use of cloud tags + improved error checking and messages

pkg/model/context.go

@@ -33,6 +33,7 @@ import (
 	"k8s.io/kops/upup/pkg/fi"
 	"k8s.io/kops/upup/pkg/fi/cloudup/awstasks"
 	"k8s.io/kops/upup/pkg/fi/cloudup/awsup"
+	"k8s.io/kops/upup/pkg/fi/cloudup/scaleway"
 
 	"github.com/blang/semver/v4"
 	utilnet "k8s.io/apimachinery/pkg/util/net"
@@ -234,6 +235,14 @@ func (b *KopsModelContext) CloudTags(name string, shared bool) map[string]string
 				tags[k] = v
 			}
 		}
+	case kops.CloudProviderScaleway:
+		for k, v := range b.Cluster.Spec.CloudLabels {
+			if k == scaleway.TagClusterName && shared == true {
+				klog.V(4).Infof("Skipping %q tag for shared resource", scaleway.TagClusterName)
+				continue
+			}
+			tags[k] = v
+		}
 	}
 	return tags
 }

pkg/model/scalewaymodel/api_loadbalancer.go

@@ -18,9 +18,7 @@ package scalewaymodel
 
 import (
 	"fmt"
-	"os"
 
-	"github.com/scaleway/scaleway-sdk-go/scw"
 	"k8s.io/klog/v2"
 	"k8s.io/kops/pkg/apis/kops"
 	"k8s.io/kops/pkg/dns"
@@ -44,34 +42,28 @@ func (b *APILoadBalancerModelBuilder) Build(c *fi.CloudupModelBuilderContext) er
 	}
 
 	lbSpec := b.Cluster.Spec.API.LoadBalancer
-	if lbSpec == nil {
-		// Skipping API LB creation; not requested in Spec
-		return nil
-	}
 
 	switch lbSpec.Type {
 	case kops.LoadBalancerTypePublic:
 		klog.V(8).Infof("Using public load-balancer")
 	case kops.LoadBalancerTypeInternal:
-		return fmt.Errorf("internal load-balancers are not yet supported by Scaleway on kops")
+		return fmt.Errorf("Scaleway clusters don't have a VPC yet, so internal load-balancers are not supported at the time")
 	default:
 		return fmt.Errorf("unhandled load-balancer type %q", lbSpec.Type)
 	}
 
-	loadBalancerName := "api." + b.ClusterName()
+	lbTags := []string(nil)
-	region, err := scw.ParseRegion(os.Getenv("SCW_DEFAULT_REGION"))
+	for k, v := range b.CloudTags(b.ClusterName(), false) {
-	if err != nil {
+		lbTags = append(lbTags, fmt.Sprintf("%s=%s", k, v))
-		return fmt.Errorf("error building load-balancer task for %q: %w", loadBalancerName, err)
 	}
+	lbTags = append(lbTags, fmt.Sprintf("%s=%s", scaleway.TagNameRolePrefix, scaleway.TagRoleControlPlane))
 
+	loadBalancerName := "api." + b.ClusterName()
 	loadBalancer := &scalewaytasks.LoadBalancer{
 		Name:      fi.PtrTo(loadBalancerName),
-		Region:    fi.PtrTo(string(region)),
+		Region:    fi.PtrTo(b.Region),
 		Lifecycle: b.Lifecycle,
-		Tags: []string{
+		Tags:      lbTags,
-			scaleway.TagClusterName + "=" + b.ClusterName(),
-			scaleway.TagNameRolePrefix + "=" + scaleway.TagRoleMaster,
-		},
 	}
 
 	c.AddTask(loadBalancer)

upup/pkg/fi/cloudup/scaleway/cloud.go

@@ -203,12 +203,12 @@ func (s *scwCloudImplementation) DeleteInstance(i *cloudinstances.CloudInstance)
 			klog.V(4).Infof("error deleting cloud instance %s of group %s : instance was already deleted", i.ID, i.CloudInstanceGroup.HumanName)
 			return nil
 		}
