github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-04 01:40:07 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #88487 from zioproto/issues/69314-tier-config-support

Browse Source 
Use compute v1 api to specify network tier
This commit is contained in:
Kubernetes Prow Robot 2020-03-03 12:16:52 -08:00 committed by GitHub
commit 481b04cf7c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 38 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
staging/src/k8s.io/legacy-cloud-providers/gce/gce_loadbalancer_external.go
View File

@ -33,7 +33,6 @@ import (
servicehelpers "k8s.io/cloud-provider/service/helpers" servicehelpers "k8s.io/cloud-provider/service/helpers"
utilnet "k8s.io/utils/net" utilnet "k8s.io/utils/net"
computealpha "google.golang.org/api/compute/v0.alpha"
compute "google.golang.org/api/compute/v1" compute "google.golang.org/api/compute/v1"
"k8s.io/klog" "k8s.io/klog"
) )
@ -932,30 +931,18 @@ func createForwardingRule(s CloudForwardingRuleService, name, serviceName, regio
desc := makeServiceDescription(serviceName) desc := makeServiceDescription(serviceName)
ipProtocol := string(ports[0].Protocol) ipProtocol := string(ports[0].Protocol)
switch netTier { rule := &compute.ForwardingRule{
case cloud.NetworkTierPremium: Name: name,
rule := &compute.ForwardingRule{ Description: desc,
Name: name, IPAddress: ipAddress,
Description: desc, IPProtocol: ipProtocol,
IPAddress: ipAddress, PortRange: portRange,
IPProtocol: ipProtocol, Target: target,
PortRange: portRange, NetworkTier: netTier.ToGCEValue(),
Target: target,
}
err = s.CreateRegionForwardingRule(rule, region)
default:
rule := &computealpha.ForwardingRule{
Name: name,
Description: desc,
IPAddress: ipAddress,
IPProtocol: ipProtocol,
PortRange: portRange,
Target: target,
NetworkTier: netTier.ToGCEValue(),
}
err = s.CreateAlphaRegionForwardingRule(rule, region)
} }
err = s.CreateRegionForwardingRule(rule, region)
if err != nil && !isHTTPErrorCode(err, http.StatusConflict) { if err != nil && !isHTTPErrorCode(err, http.StatusConflict) {
return err return err
} }
@ -1045,27 +1032,15 @@ func ensureStaticIP(s CloudAddressService, name, serviceName, region, existingIP
desc := makeServiceDescription(serviceName) desc := makeServiceDescription(serviceName)
var creationErr error var creationErr error
switch netTier { addressObj := &compute.Address{
case cloud.NetworkTierPremium: Name: name,
addressObj := &compute.Address{ Description: desc,
Name: name, NetworkTier: netTier.ToGCEValue(),
Description: desc,
}
if existingIP != "" {
addressObj.Address = existingIP
}
creationErr = s.ReserveRegionAddress(addressObj, region)
default:
addressObj := &computealpha.Address{
Name: name,
Description: desc,
NetworkTier: netTier.ToGCEValue(),
}
if existingIP != "" {
addressObj.Address = existingIP
}
creationErr = s.ReserveAlphaRegionAddress(addressObj, region)
} }
if existingIP != "" {
addressObj.Address = existingIP
}
creationErr = s.ReserveRegionAddress(addressObj, region)
if creationErr != nil { if creationErr != nil {
// GCE returns StatusConflict if the name conflicts; it returns // GCE returns StatusConflict if the name conflicts; it returns

41
staging/src/k8s.io/legacy-cloud-providers/gce/gce_loadbalancer_external_test.go
View File

@ -26,7 +26,6 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
computealpha "google.golang.org/api/compute/v0.alpha"
compute "google.golang.org/api/compute/v1" compute "google.golang.org/api/compute/v1"
"github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud" "github.com/GoogleCloudPlatform/k8s-cloud-provider/pkg/cloud"
@ -103,9 +102,9 @@ func TestEnsureStaticIPWithTier(t *testing.T) {
assert.NotEqual(t, ip, "") assert.NotEqual(t, ip, "")
// Get the Address from the fake address service and verify that the tier // Get the Address from the fake address service and verify that the tier
// is set correctly. // is set correctly.
alphaAddr, err := s.GetAlphaRegionAddress(tc.name, s.region) Addr, err := s.GetRegionAddress(tc.name, s.region)
require.NoError(t, err) require.NoError(t, err)
assert.Equal(t, tc.expected, alphaAddr.NetworkTier) assert.Equal(t, tc.expected, Addr.NetworkTier)
}) })
} }
} }
@ -119,14 +118,14 @@ func TestVerifyRequestedIP(t *testing.T) {
requestedIP string requestedIP string
fwdRuleIP string fwdRuleIP string
netTier cloud.NetworkTier netTier cloud.NetworkTier
addrList []*computealpha.Address addrList []*compute.Address
expectErr bool expectErr bool
expectUserOwned bool expectUserOwned bool
}{ }{
"requested IP exists": { "requested IP exists": {
requestedIP: "1.1.1.1", requestedIP: "1.1.1.1",
netTier: cloud.NetworkTierPremium, netTier: cloud.NetworkTierPremium,
addrList: []*computealpha.Address{{Name: "foo", Address: "1.1.1.1", NetworkTier: "PREMIUM"}}, addrList: []*compute.Address{{Name: "foo", Address: "1.1.1.1", NetworkTier: "PREMIUM"}},
expectErr: false, expectErr: false,
expectUserOwned: true, expectUserOwned: true,
}, },
@ -149,7 +148,7 @@ func TestVerifyRequestedIP(t *testing.T) {
"requested IP exists, but network tier does not match": { "requested IP exists, but network tier does not match": {
requestedIP: "1.1.1.1", requestedIP: "1.1.1.1",
netTier: cloud.NetworkTierStandard, netTier: cloud.NetworkTierStandard,
addrList: []*computealpha.Address{{Name: "foo", Address: "1.1.1.1", NetworkTier: "PREMIUM"}}, addrList: []*compute.Address{{Name: "foo", Address: "1.1.1.1", NetworkTier: "PREMIUM"}},
expectErr: true, expectErr: true,
}, },
} { } {
@ -158,7 +157,7 @@ func TestVerifyRequestedIP(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
for _, addr := range tc.addrList { for _, addr := range tc.addrList {
s.ReserveAlphaRegionAddress(addr, s.region) s.ReserveRegionAddress(addr, s.region)
} }
isUserOwnedIP, err := verifyUserRequestedIP(s, s.region, tc.requestedIP, tc.fwdRuleIP, lbRef, tc.netTier) isUserOwnedIP, err := verifyUserRequestedIP(s, s.region, tc.requestedIP, tc.fwdRuleIP, lbRef, tc.netTier)
assert.Equal(t, tc.expectErr, err != nil, fmt.Sprintf("err: %v", err)) assert.Equal(t, tc.expectErr, err != nil, fmt.Sprintf("err: %v", err))
@ -180,11 +179,11 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
for desc, tc := range map[string]struct { for desc, tc := range map[string]struct {
netTier cloud.NetworkTier netTier cloud.NetworkTier
expectedRule *computealpha.ForwardingRule expectedRule *compute.ForwardingRule
}{ }{
"Premium tier": { "Premium tier": {
netTier: cloud.NetworkTierPremium, netTier: cloud.NetworkTierPremium,
expectedRule: &computealpha.ForwardingRule{ expectedRule: &compute.ForwardingRule{
Name: "lb-1", Name: "lb-1",
Description: `{"kubernetes.io/service-name":"foo-svc"}`, Description: `{"kubernetes.io/service-name":"foo-svc"}`,
IPAddress: "1.1.1.1", IPAddress: "1.1.1.1",
@ -197,7 +196,7 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
}, },
"Standard tier": { "Standard tier": {
netTier: cloud.NetworkTierStandard, netTier: cloud.NetworkTierStandard,
expectedRule: &computealpha.ForwardingRule{ expectedRule: &compute.ForwardingRule{
Name: "lb-2", Name: "lb-2",
Description: `{"kubernetes.io/service-name":"foo-svc"}`, Description: `{"kubernetes.io/service-name":"foo-svc"}`,
IPAddress: "2.2.2.2", IPAddress: "2.2.2.2",
@ -205,7 +204,7 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
PortRange: "123-123", PortRange: "123-123",
Target: target, Target: target,
NetworkTier: "STANDARD", NetworkTier: "STANDARD",
SelfLink: fmt.Sprintf(baseLinkURL, "alpha", vals.ProjectID, vals.Region, "lb-2"), SelfLink: fmt.Sprintf(baseLinkURL, "v1", vals.ProjectID, vals.Region, "lb-2"),
}, },
}, },
} { } {
@ -219,9 +218,9 @@ func TestCreateForwardingRuleWithTier(t *testing.T) {
err = createForwardingRule(s, lbName, serviceName, s.region, ipAddr, target, ports, tc.netTier) err = createForwardingRule(s, lbName, serviceName, s.region, ipAddr, target, ports, tc.netTier)
assert.NoError(t, err) assert.NoError(t, err)
alphaRule, err := s.GetAlphaRegionForwardingRule(lbName, s.region) Rule, err := s.GetRegionForwardingRule(lbName, s.region)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, tc.expectedRule, alphaRule) assert.Equal(t, tc.expectedRule, Rule)
}) })
} }
} }
@ -240,35 +239,35 @@ func TestDeleteAddressWithWrongTier(t *testing.T) {
for desc, tc := range map[string]struct { for desc, tc := range map[string]struct {
addrName string addrName string
netTier cloud.NetworkTier netTier cloud.NetworkTier
addrList []*computealpha.Address addrList []*compute.Address
expectDelete bool expectDelete bool
}{ }{
"Network tiers (premium) match; do nothing": { "Network tiers (premium) match; do nothing": {
addrName: "foo1", addrName: "foo1",
netTier: cloud.NetworkTierPremium, netTier: cloud.NetworkTierPremium,
addrList: []*computealpha.Address{{Name: "foo1", Address: "1.1.1.1", NetworkTier: "PREMIUM"}}, addrList: []*compute.Address{{Name: "foo1", Address: "1.1.1.1", NetworkTier: "PREMIUM"}},
}, },
"Network tiers (standard) match; do nothing": { "Network tiers (standard) match; do nothing": {
addrName: "foo2", addrName: "foo2",
netTier: cloud.NetworkTierStandard, netTier: cloud.NetworkTierStandard,
addrList: []*computealpha.Address{{Name: "foo2", Address: "1.1.1.2", NetworkTier: "STANDARD"}}, addrList: []*compute.Address{{Name: "foo2", Address: "1.1.1.2", NetworkTier: "STANDARD"}},
}, },
"Wrong network tier (standard); delete address": { "Wrong network tier (standard); delete address": {
addrName: "foo3", addrName: "foo3",
netTier: cloud.NetworkTierPremium, netTier: cloud.NetworkTierPremium,
addrList: []*computealpha.Address{{Name: "foo3", Address: "1.1.1.3", NetworkTier: "STANDARD"}}, addrList: []*compute.Address{{Name: "foo3", Address: "1.1.1.3", NetworkTier: "STANDARD"}},
expectDelete: true, expectDelete: true,
}, },
"Wrong network tier (premium); delete address": { "Wrong network tier (premium); delete address": {
addrName: "foo4", addrName: "foo4",
netTier: cloud.NetworkTierStandard, netTier: cloud.NetworkTierStandard,
addrList: []*computealpha.Address{{Name: "foo4", Address: "1.1.1.4", NetworkTier: "PREMIUM"}}, addrList: []*compute.Address{{Name: "foo4", Address: "1.1.1.4", NetworkTier: "PREMIUM"}},
expectDelete: true, expectDelete: true,
}, },
} { } {
t.Run(desc, func(t *testing.T) { t.Run(desc, func(t *testing.T) {
for _, addr := range tc.addrList { for _, addr := range tc.addrList {
s.ReserveAlphaRegionAddress(addr, s.region) s.ReserveRegionAddress(addr, s.region)
} }
// Sanity check to ensure we inject the right address. // Sanity check to ensure we inject the right address.
@ -428,13 +427,13 @@ func TestLoadBalancerWrongTierResourceDeletion(t *testing.T) {
) )
require.NoError(t, err) require.NoError(t, err)
addressObj := &computealpha.Address{ addressObj := &compute.Address{
Name: lbName, Name: lbName,
Description: serviceName.String(), Description: serviceName.String(),
NetworkTier: cloud.NetworkTierStandard.ToGCEValue(), NetworkTier: cloud.NetworkTierStandard.ToGCEValue(),
} }
err = gce.ReserveAlphaRegionAddress(addressObj, gce.region) err = gce.ReserveRegionAddress(addressObj, gce.region)
require.NoError(t, err) require.NoError(t, err)
_, err = createExternalLoadBalancer(gce, svc, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName) _, err = createExternalLoadBalancer(gce, svc, []string{"test-node-1"}, vals.ClusterName, vals.ClusterID, vals.ZoneName)