upstream/kubernetes
1
0
Fork 0
mirror of https://github.com/kubernetes/kubernetes.git synced 2026-06-09 08:55:55 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove LoadBalancerIPMode feature gate

Browse source
This commit is contained in:
Dan Winship 2025-10-12 12:49:19 -04:00
parent b5297b18ab
commit 715228f478
15 changed files with 83 additions and 789 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
pkg/apis/core/v1/defaults.go
View file

@ -152,13 +152,10 @@ func SetDefaults_Service(obj *v1.Service) {
}
if obj.Spec.Type == v1.ServiceTypeLoadBalancer {
if utilfeature.DefaultFeatureGate.Enabled(features.LoadBalancerIPMode) {
ipMode := v1.LoadBalancerIPModeVIP
for i, ing := range obj.Status.LoadBalancer.Ingress {
if ing.IP != "" && ing.IPMode == nil {
obj.Status.LoadBalancer.Ingress[i].IPMode = &ipMode
}
ipMode := v1.LoadBalancerIPModeVIP
for i, ing := range obj.Status.LoadBalancer.Ingress {
if ing.IP != "" && ing.IPMode == nil {
obj.Status.LoadBalancer.Ingress[i].IPMode = &ipMode
}
}
}

25
pkg/apis/core/v1/defaults_test.go
View file

@ -31,7 +31,6 @@ import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/version"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/kubernetes/pkg/api/legacyscheme"
@ -2437,26 +2436,11 @@ func TestSetDefaultServiceLoadbalancerIPMode(t *testing.T) {
modeProxy := v1.LoadBalancerIPModeProxy
testCases := []struct {
name string
ipModeEnabled bool
svc *v1.Service
expectedIPMode []*v1.LoadBalancerIPMode
}{
{
name: "Set IP but not set IPMode with LoadbalancerIPMode disabled",
ipModeEnabled: false,
svc: &v1.Service{
Spec: v1.ServiceSpec{Type: v1.ServiceTypeLoadBalancer},
Status: v1.ServiceStatus{
LoadBalancer: v1.LoadBalancerStatus{
Ingress: []v1.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
}},
expectedIPMode: []*v1.LoadBalancerIPMode{nil},
}, {
name: "Set IP but bot set IPMode with LoadbalancerIPMode enabled",
ipModeEnabled: true,
name: "Set IP but not set IPMode",
svc: &v1.Service{
Spec: v1.ServiceSpec{Type: v1.ServiceTypeLoadBalancer},
Status: v1.ServiceStatus{
@ -2468,8 +2452,7 @@ func TestSetDefaultServiceLoadbalancerIPMode(t *testing.T) {
}},
expectedIPMode: []*v1.LoadBalancerIPMode{&modeVIP},
}, {
name: "Both IP and IPMode are set with LoadbalancerIPMode enabled",
ipModeEnabled: true,
name: "Both IP and IPMode are set",
svc: &v1.Service{
Spec: v1.ServiceSpec{Type: v1.ServiceTypeLoadBalancer},
Status: v1.ServiceStatus{
@ -2486,10 +2469,6 @@ func TestSetDefaultServiceLoadbalancerIPMode(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
if !tc.ipModeEnabled {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
}
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, tc.ipModeEnabled)
obj := roundTrip(t, runtime.Object(tc.svc))
svc := obj.(*v1.Service)
for i, s := range svc.Status.LoadBalancer.Ingress {

2
pkg/apis/core/validation/validation.go
View file

@ -8407,7 +8407,7 @@ func ValidateLoadBalancerStatus(status, oldStatus *core.LoadBalancerStatus, fldP
allErrs = append(allErrs, IsValidIPForLegacyField(idxPath.Child("ip"), ingress.IP, existingIngressIPs)...)
}
if utilfeature.DefaultFeatureGate.Enabled(features.LoadBalancerIPMode) && ingress.IPMode == nil {
if ingress.IPMode == nil {
if len(ingress.IP) > 0 {
allErrs = append(allErrs, field.Required(idxPath.Child("ipMode"), "must be specified when `ip` is set"))
}

42
pkg/apis/core/validation/validation_test.go
View file

@ -26912,7 +26912,6 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
testCases := []struct {
name string
ipModeEnabled bool
legacyIPs bool
tweakOldLBStatus func(s *core.LoadBalancerStatus)
tweakLBStatus func(s *core.LoadBalancerStatus)
@ -26931,8 +26930,7 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
},
numErrs: 1,
}, {
name: "valid vip ipMode",
ipModeEnabled: true,
name: "valid vip ipMode",
tweakLBStatus: func(s *core.LoadBalancerStatus) {
s.Ingress = []core.LoadBalancerIngress{{
IP: "1.2.3.4",
@ -26941,8 +26939,7 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
},
numErrs: 0,
}, {
name: "valid proxy ipMode",
ipModeEnabled: true,
name: "valid proxy ipMode",
tweakLBStatus: func(s *core.LoadBalancerStatus) {
s.Ingress = []core.LoadBalancerIngress{{
IP: "1.2.3.4",
@ -26951,8 +26948,7 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
},
numErrs: 0,
}, {
name: "invalid ipMode",
ipModeEnabled: true,
name: "invalid ipMode",
tweakLBStatus: func(s *core.LoadBalancerStatus) {
s.Ingress = []core.LoadBalancerIngress{{
IP: "1.2.3.4",
@ -26961,8 +26957,7 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
},
numErrs: 1,
}, {
name: "missing ipMode with LoadbalancerIPMode enabled",
ipModeEnabled: true,
name: "missing ipMode",
tweakLBStatus: func(s *core.LoadBalancerStatus) {
s.Ingress = []core.LoadBalancerIngress{{
IP: "1.2.3.4",
@ -26970,17 +26965,7 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
},
numErrs: 1,
}, {
name: "missing ipMode with LoadbalancerIPMode disabled",
ipModeEnabled: false,
tweakLBStatus: func(s *core.LoadBalancerStatus) {
s.Ingress = []core.LoadBalancerIngress{{
IP: "1.2.3.4",
}}
},
numErrs: 0,
}, {
name: "missing ip with ipMode present",
ipModeEnabled: true,
name: "missing ip with ipMode present",
tweakLBStatus: func(s *core.LoadBalancerStatus) {
s.Ingress = []core.LoadBalancerIngress{{
IPMode: &ipModeProxy,
@ -26988,9 +26973,8 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
},
numErrs: 1,
}, {
name: "legacy IP with legacy validation",
ipModeEnabled: true,
legacyIPs: true,
name: "legacy IP with legacy validation",
legacyIPs: true,
tweakLBStatus: func(s *core.LoadBalancerStatus) {
s.Ingress = []core.LoadBalancerIngress{{
IP: "001.002.003.004",
@ -26999,8 +26983,7 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
},
numErrs: 0,
}, {
name: "legacy IP with strict validation",
ipModeEnabled: true,
name: "legacy IP with strict validation",
tweakLBStatus: func(s *core.LoadBalancerStatus) {
s.Ingress = []core.LoadBalancerIngress{{
IP: "001.002.003.004",
@ -27060,14 +27043,7 @@ func TestValidateLoadBalancerStatus(t *testing.T) {
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
if !tc.ipModeEnabled {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
} else {
// (This feature gate doesn't exist in 1.31 so we can't set it
// when testing !ipModeEnabled.)
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StrictIPCIDRValidation, !tc.legacyIPs)
}
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, tc.ipModeEnabled)
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StrictIPCIDRValidation, !tc.legacyIPs)
oldStatus := core.LoadBalancerStatus{}
if tc.tweakOldLBStatus != nil {
tc.tweakOldLBStatus(&oldStatus)

13
pkg/features/kube_features.go
View file

@ -518,11 +518,6 @@ const (
// Add support for distributed tracing in the kubelet
KubeletTracing featuregate.Feature = "KubeletTracing"
// owner: @Sh4d1,@RyanAoh,@rikatz
// kep: http://kep.k8s.io/1860
// LoadBalancerIPMode enables the IPMode field in the LoadBalancerIngress status of a Service
LoadBalancerIPMode featuregate.Feature = "LoadBalancerIPMode"
// owner: @RobertKrawitz
//
// Allow use of filesystems for ephemeral storage monitoring.
@ -1374,12 +1369,6 @@ var defaultVersionedKubernetesFeatureGates = map[featuregate.Feature]featuregate
{Version: version.MustParse("1.34"), Default: true, PreRelease: featuregate.GA, LockToDefault: true}, // remove in 1.37
},
LoadBalancerIPMode: {
{Version: version.MustParse("1.29"), Default: false, PreRelease: featuregate.Alpha},
{Version: version.MustParse("1.30"), Default: true, PreRelease: featuregate.Beta},
{Version: version.MustParse("1.32"), Default: true, PreRelease: featuregate.GA, LockToDefault: true},
},
LocalStorageCapacityIsolationFSQuotaMonitoring: {
{Version: version.MustParse("1.15"), Default: false, PreRelease: featuregate.Alpha},
{Version: version.MustParse("1.31"), Default: false, PreRelease: featuregate.Beta},
@ -2143,8 +2132,6 @@ var defaultKubernetesFeatureGateDependencies = map[featuregate.Feature][]feature
KubeletTracing: {},
LoadBalancerIPMode: {},
LocalStorageCapacityIsolationFSQuotaMonitoring: {},
LogarithmicScaleDown: {},

78
pkg/proxy/iptables/proxier_test.go
View file

@ -42,14 +42,10 @@ import (
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/apimachinery/pkg/util/version"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/component-base/metrics/legacyregistry"
"k8s.io/component-base/metrics/testutil"
"k8s.io/klog/v2"
klogtesting "k8s.io/klog/v2/ktesting"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/proxy"
kubeproxyconfig "k8s.io/kubernetes/pkg/proxy/apis/config"
"k8s.io/kubernetes/pkg/proxy/conntrack"
@ -6527,62 +6523,32 @@ func TestNoEndpointsMetric(t *testing.T) {
func TestLoadBalancerIngressRouteTypeProxy(t *testing.T) {
testCases := []struct {
name string
ipModeEnabled bool
svcIP string
svcLBIP string
ipMode *v1.LoadBalancerIPMode
expectedRule bool
name string
svcIP string
svcLBIP string
ipMode *v1.LoadBalancerIPMode
expectedRule bool
}{
/* LoadBalancerIPMode disabled */
{
name: "LoadBalancerIPMode disabled, ipMode Proxy",
ipModeEnabled: false,
svcIP: "10.20.30.41",
svcLBIP: "1.2.3.4",
ipMode: ptr.To(v1.LoadBalancerIPModeProxy),
expectedRule: true,
name: "ipMode Proxy",
svcIP: "10.20.30.41",
svcLBIP: "1.2.3.4",
ipMode: ptr.To(v1.LoadBalancerIPModeProxy),
expectedRule: false,
},
{
name: "LoadBalancerIPMode disabled, ipMode VIP",
ipModeEnabled: false,
svcIP: "10.20.30.42",
svcLBIP: "1.2.3.5",
ipMode: ptr.To(v1.LoadBalancerIPModeVIP),
expectedRule: true,
name: "ipMode VIP",
svcIP: "10.20.30.42",
svcLBIP: "1.2.3.5",
ipMode: ptr.To(v1.LoadBalancerIPModeVIP),
expectedRule: true,
},
{
name: "LoadBalancerIPMode disabled, ipMode nil",
ipModeEnabled: false,
svcIP: "10.20.30.43",
svcLBIP: "1.2.3.6",
ipMode: nil,
expectedRule: true,
},
/* LoadBalancerIPMode enabled */
{
name: "LoadBalancerIPMode enabled, ipMode Proxy",
ipModeEnabled: true,
svcIP: "10.20.30.41",
svcLBIP: "1.2.3.4",
ipMode: ptr.To(v1.LoadBalancerIPModeProxy),
expectedRule: false,
},
{
name: "LoadBalancerIPMode enabled, ipMode VIP",
ipModeEnabled: true,
svcIP: "10.20.30.42",
svcLBIP: "1.2.3.5",
ipMode: ptr.To(v1.LoadBalancerIPModeVIP),
expectedRule: true,
},
{
name: "LoadBalancerIPMode enabled, ipMode nil",
ipModeEnabled: true,
svcIP: "10.20.30.43",
svcLBIP: "1.2.3.6",
ipMode: nil,
expectedRule: true,
name: "ipMode nil",
svcIP: "10.20.30.43",
svcLBIP: "1.2.3.6",
ipMode: nil,
expectedRule: true,
},
}
@ -6596,10 +6562,6 @@ func TestLoadBalancerIngressRouteTypeProxy(t *testing.T) {
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
if !testCase.ipModeEnabled {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
}
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, testCase.ipModeEnabled)
ipt := iptablestest.NewFake()
fp := NewFakeProxier(ipt)
makeServiceMap(fp,

44
pkg/proxy/ipvs/proxier_test.go
View file

@ -39,11 +39,7 @@ import (
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/apimachinery/pkg/util/version"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/component-base/metrics/testutil"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/proxy"
kubeproxyconfig "k8s.io/kubernetes/pkg/proxy/apis/config"
"k8s.io/kubernetes/pkg/proxy/conntrack"
@ -5762,57 +5758,27 @@ func TestDismissLocalhostRuleExist(t *testing.T) {
func TestLoadBalancerIngressRouteTypeProxy(t *testing.T) {
testCases := []struct {
name string
ipModeEnabled bool
svcIP string
svcLBIP string
ipMode *v1.LoadBalancerIPMode
expectedServices int
}{
/* LoadBalancerIPMode disabled */
{
name: "LoadBalancerIPMode disabled, ipMode Proxy",
ipModeEnabled: false,
svcIP: "10.20.30.41",
svcLBIP: "1.2.3.4",
ipMode: ptr.To(v1.LoadBalancerIPModeProxy),
expectedServices: 2,
},
{
name: "LoadBalancerIPMode disabled, ipMode VIP",
ipModeEnabled: false,
svcIP: "10.20.30.42",
svcLBIP: "1.2.3.5",
ipMode: ptr.To(v1.LoadBalancerIPModeVIP),
expectedServices: 2,
},
{
name: "LoadBalancerIPMode disabled, ipMode nil",
ipModeEnabled: false,
svcIP: "10.20.30.43",
svcLBIP: "1.2.3.6",
ipMode: nil,
expectedServices: 2,
},
/* LoadBalancerIPMode enabled */
{
name: "LoadBalancerIPMode enabled, ipMode Proxy",
ipModeEnabled: true,
name: "ipMode Proxy",
svcIP: "10.20.30.41",
svcLBIP: "1.2.3.4",
ipMode: ptr.To(v1.LoadBalancerIPModeProxy),
expectedServices: 1,
},
{
name: "LoadBalancerIPMode enabled, ipMode VIP",
ipModeEnabled: true,
name: "ipMode VIP",
svcIP: "10.20.30.42",
svcLBIP: "1.2.3.5",
ipMode: ptr.To(v1.LoadBalancerIPModeVIP),
expectedServices: 2,
},
{
name: "LoadBalancerIPMode enabled, ipMode nil",
ipModeEnabled: true,
name: "ipMode nil",
svcIP: "10.20.30.43",
svcLBIP: "1.2.3.6",
ipMode: nil,
@ -5829,10 +5795,6 @@ func TestLoadBalancerIngressRouteTypeProxy(t *testing.T) {
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
if !testCase.ipModeEnabled {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
}
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, testCase.ipModeEnabled)
_, fp := buildFakeProxier(t)
makeServiceMap(fp,
makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) {

78
pkg/proxy/nftables/proxier_test.go
View file

@ -36,11 +36,7 @@ import (
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/sets"
"k8s.io/apimachinery/pkg/util/version"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/component-base/metrics/testutil"
"k8s.io/kubernetes/pkg/features"
"k8s.io/kubernetes/pkg/proxy"
kubeproxyconfig "k8s.io/kubernetes/pkg/proxy/apis/config"
"k8s.io/kubernetes/pkg/proxy/conntrack"
@ -4616,62 +4612,32 @@ func TestNoEndpointsMetric(t *testing.T) {
func TestLoadBalancerIngressRouteTypeProxy(t *testing.T) {
testCases := []struct {
name string
ipModeEnabled bool
svcIP string
svcLBIP string
ipMode *v1.LoadBalancerIPMode
expectedRule bool
name string
svcIP string
svcLBIP string
ipMode *v1.LoadBalancerIPMode
expectedRule bool
}{
/* LoadBalancerIPMode disabled */
{
name: "LoadBalancerIPMode disabled, ipMode Proxy",
ipModeEnabled: false,
svcIP: "10.20.30.41",
svcLBIP: "1.2.3.4",
ipMode: ptr.To(v1.LoadBalancerIPModeProxy),
expectedRule: true,
name: "ipMode Proxy",
svcIP: "10.20.30.41",
svcLBIP: "1.2.3.4",
ipMode: ptr.To(v1.LoadBalancerIPModeProxy),
expectedRule: false,
},
{
name: "LoadBalancerIPMode disabled, ipMode VIP",
ipModeEnabled: false,
svcIP: "10.20.30.42",
svcLBIP: "1.2.3.5",
ipMode: ptr.To(v1.LoadBalancerIPModeVIP),
expectedRule: true,
name: "ipMode VIP",
svcIP: "10.20.30.42",
svcLBIP: "1.2.3.5",
ipMode: ptr.To(v1.LoadBalancerIPModeVIP),
expectedRule: true,
},
{
name: "LoadBalancerIPMode disabled, ipMode nil",
ipModeEnabled: false,
svcIP: "10.20.30.43",
svcLBIP: "1.2.3.6",
ipMode: nil,
expectedRule: true,
},
/* LoadBalancerIPMode enabled */
{
name: "LoadBalancerIPMode enabled, ipMode Proxy",
ipModeEnabled: true,
svcIP: "10.20.30.41",
svcLBIP: "1.2.3.4",
ipMode: ptr.To(v1.LoadBalancerIPModeProxy),
expectedRule: false,
},
{
name: "LoadBalancerIPMode enabled, ipMode VIP",
ipModeEnabled: true,
svcIP: "10.20.30.42",
svcLBIP: "1.2.3.5",
ipMode: ptr.To(v1.LoadBalancerIPModeVIP),
expectedRule: true,
},
{
name: "LoadBalancerIPMode enabled, ipMode nil",
ipModeEnabled: true,
svcIP: "10.20.30.43",
svcLBIP: "1.2.3.6",
ipMode: nil,
expectedRule: true,
name: "ipMode nil",
svcIP: "10.20.30.43",
svcLBIP: "1.2.3.6",
ipMode: nil,
expectedRule: true,
},
}
@ -4685,10 +4651,6 @@ func TestLoadBalancerIngressRouteTypeProxy(t *testing.T) {
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
if !testCase.ipModeEnabled {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
}
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, testCase.ipModeEnabled)
nft, fp := NewFakeProxier(v1.IPv4Protocol)
makeServiceMap(fp,
makeTestService(svcPortName.Namespace, svcPortName.Name, func(svc *v1.Service) {

65
pkg/proxy/servicechangetracker_test.go
View file

@ -27,10 +27,6 @@ import (
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/dump"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/version"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
"k8s.io/kubernetes/pkg/features"
netutils "k8s.io/utils/net"
)
@ -117,11 +113,10 @@ func TestServiceToServiceMap(t *testing.T) {
ipModeProxy := v1.LoadBalancerIPModeProxy
testCases := []struct {
desc string
service *v1.Service
expected map[ServicePortName]*BaseServicePortInfo
ipFamily v1.IPFamily
ipModeEnabled bool
desc string
service *v1.Service
expected map[ServicePortName]*BaseServicePortInfo
ipFamily v1.IPFamily
}{
{
desc: "nothing",
@ -214,7 +209,7 @@ func TestServiceToServiceMap(t *testing.T) {
},
},
{
desc: "load balancer service ipMode VIP feature gate disable",
desc: "load balancer service ipMode VIP",
ipFamily: v1.IPv4Protocol,
service: makeTestService("ns1", "load-balancer", func(svc *v1.Service) {
@ -235,53 +230,9 @@ func TestServiceToServiceMap(t *testing.T) {
},
},
{
desc: "load balancer service ipMode Proxy feature gate disable",
desc: "load balancer service ipMode Proxy",
ipFamily: v1.IPv4Protocol,
service: makeTestService("ns1", "load-balancer", func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer
svc.Spec.ClusterIP = "172.16.55.11"
svc.Spec.LoadBalancerIP = "5.6.7.8"
svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port3", "UDP", 8675, 30061, 7000)
svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port4", "UDP", 8676, 30062, 7001)
svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{IP: "10.1.2.4", IPMode: &ipModeProxy}}
}),
expected: map[ServicePortName]*BaseServicePortInfo{
makeServicePortName("ns1", "load-balancer", "port3", v1.ProtocolUDP): makeTestServiceInfo("172.16.55.11", 8675, "UDP", 0, func(bsvcPortInfo *BaseServicePortInfo) {
bsvcPortInfo.loadBalancerVIPs = makeIPs("10.1.2.4")
}),
makeServicePortName("ns1", "load-balancer", "port4", v1.ProtocolUDP): makeTestServiceInfo("172.16.55.11", 8676, "UDP", 0, func(bsvcPortInfo *BaseServicePortInfo) {
bsvcPortInfo.loadBalancerVIPs = makeIPs("10.1.2.4")
}),
},
},
{
desc: "load balancer service ipMode VIP feature gate enabled",
ipFamily: v1.IPv4Protocol,
ipModeEnabled: true,
service: makeTestService("ns1", "load-balancer", func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer
svc.Spec.ClusterIP = "172.16.55.11"
svc.Spec.LoadBalancerIP = "5.6.7.8"
svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port3", "UDP", 8675, 30061, 7000)
svc.Spec.Ports = addTestPort(svc.Spec.Ports, "port4", "UDP", 8676, 30062, 7001)
svc.Status.LoadBalancer.Ingress = []v1.LoadBalancerIngress{{IP: "10.1.2.4", IPMode: &ipModeVIP}}
}),
expected: map[ServicePortName]*BaseServicePortInfo{
makeServicePortName("ns1", "load-balancer", "port3", v1.ProtocolUDP): makeTestServiceInfo("172.16.55.11", 8675, "UDP", 0, func(bsvcPortInfo *BaseServicePortInfo) {
bsvcPortInfo.loadBalancerVIPs = makeIPs("10.1.2.4")
}),
makeServicePortName("ns1", "load-balancer", "port4", v1.ProtocolUDP): makeTestServiceInfo("172.16.55.11", 8676, "UDP", 0, func(bsvcPortInfo *BaseServicePortInfo) {
bsvcPortInfo.loadBalancerVIPs = makeIPs("10.1.2.4")
}),
},
},
{
desc: "load balancer service ipMode Proxy feature gate enabled",
ipFamily: v1.IPv4Protocol,
ipModeEnabled: true,
service: makeTestService("ns1", "load-balancer", func(svc *v1.Service) {
svc.Spec.Type = v1.ServiceTypeLoadBalancer
svc.Spec.ClusterIP = "172.16.55.11"
@ -573,10 +524,6 @@ func TestServiceToServiceMap(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.desc, func(t *testing.T) {
if !tc.ipModeEnabled {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
}
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, tc.ipModeEnabled)
svcTracker := NewServiceChangeTracker(tc.ipFamily, nil, nil)
// outputs
newServices := svcTracker.serviceToServiceMap(tc.service)

5
pkg/proxy/util/utils.go
View file

@ -24,11 +24,9 @@ import (
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/util/sets"
utilfeature "k8s.io/apiserver/pkg/util/feature"
utilsysctl "k8s.io/component-helpers/node/util/sysctl"
"k8s.io/klog/v2"
"k8s.io/kubernetes/pkg/apis/core/v1/helper"
"k8s.io/kubernetes/pkg/features"
netutils "k8s.io/utils/net"
)
@ -216,9 +214,6 @@ func GetClusterIPByFamily(ipFamily v1.IPFamily, service *v1.Service) string {
}
func IsVIPMode(ing v1.LoadBalancerIngress) bool {
if !utilfeature.DefaultFeatureGate.Enabled(features.LoadBalancerIPMode) {
return true // backwards compat
}
if ing.IPMode == nil {
return true
}

185
pkg/registry/core/service/storage/storage_test.go
View file

@ -35,18 +35,14 @@ import (
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/intstr"
machineryutilnet "k8s.io/apimachinery/pkg/util/net"
"k8s.io/apimachinery/pkg/util/version"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/generic"
genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
"k8s.io/apiserver/pkg/registry/rest"
etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
epstest "k8s.io/kubernetes/pkg/api/endpoints/testing"
svctest "k8s.io/kubernetes/pkg/api/service/testing"
api "k8s.io/kubernetes/pkg/apis/core"
"k8s.io/kubernetes/pkg/features"
endpointstore "k8s.io/kubernetes/pkg/registry/core/endpoint/storage"
podstore "k8s.io/kubernetes/pkg/registry/core/pod/storage"
"k8s.io/kubernetes/pkg/registry/core/service/ipallocator"
@ -11763,132 +11759,14 @@ func TestUpdateServiceLoadBalancerStatus(t *testing.T) {
testCases := []struct {
name string
ipModeEnabled bool
statusBeforeUpdate api.ServiceStatus
newStatus api.ServiceStatus
expectedStatus api.ServiceStatus
expectErr bool
expectedReasonForError metav1.StatusReason
}{
/*LoadBalancerIPMode disabled*/
{
name: "LoadBalancerIPMode disabled, ipMode not used in old, not used in new",
ipModeEnabled: false,
statusBeforeUpdate: api.ServiceStatus{},
newStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
},
expectedStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
},
expectErr: false,
}, {
name: "LoadBalancerIPMode disabled, ipMode used in old and in new",
ipModeEnabled: false,
statusBeforeUpdate: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeVIP,
}},
},
},
newStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
},
},
expectedStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
},
},
expectErr: false,
}, {
name: "LoadBalancerIPMode disabled, ipMode not used in old, used in new",
ipModeEnabled: false,
statusBeforeUpdate: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
},
newStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
},
},
expectedStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
},
expectErr: false,
}, {
name: "LoadBalancerIPMode disabled, ipMode used in old, not used in new",
ipModeEnabled: false,
statusBeforeUpdate: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeVIP,
}},
},
},
newStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
},
expectedStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
},
expectErr: false,
},
/*LoadBalancerIPMode enabled*/
{
name: "LoadBalancerIPMode enabled, ipMode not used in old, not used in new",
ipModeEnabled: true,
statusBeforeUpdate: api.ServiceStatus{},
newStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
},
expectedStatus: api.ServiceStatus{},
expectErr: true,
expectedReasonForError: metav1.StatusReasonInvalid,
}, {
name: "LoadBalancerIPMode enabled, ipMode used in old and in new",
ipModeEnabled: true,
name: "ipMode used in old and in new",
statusBeforeUpdate: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
@ -11915,35 +11793,7 @@ func TestUpdateServiceLoadBalancerStatus(t *testing.T) {
},
expectErr: false,
}, {
name: "LoadBalancerIPMode enabled, ipMode not used in old, used in new",
ipModeEnabled: true,
statusBeforeUpdate: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
},
},
newStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
},
},
expectedStatus: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
},
},
expectErr: false,
}, {
name: "LoadBalancerIPMode enabled, ipMode used in old, not used in new",
ipModeEnabled: true,
name: "ipMode used in old, not used in new",
statusBeforeUpdate: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
@ -11963,12 +11813,12 @@ func TestUpdateServiceLoadBalancerStatus(t *testing.T) {
expectErr: true,
expectedReasonForError: metav1.StatusReasonInvalid,
}, {
name: "LoadBalancerIPMode enabled, ipMode not used in old, invalid value used in new",
ipModeEnabled: true,
name: "ipMode used in old, invalid value used in new",
statusBeforeUpdate: api.ServiceStatus{
LoadBalancer: api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IP: "1.2.3.4",
IPMode: &ipModeVIP,
}},
},
},
@ -11993,28 +11843,18 @@ func TestUpdateServiceLoadBalancerStatus(t *testing.T) {
ctx := genericapirequest.NewDefaultContext()
obj, err := storage.Create(ctx, svc, rest.ValidateAllObjectFunc, &metav1.CreateOptions{})
if err != nil {
t.Errorf("created svc: %s", err)
t.Fatalf("created svc: %s", err)
}
defer storage.Delete(ctx, svc.Name, rest.ValidateAllObjectFunc, &metav1.DeleteOptions{})
// prepare status
// Test here is negative, because starting with v1.30 the feature gate is enabled by default, so we should
// now disable it to do the proper test
if !loadbalancerIPModeInUse(tc.statusBeforeUpdate) {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, false)
}
oldSvc := obj.(*api.Service).DeepCopy()
oldSvc.Status = tc.statusBeforeUpdate
obj, _, err = statusStorage.Update(ctx, oldSvc.Name, rest.DefaultUpdatedObjectInfo(oldSvc), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
if err != nil {
t.Errorf("updated status: %s", err)
t.Fatalf("updated status: %s", err)
}
if !tc.ipModeEnabled {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
}
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, tc.ipModeEnabled)
newSvc := obj.(*api.Service).DeepCopy()
newSvc.Status = tc.newStatus
obj, _, err = statusStorage.Update(ctx, newSvc.Name, rest.DefaultUpdatedObjectInfo(newSvc), rest.ValidateAllObjectFunc, rest.ValidateAllObjectUpdateFunc, false, &metav1.UpdateOptions{})
@ -12022,7 +11862,7 @@ func TestUpdateServiceLoadBalancerStatus(t *testing.T) {
if tc.expectErr && tc.expectedReasonForError == errors.ReasonForError(err) {
return
}
t.Errorf("updated status: %s", err)
t.Fatalf("updated status: %s", err)
}
updated := obj.(*api.Service)
@ -12032,12 +11872,3 @@ func TestUpdateServiceLoadBalancerStatus(t *testing.T) {
})
}
}
func loadbalancerIPModeInUse(status api.ServiceStatus) bool {
for _, ing := range status.LoadBalancer.Ingress {
if ing.IPMode != nil {
return true
}
}
return false
}

21
pkg/registry/core/service/strategy.go
View file

@ -218,26 +218,7 @@ func SelectableFields(service *api.Service) fields.Set {
// if !utilfeature.DefaultFeatureGate.Enabled(features.MyFeature) && !myFeatureInUse(oldSvc) {
// newSvc.Status.MyFeature = nil
// }
func dropServiceStatusDisabledFields(newSvc *api.Service, oldSvc *api.Service) {
if !utilfeature.DefaultFeatureGate.Enabled(features.LoadBalancerIPMode) && !loadbalancerIPModeInUse(oldSvc) {
for i := range newSvc.Status.LoadBalancer.Ingress {
newSvc.Status.LoadBalancer.Ingress[i].IPMode = nil
}
}
}
// returns true when the LoadBalancer Ingress IPMode fields are in use.
func loadbalancerIPModeInUse(svc *api.Service) bool {
if svc == nil {
return false
}
for _, ing := range svc.Status.LoadBalancer.Ingress {
if ing.IPMode != nil {
return true
}
}
return false
}
func dropServiceStatusDisabledFields(newSvc *api.Service, oldSvc *api.Service) {}
func sameStringSlice(a []string, b []string) bool {
if len(a) != len(b) {

252
pkg/registry/core/service/strategy_test.go
View file

@ -28,14 +28,10 @@ import (
"k8s.io/apimachinery/pkg/labels"
"k8s.io/apimachinery/pkg/selection"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/apimachinery/pkg/util/version"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/rest"
utilfeature "k8s.io/apiserver/pkg/util/feature"
featuregatetesting "k8s.io/component-base/featuregate/testing"
api "k8s.io/kubernetes/pkg/apis/core"
_ "k8s.io/kubernetes/pkg/apis/core/install"
"k8s.io/kubernetes/pkg/features"
"k8s.io/utils/ptr"
)
@ -253,254 +249,6 @@ func TestDropDisabledField(t *testing.T) {
}
func TestDropServiceStatusDisabledFields(t *testing.T) {
ipModeVIP := api.LoadBalancerIPModeVIP
ipModeProxy := api.LoadBalancerIPModeProxy
testCases := []struct {
name string
ipModeEnabled bool
svc *api.Service
oldSvc *api.Service
compareSvc *api.Service
}{
/*LoadBalancerIPMode disabled*/
{
name: "LoadBalancerIPMode disabled, ipMode not used in old, not used in new",
ipModeEnabled: false,
svc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
oldSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{}
}),
compareSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
}, {
name: "LoadBalancerIPMode disabled, ipMode used in old and in new",
ipModeEnabled: false,
svc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
}
}),
oldSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeVIP,
}},
}
}),
compareSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
}
}),
}, {
name: "LoadBalancerIPMode disabled, ipMode not used in old, used in new",
ipModeEnabled: false,
svc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeVIP,
}},
}
}),
oldSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
compareSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
}, {
name: "LoadBalancerIPMode disabled, ipMode used in old, not used in new",
ipModeEnabled: false,
svc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
oldSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
}
}),
compareSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
},
/*LoadBalancerIPMode enabled*/
{
name: "LoadBalancerIPMode enabled, ipMode not used in old, not used in new",
ipModeEnabled: true,
svc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
oldSvc: nil,
compareSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
}, {
name: "LoadBalancerIPMode enabled, ipMode used in old and in new",
ipModeEnabled: true,
svc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
}
}),
oldSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeVIP,
}},
}
}),
compareSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
}
}),
}, {
name: "LoadBalancerIPMode enabled, ipMode not used in old, used in new",
ipModeEnabled: true,
svc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeVIP,
}},
}
}),
oldSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
compareSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeVIP,
}},
}
}),
}, {
name: "LoadBalancerIPMode enabled, ipMode used in old, not used in new",
ipModeEnabled: true,
svc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
oldSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
IPMode: &ipModeProxy,
}},
}
}),
compareSvc: makeValidServiceCustom(func(svc *api.Service) {
svc.Spec.Type = api.ServiceTypeLoadBalancer
svc.Status.LoadBalancer = api.LoadBalancerStatus{
Ingress: []api.LoadBalancerIngress{{
IP: "1.2.3.4",
}},
}
}),
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
if !tc.ipModeEnabled {
featuregatetesting.SetFeatureGateEmulationVersionDuringTest(t, utilfeature.DefaultFeatureGate, version.MustParse("1.31"))
}
featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.LoadBalancerIPMode, tc.ipModeEnabled)
dropServiceStatusDisabledFields(tc.svc, tc.oldSvc)
if !reflect.DeepEqual(tc.svc, tc.compareSvc) {
t.Errorf("%v: unexpected svc spec: %v", tc.name, cmp.Diff(tc.svc, tc.compareSvc))
}
})
}
}
func TestDropTypeDependentFields(t *testing.T) {
// Tweaks used below.
setTypeExternalName := func(svc *api.Service) {

14
test/compatibility_lifecycle/reference/versioned_feature_list.yaml
View file

@ -879,20 +879,6 @@
lockToDefault: false
preRelease: Beta
version: "1.34"
- name: LoadBalancerIPMode
versionedSpecs:
- default: false
lockToDefault: false
preRelease: Alpha
version: "1.29"
- default: true
lockToDefault: false
preRelease: Beta
version: "1.30"
- default: true
lockToDefault: true
preRelease: GA
version: "1.32"
- name: LocalStorageCapacityIsolationFSQuotaMonitoring
versionedSpecs:
- default: false

37
test/integration/service/loadbalancer_test.go
View file

@ -19,7 +19,6 @@ package service
import (
"context"
"encoding/json"
"fmt"
"testing"
"time"
@ -657,24 +656,13 @@ func Test_ServiceLoadBalancerIPMode(t *testing.T) {
}
testCases := []struct {
ipModeEnabled bool
setIPMode *corev1.LoadBalancerIPMode
externalIP string
expectedIngress corev1.LoadBalancerIngress
}{
{
ipModeEnabled: false,
externalIP: "1.2.3.4",
expectedIngress: corev1.LoadBalancerIngress{
IP: "1.2.3.4",
IPMode: nil,
Ports: []corev1.PortStatus{{Port: 80, Protocol: corev1.ProtocolTCP}},
},
},
{
ipModeEnabled: true,
setIPMode: nil,
externalIP: "1.2.3.4",
setIPMode: nil,
externalIP: "1.2.3.4",
expectedIngress: corev1.LoadBalancerIngress{
IP: "1.2.3.4",
IPMode: ptr.To(corev1.LoadBalancerIPModeVIP),
@ -682,9 +670,8 @@ func Test_ServiceLoadBalancerIPMode(t *testing.T) {
},
},
{
ipModeEnabled: true,
setIPMode: ptr.To(corev1.LoadBalancerIPModeVIP),
externalIP: "1.2.3.4",
setIPMode: ptr.To(corev1.LoadBalancerIPModeVIP),
externalIP: "1.2.3.4",
expectedIngress: corev1.LoadBalancerIngress{
IP: "1.2.3.4",
IPMode: ptr.To(corev1.LoadBalancerIPModeVIP),
@ -692,9 +679,8 @@ func Test_ServiceLoadBalancerIPMode(t *testing.T) {
},
},
{
ipModeEnabled: true,
setIPMode: ptr.To(corev1.LoadBalancerIPModeProxy),
externalIP: "1.2.3.4",
setIPMode: ptr.To(corev1.LoadBalancerIPModeProxy),
externalIP: "1.2.3.4",
expectedIngress: corev1.LoadBalancerIngress{
IP: "1.2.3.4",
IPMode: ptr.To(corev1.LoadBalancerIPModeProxy),
@ -705,12 +691,7 @@ func Test_ServiceLoadBalancerIPMode(t *testing.T) {
for _, tc := range testCases {
t.Run("", func(t *testing.T) {
serverFlags := framework.DefaultTestServerFlags()
if !tc.ipModeEnabled {
serverFlags = append(serverFlags, "--emulated-version=1.31")
}
serverFlags = append(serverFlags, fmt.Sprintf("--feature-gates=LoadBalancerIPMode=%v", tc.ipModeEnabled))
server := kubeapiservertesting.StartTestServerOrDie(t, nil, serverFlags, framework.SharedEtcd())
server := kubeapiservertesting.StartTestServerOrDie(t, nil, framework.DefaultTestServerFlags(), framework.SharedEtcd())
defer server.TearDownFn()
client, err := clientset.NewForConfig(server.ClientConfig)
@ -751,8 +732,8 @@ func Test_ServiceLoadBalancerIPMode(t *testing.T) {
ingress := service.Status.LoadBalancer.Ingress[0]
if !apiequality.Semantic.DeepEqual(&ingress, &tc.expectedIngress) {
t.Errorf("expected Ingress %v, got IP %v",
ingress, tc.expectedIngress)
t.Errorf("expected Ingress %v, got %v",
tc.expectedIngress, ingress)
if ingress.IPMode != nil && tc.expectedIngress.IPMode != nil {
t.Logf("IPMode %v expected %v", *ingress.IPMode, *tc.expectedIngress.IPMode)
}