-		return fmt.Errorf("error deleting cloud instance %s of group %s: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
+		return fmt.Errorf("deleting cloud instance %s of group %s: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
 	}
 
 	err = s.DeleteServer(server.Server)
 	if err != nil {
-		return fmt.Errorf("error deleting cloud instance %s of group %s: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
+		return fmt.Errorf("deleting cloud instance %s of group %s: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
 	}
 
 	return nil
@@ -220,13 +220,13 @@ func (s *scwCloudImplementation) DeregisterInstance(i *cloudinstances.CloudInsta
 		ServerID: i.ID,
 	})
 	if err != nil {
-		return fmt.Errorf("error deregistering cloud instance %s of group %q: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
+		return fmt.Errorf("deregistering cloud instance %s of group %q: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
 	}
 
 	// We remove the instance's IP from load-balancers
 	lbs, err := s.GetClusterLoadBalancers(s.ClusterName(server.Server.Tags))
 	if err != nil {
-		return fmt.Errorf("error deregistering cloud instance %s of group %q: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
+		return fmt.Errorf("deregistering cloud instance %s of group %q: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
 	}
 	for _, loadBalancer := range lbs {
 		backEnds, err := s.lbAPI.ListBackends(&lb.ListBackendsRequest{
@@ -234,7 +234,7 @@ func (s *scwCloudImplementation) DeregisterInstance(i *cloudinstances.CloudInsta
 			LBID:   loadBalancer.ID,
 		}, scw.WithAllPages())
 		if err != nil {
-			return fmt.Errorf("eerror deregistering cloud instance %s of group %q: error listing load-balancer's back-ends for instance creation: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
+			return fmt.Errorf("deregistering cloud instance %s of group %q: listing load-balancer's back-ends for instance creation: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
 		}
 		for _, backEnd := range backEnds.Backends {
 			for _, serverIP := range backEnd.Pool {
@@ -245,7 +245,7 @@ func (s *scwCloudImplementation) DeregisterInstance(i *cloudinstances.CloudInsta
 						ServerIP:  []string{serverIP},
 					})
 					if err != nil {
-						return fmt.Errorf("error deregistering cloud instance %s of group %q: error removing IP from lb: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
+						return fmt.Errorf("deregistering cloud instance %s of group %q: removing IP from lb: %w", i.ID, i.CloudInstanceGroup.HumanName, err)
 					}
 				}
 			}
@@ -281,14 +281,14 @@ func (s *scwCloudImplementation) GetApiIngressStatus(cluster *kops.Cluster) ([]f
 		Name:   &name,
 	}, scw.WithAllPages())
 	if err != nil {
-		return nil, fmt.Errorf("error finding load-balancers: %w", err)
+		return nil, fmt.Errorf("finding load-balancers: %w", err)
 	}
 	if len(responseLoadBalancers.LBs) == 0 {
-		klog.V(8).Infof("could not find any load-balancers for cluster %s", cluster.Name)
+		klog.V(8).Infof("Could not find any load-balancers for cluster %s", cluster.Name)
 		return nil, nil
 	}
 	if len(responseLoadBalancers.LBs) > 1 {
-		klog.V(4).Infof("more than 1 load-balancer with the name %s was found", name)
+		klog.V(4).Infof("More than 1 load-balancer with the name %s was found", name)
 	}
 
 	for _, loadBalancer := range responseLoadBalancers.LBs {
@@ -387,7 +387,7 @@ func (s *scwCloudImplementation) GetClusterLoadBalancers(clusterName string) ([]
 		Name:   &loadBalancerName,
 	}, scw.WithAllPages())
 	if err != nil {
-		return nil, fmt.Errorf("failed to list cluster load-balancers: %w", err)
+		return nil, fmt.Errorf("listing cluster load-balancers: %w", err)
 	}
 	return lbs.LBs, nil
 }
@@ -442,14 +442,14 @@ func (s *scwCloudImplementation) DeleteLoadBalancer(loadBalancer *lb.LB) error {
 		Region: s.region,
 	})
 	if err != nil {
-		return fmt.Errorf("error waiting for load-balancer: %w", err)
+		return fmt.Errorf("waiting for load-balancer: %w", err)
 	}
 	err = s.lbAPI.DeleteLB(&lb.DeleteLBRequest{
 		Region: s.region,
 		LBID:   loadBalancer.ID,
 	})
 	if err != nil {
-		return fmt.Errorf("failed to delete load-balancer %s: %w", loadBalancer.ID, err)
+		return fmt.Errorf("deleting load-balancer %s: %w", loadBalancer.ID, err)
 	}
 
 	// We wait for the load-balancer to be deleted, then we detach its IPs
@@ -458,7 +458,7 @@ func (s *scwCloudImplementation) DeleteLoadBalancer(loadBalancer *lb.LB) error {
 		Region: s.region,
 	})
 	if !is404Error(err) {
-		return fmt.Errorf("error waiting for load-balancer %s after deletion: %w", loadBalancer.ID, err)
+		return fmt.Errorf("waiting for load-balancer %s after deletion: %w", loadBalancer.ID, err)
 	}
 	for _, ip := range ipsToRelease {
 		err := s.lbAPI.ReleaseIP(&lb.ReleaseIPRequest{
@@ -466,7 +466,7 @@ func (s *scwCloudImplementation) DeleteLoadBalancer(loadBalancer *lb.LB) error {
 			IPID:   ip.ID,
 		})
 		if err != nil {
-			return fmt.Errorf("failed to delete load-balancer IP: %w", err)
+			return fmt.Errorf("deleting load-balancer IP: %w", err)
 		}
 	}
 	return nil

upup/pkg/fi/cloudup/scalewaytasks/instance.go

@@ -19,7 +19,6 @@ package scalewaytasks
 import (
 	"bytes"
 	"fmt"
-	"os"
 
 	"github.com/scaleway/scaleway-sdk-go/api/instance/v1"
 	"github.com/scaleway/scaleway-sdk-go/api/lb/v1"
@@ -120,7 +119,7 @@ func (_ *Instance) RenderScw(c *fi.CloudupContext, actual, expected, changes *In
 	cloud := c.T.Cloud.(scaleway.ScwCloud)
 	instanceService := cloud.InstanceService()
 	zone := scw.Zone(fi.ValueOf(expected.Zone))
-	mastersPrivateIPs := []string(nil)
+	controlPlanePrivateIPs := []string(nil)
 
 	userData, err := fi.ResourceAsBytes(*expected.UserData)
 	if err != nil {
@@ -195,25 +194,25 @@ func (_ *Instance) RenderScw(c *fi.CloudupContext, actual, expected, changes *In
 			ServerID: srv.Server.ID,
 		})
 		if err != nil {
-			return fmt.Errorf("error getting server %s: %s", srv.Server.ID, err)
+			return fmt.Errorf("getting server %s: %s", srv.Server.ID, err)
 		}
 
-		// If instance has role master, we add its private IP to the list to add it to the lb's backend
+		// If instance has control-plane role, we add its private IP to the list to add it to the lb's backend
 		for _, tag := range expected.Tags {
-			if tag == scaleway.TagNameRolePrefix+"="+scaleway.TagRoleMaster {
+			if tag == scaleway.TagNameRolePrefix+"="+scaleway.TagRoleControlPlane {
-				mastersPrivateIPs = append(mastersPrivateIPs, *server.Server.PrivateIP)
+				controlPlanePrivateIPs = append(controlPlanePrivateIPs, *server.Server.PrivateIP)
 			}
 		}
 	}
 
-	// If IG is master, we add the new servers' IPs to the load-balancer's back-end
+	// If IG is control-plane, we add the new servers' IPs to the load-balancer's back-end
-	if len(mastersPrivateIPs) > 0 {
+	if len(controlPlanePrivateIPs) > 0 {
 		lbService := cloud.LBService()
-		region := scw.Region(os.Getenv("SCW_DEFAULT_REGION"))
+		region := scw.Region(cloud.Region())
 
 		lbs, err := cloud.GetClusterLoadBalancers(cloud.ClusterName(expected.Tags))
 		if err != nil {
-			return fmt.Errorf("error listing load-balancers for instance creation: %w", err)
+			return fmt.Errorf("listing load-balancers for instance creation: %w", err)
 		}
 
 		for _, loadBalancer := range lbs {
@@ -222,20 +221,20 @@ func (_ *Instance) RenderScw(c *fi.CloudupContext, actual, expected, changes *In
 				LBID:   loadBalancer.ID,
 			})
 			if err != nil {
-				return fmt.Errorf("error listing load-balancer's back-ends for instance creation: %w", err)
+				return fmt.Errorf("listing load-balancer's back-ends for instance creation: %w", err)
 			}
 			if backEnds.TotalCount > 1 {
-				return fmt.Errorf("found multiple back-ends for load-balancer %s, exiting now", loadBalancer.ID)
+				return fmt.Errorf("cannot have multiple back-ends for load-balancer %s", loadBalancer.ID)
 			}
 			backEnd := backEnds.Backends[0]
 
 			_, err = lbService.AddBackendServers(&lb.AddBackendServersRequest{
 				Region:    region,
 				BackendID: backEnd.ID,
-				ServerIP:  mastersPrivateIPs,
+				ServerIP:  controlPlanePrivateIPs,
 			})
 			if err != nil {
-				return fmt.Errorf("error adding servers' IPs to load-balancer's back-end: %w", err)
+				return fmt.Errorf("adding servers' IPs to load-balancer's back-end: %w", err)
 			}
 
 			_, err = lbService.WaitForLb(&lb.WaitForLBRequest{
@@ -243,7 +242,7 @@ func (_ *Instance) RenderScw(c *fi.CloudupContext, actual, expected, changes *In
 				Region: region,
 			})
 			if err != nil {
-				return fmt.Errorf("error waiting for load-balancer %s: %w", loadBalancer.ID, err)
+				return fmt.Errorf("waiting for load-balancer %s: %w", loadBalancer.ID, err)
 			}
 		}
 	}

upup/pkg/fi/cloudup/scalewaytasks/loadbalancer.go

@@ -33,8 +33,8 @@ type LoadBalancer struct {
 	Lifecycle fi.Lifecycle
 
 	Region       *string
-	LoadBalancerId      *string
+	LBID         *string
-	LoadBalancerAddress *string
+	LBAddresses  []string
 	Tags         []string
 	ForAPIServer bool
 }
@@ -43,7 +43,7 @@ var _ fi.CompareWithID = &LoadBalancer{}
 var _ fi.HasAddress = &LoadBalancer{}
 
 func (l *LoadBalancer) CompareWithID() *string {
-	return l.LoadBalancerId
+	return l.LBID
 }
 
 func (l *LoadBalancer) IsForAPIServer() bool {
@@ -51,7 +51,7 @@ func (l *LoadBalancer) IsForAPIServer() bool {
 }
 
 func (l *LoadBalancer) Find(context *fi.CloudupContext) (*LoadBalancer, error) {
-	if fi.ValueOf(l.LoadBalancerId) == "" {
+	if fi.ValueOf(l.LBID) == "" {
 		return nil, nil
 	}
 
@@ -60,21 +60,21 @@ func (l *LoadBalancer) Find(context *fi.CloudupContext) (*LoadBalancer, error) {
 
 	loadBalancer, err := lbService.GetLB(&lb.GetLBRequest{
 		Region: scw.Region(cloud.Region()),
-		LBID:   fi.ValueOf(l.LoadBalancerId),
+		LBID:   fi.ValueOf(l.LBID),
 	})
 	if err != nil {
-		return nil, fmt.Errorf("error getting load-balancer %s: %s", fi.ValueOf(l.LoadBalancerId), err)
+		return nil, fmt.Errorf("getting load-balancer %s: %s", fi.ValueOf(l.LBID), err)
 	}
 
-	lbIP := loadBalancer.IP[0].IPAddress
+	lbIPs := []string(nil)
-	if len(loadBalancer.IP) > 1 {
+	for _, IP := range loadBalancer.IP {
-		klog.V(4).Infof("multiple IPs found for load-balancer, using %s", lbIP)
+		lbIPs = append(lbIPs, IP.IPAddress)
 	}
 
 	return &LoadBalancer{
 		Name:         &loadBalancer.Name,
-		LoadBalancerId:      &loadBalancer.ID,
+		LBID:         &loadBalancer.ID,
-		LoadBalancerAddress: &lbIP,
+		LBAddresses:  lbIPs,
 		Tags:         loadBalancer.Tags,
 		Lifecycle:    l.Lifecycle,
 		ForAPIServer: l.ForAPIServer,
@@ -85,13 +85,13 @@ func (l *LoadBalancer) FindAddresses(context *fi.CloudupContext) ([]string, erro
 	cloud := context.T.Cloud.(scaleway.ScwCloud)
 	lbService := cloud.LBService()
 
-	if l.LoadBalancerId == nil {
+	if l.LBID == nil {
 		return nil, nil
 	}
 
 	loadBalancer, err := lbService.GetLB(&lb.GetLBRequest{
 		Region: scw.Region(cloud.Region()),
-		LBID:   fi.ValueOf(l.LoadBalancerId),
+		LBID:   fi.ValueOf(l.LBID),
 	})
 	if err != nil {
 		return nil, err
@@ -114,7 +114,7 @@ func (_ *LoadBalancer) CheckChanges(actual, expected, changes *LoadBalancer) err
 		if changes.Name != nil {
 			return fi.CannotChangeField("Name")
 		}
-		if changes.LoadBalancerId != nil {
+		if changes.LBID != nil {
 			return fi.CannotChangeField("ID")
 		}
 		if changes.Region != nil {
@@ -133,56 +133,108 @@ func (_ *LoadBalancer) CheckChanges(actual, expected, changes *LoadBalancer) err
 
 func (l *LoadBalancer) RenderScw(t *scaleway.ScwAPITarget, actual, expected, changes *LoadBalancer) error {
 	lbService := t.Cloud.LBService()
+	region := scw.Region(fi.ValueOf(expected.Region))
+	var loadBalancer *lb.LB
+	backEndToCreate := true
+	frontEndToCreate := true
 
-	// We check if the load-balancer already exists
+	if actual != nil {
-	lbs, err := lbService.ListLBs(&lb.ListLBsRequest{
+		klog.Infof("Updating existing load-balancer with name %q", expected.Name)
-		Region: scw.Region(fi.ValueOf(expected.Region)),
+
-		Name:   expected.Name,
+		lbToUpdate, err := lbService.GetLB(&lb.GetLBRequest{
-	}, scw.WithAllPages())
+			Region: region,
+			LBID:   fi.ValueOf(actual.LBID),
+		})
 		if err != nil {
-		return fmt.Errorf("error listing existing load-balancers: %w", err)
+			return fmt.Errorf("getting load-balancer %q (%s): %w", fi.ValueOf(actual.Name), fi.ValueOf(actual.LBID), err)
 		}
 
-	if lbs.TotalCount > 0 {
+		// We update the tags
-		loadBalancer := lbs.LBs[0]
+		if changes != nil || len(actual.Tags) != len(expected.Tags) {
-		lbIP := loadBalancer.IP[0].IPAddress
+			_, err = lbService.UpdateLB(&lb.UpdateLBRequest{
-		if len(loadBalancer.IP) > 1 {
+				Region:                region,
-			klog.V(4).Infof("multiple IPs found for load-balancer, using %s", lbIP)
+				LBID:                  lbToUpdate.ID,
-		}
+				Name:                  lbToUpdate.Name,
-		expected.LoadBalancerId = &loadBalancer.ID
+				Description:           lbToUpdate.Description,
-		expected.LoadBalancerAddress = &lbIP
+				SslCompatibilityLevel: lbToUpdate.SslCompatibilityLevel,
-		return nil
-	}
-
-	loadBalancer, err := lbService.CreateLB(&lb.CreateLBRequest{
-		Region: scw.Region(fi.ValueOf(expected.Region)),
-		Name:   fi.ValueOf(expected.Name),
-		IPID:   nil,
 				Tags:                  expected.Tags,
 			})
 			if err != nil {
-		return err
+				return fmt.Errorf("updatings tags for load-balancer %q: %w", fi.ValueOf(expected.Name), err)
+			}
+		}
+
+		// We check that the back-end exists
+		backEnds, err := lbService.ListBackends(&lb.ListBackendsRequest{
+			Region: region,
+			LBID:   lbToUpdate.ID,
+			Name:   scw.StringPtr("lb-backend"),
+		})
+		if err != nil {
+			return fmt.Errorf("listing back-ends for load-balancer %q: %w", fi.ValueOf(expected.Name), err)
+		}
+		if backEnds.TotalCount > 0 {
+			backEndToCreate = false
+		}
+
+		// We check that the front-end exists
+		frontEnds, err := lbService.ListFrontends(&lb.ListFrontendsRequest{
+			Region: region,
+			LBID:   lbToUpdate.ID,
+			Name:   scw.StringPtr("lb-frontend"),
+		})
+		if err != nil {
+			return fmt.Errorf("listing front-ends for load-balancer %q: %w", fi.ValueOf(expected.Name), err)
+		}
+		if frontEnds.TotalCount > 0 {
+			frontEndToCreate = false
+		}
+
+		lbIPs := []string(nil)
+		for _, ip := range lbToUpdate.IP {
+			lbIPs = append(lbIPs, ip.IPAddress)
+		}
+		expected.LBID = &lbToUpdate.ID
+		expected.LBAddresses = lbIPs
+
+		loadBalancer = lbToUpdate
+
+	} else {
+		klog.Infof("Creating new load-balancer with name %q", expected.Name)
+
+		lbCreated, err := lbService.CreateLB(&lb.CreateLBRequest{
+			Region: region,
+			Name:   fi.ValueOf(expected.Name),
+			Tags:   expected.Tags,
+		})
+		if err != nil {
+			return fmt.Errorf("creating load-balancer: %w", err)
 		}
 
 		_, err = lbService.WaitForLb(&lb.WaitForLBRequest{
-		LBID:   loadBalancer.ID,
+			LBID:   lbCreated.ID,
-		Region: scw.Region(fi.ValueOf(expected.Region)),
+			Region: region,
 		})
 		if err != nil {
-		return fmt.Errorf("error waiting for load-balancer %s: %w", loadBalancer.ID, err)
+			return fmt.Errorf("waiting for load-balancer %s: %w", lbCreated.ID, err)
 		}
 
-	expected.LoadBalancerId = &loadBalancer.ID
+		lbIPs := []string(nil)
-
+		for _, ip := range lbCreated.IP {
-	if len(loadBalancer.IP) > 1 {
+			lbIPs = append(lbIPs, ip.IPAddress)
-		klog.V(8).Infof("got more more than 1 IP for LB (got %d)", len(loadBalancer.IP))
 		}
-	ip := (*loadBalancer.IP[0]).IPAddress
+		expected.LBID = &lbCreated.ID
-	expected.LoadBalancerAddress = &ip
+		expected.LBAddresses = lbIPs
 
-	// We create the load-balancer's backend
+		loadBalancer = lbCreated
+	}
+
+	backEndID := ""
+
+	// We create the load-balancer's backend if needed
+	if backEndToCreate == true {
 		backEnd, err := lbService.CreateBackend(&lb.CreateBackendRequest{
-		Region:               scw.Region(fi.ValueOf(expected.Region)),
+			Region:               region,
 			LBID:                 loadBalancer.ID,
 			Name:                 "lb-backend",
 			ForwardProtocol:      "tcp",
@@ -199,34 +251,38 @@ func (l *LoadBalancer) RenderScw(t *scaleway.ScwAPITarget, actual, expected, cha
 			ProxyProtocol: "proxy_protocol_none",
 		})
 		if err != nil {
-		return fmt.Errorf("error creating back-end for load-balancer %s: %w", loadBalancer.ID, err)
+			return fmt.Errorf("creating back-end for load-balancer %s: %w", loadBalancer.ID, err)
 		}
 
 		_, err = lbService.WaitForLb(&lb.WaitForLBRequest{
 			LBID:   loadBalancer.ID,
-		Region: scw.Region(fi.ValueOf(expected.Region)),
+			Region: region,
 		})
 		if err != nil {
-		return fmt.Errorf("error waiting for load-balancer %s: %w", loadBalancer.ID, err)
+			return fmt.Errorf("waiting for load-balancer %s: %w", loadBalancer.ID, err)
+		}
+		backEndID = backEnd.ID
 	}
 
-	// We create the load-balancer's front-end
+	// We create the load-balancer's front-end if needed
-	_, err = lbService.CreateFrontend(&lb.CreateFrontendRequest{
+	if frontEndToCreate == true {
-		Region:      scw.Region(fi.ValueOf(expected.Region)),
+		_, err := lbService.CreateFrontend(&lb.CreateFrontendRequest{
+			Region:      region,
 			LBID:        loadBalancer.ID,
 			Name:        "lb-frontend",
 			InboundPort: 443,
-		BackendID:   backEnd.ID,
+			BackendID:   backEndID,
 		})
 		if err != nil {
-		return fmt.Errorf("error creating front-end for load-balancer %s: %w", loadBalancer.ID, err)
+			return fmt.Errorf("creating front-end for load-balancer %s: %w", loadBalancer.ID, err)
 		}
 		_, err = lbService.WaitForLb(&lb.WaitForLBRequest{
 			LBID:   loadBalancer.ID,
-		Region: scw.Region(fi.ValueOf(expected.Region)),
+			Region: region,
 		})
 		if err != nil {
-		return fmt.Errorf("error waiting for load-balancer %s: %w", loadBalancer.ID, err)
+			return fmt.Errorf("waiting for load-balancer %s: %w", loadBalancer.ID, err)
+		}
 	}
 
 	return nil

upup/pkg/fi/cloudup/utils.go

@@ -177,6 +177,9 @@ func BuildCloud(cluster *kops.Cluster) (fi.Cloud, error) {
 				"zone":                  string(zone),
 				"region":                string(region),
 			}
+			for k, v := range cluster.Spec.CloudLabels {
+				cloudTags[k] = v
+			}
 
 			scwCloud, err := scaleway.NewScwCloud(cloudTags)
 			if err != nil {