add support for svc backend

api/v1beta1/gslb_types.go

@@ -44,7 +44,9 @@ type Strategy struct {
 // +k8s:openapi-gen=true
 type GslbSpec struct {
 	// Gslb-enabled Ingress Spec
-	Ingress IngressSpec `json:"ingress"`
+	Ingress *IngressSpec `json:"ingress,omitempty"`
+	// Gslb-enabled LoadBalancer Service
+	LoadBalancer *LoadBalancer `json:"loadBalancer,omitempty"`
 	// Gslb Strategy spec
 	Strategy Strategy `json:"strategy"`
 }

api/v1beta1/upstream_types.go

@@ -146,6 +146,17 @@ func (in *IngressSpec) DeepCopyInto(out *IngressSpec) {
 	}
 }
 
+// LoadBalancer defines the desired state of Gslb
+// +k8s:openapi-gen=true
+type LoadBalancer struct {
+	// Host is the fully qualified domain name of a network host, as defined by RFC 3986.
+	// This is the host name to be used as global domain name while creating GSLB records.
+	Host string `json:"host"`
+	// ServiceName is the name of the Service resource being exposed.
+	// Only LoadBalancer Service type is supported.
+	ServiceName string `json:"serviceName"`
+}
+
 // DeepCopyInto copying the receiver, writing into out. in must be non-nil.
 func (in *IngressRule) DeepCopyInto(out *IngressRule) {
 	*out = *in
@@ -163,7 +174,7 @@ func (in *IngressRuleValue) DeepCopyInto(out *IngressRuleValue) {
 }
 
 // FromV1IngressSpec transforms from networking.k8s.io/v1 IngressSpec to custom k8gb ingress Spec
-func FromV1IngressSpec(v1Spec netv1.IngressSpec) IngressSpec {
+func FromV1IngressSpec(v1Spec netv1.IngressSpec) *IngressSpec {
 	spec := IngressSpec{}
 	spec.DefaultBackend = v1Spec.DefaultBackend
 	spec.IngressClassName = v1Spec.IngressClassName
@@ -177,7 +188,7 @@ func FromV1IngressSpec(v1Spec netv1.IngressSpec) IngressSpec {
 		}
 		spec.Rules = append(spec.Rules, rule)
 	}
-	return spec
+	return &spec
 }
 
 // ToV1IngressSpec transforms from k8gb ingress Spec to networking.k8s.io/v1 IngressSpec

chart/k8gb/crd/k8gb.absa.oss_gslbs.yaml

@@ -307,6 +307,22 @@ spec:
                       type: object
                     type: array
                 type: object
+              loadBalancer:
+                description: Gslb-enabled LoadBalancer Service
+                properties:
+                  host:
+                    description: Host is the fully qualified domain name of a network
+                      host, as defined by RFC 3986. This is the host name to be used
+                      as global domain name while creating GSLB records.
+                    type: string
+                  serviceName:
+                    description: ServiceName is the name of the Service resource being
+                      exposed. Only LoadBalancer Service type is supported.
+                    type: string
+                required:
+                - host
+                - serviceName
+                type: object
               strategy:
                 description: Gslb Strategy spec
                 properties:
@@ -331,7 +347,6 @@ spec:
                 - type
                 type: object
             required:
-            - ingress
             - strategy
             type: object
           status:

controllers/dnsupdate.go

@@ -43,9 +43,19 @@ func (r *GslbReconciler) gslbDNSEndpoint(gslb *k8gbv1beta1.Gslb) (*externaldns.D
 		return nil, err
 	}
 
-	localTargets, err := r.DNSProvider.GslbIngressExposedIPs(gslb)
-	if err != nil {
-		return nil, err
+	localTargets := []string{}
+	if gslb.Spec.Ingress != nil {
+		localTargets, err = r.DNSProvider.GslbIngressExposedIPs(gslb)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if gslb.Spec.LoadBalancer != nil {
+		localTargets, err = r.DNSProvider.GslbServiceExposedIPs(gslb)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	for host, health := range serviceHealth {

controllers/gslb_controller_reconciliation.go

@@ -137,16 +137,18 @@ func (r *GslbReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.
 	}
 
 	// == Ingress ==========
-	ingress, err := r.gslbIngress(gslb)
-	if err != nil {
-		m.IncrementError(gslb)
-		return result.RequeueError(err)
-	}
+	if gslb.Spec.Ingress != nil {
+		ingress, err := r.gslbIngress(gslb)
+		if err != nil {
+			m.IncrementError(gslb)
+			return result.RequeueError(err)
+		}
 
-	err = r.saveIngress(gslb, ingress)
-	if err != nil {
-		m.IncrementError(gslb)
-		return result.RequeueError(err)
+		err = r.saveIngress(gslb, ingress)
+		if err != nil {
+			m.IncrementError(gslb)
+			return result.RequeueError(err)
+		}
 	}
 
 	// == external-dns dnsendpoints CRs ==

controllers/gslb_controller_setup.go

@@ -57,13 +57,18 @@ func (r *GslbReconciler) SetupWithManager(mgr ctrl.Manager) error {
 			}
 			gslbName := ""
 			for _, gslb := range gslbList.Items {
-				for _, rule := range gslb.Spec.Ingress.Rules {
-					for _, path := range rule.HTTP.Paths {
-						if path.Backend.Service != nil && path.Backend.Service.Name == a.GetName() {
-							gslbName = gslb.Name
+				if gslb.Spec.Ingress != nil {
+					for _, rule := range gslb.Spec.Ingress.Rules {
+						for _, path := range rule.HTTP.Paths {
+							if path.Backend.Service != nil && path.Backend.Service.Name == a.GetName() {
+								gslbName = gslb.Name
+							}
 						}
 					}
 				}
+				if gslb.Spec.LoadBalancer != nil && gslb.Spec.LoadBalancer.ServiceName == a.GetName() {
+					gslbName = gslb.Name
+				}
 			}
 			if len(gslbName) > 0 {
 				return []reconcile.Request{

controllers/ingress.go

@@ -43,7 +43,7 @@ func (r *GslbReconciler) gslbIngress(gslb *k8gbv1beta1.Gslb) (*netv1.Ingress, er
 			Namespace:   gslb.Namespace,
 			Annotations: gslb.Annotations,
 		},
-		Spec: k8gbv1beta1.ToV1IngressSpec(gslb.Spec.Ingress),
+		Spec: k8gbv1beta1.ToV1IngressSpec(*gslb.Spec.Ingress),
 	}
 
 	err := controllerutil.SetControllerReference(gslb, ingress, r.Scheme)

controllers/providers/assistant/assistant.go

@@ -30,6 +30,8 @@ type Assistant interface {
 	CoreDNSExposedIPs() ([]string, error)
 	// GslbIngressExposedIPs retrieves list of IP's exposed by all GSLB ingresses
 	GslbIngressExposedIPs(gslb *k8gbv1beta1.Gslb) ([]string, error)
+	// GslbServiceExposedIPs retrieves list of IP's exposed by all GSLB LoadBalancer type Services
+	GslbServiceExposedIPs(gslb *k8gbv1beta1.Gslb) ([]string, error)
 	// GetExternalTargets retrieves slice of targets from external clusters
 	GetExternalTargets(host string, extClusterNsNames map[string]string) (targets Targets)
 	// SaveDNSEndpoint update DNS endpoint or create new one if doesnt exist

controllers/providers/assistant/gslb.go

@@ -158,6 +158,47 @@ func (r *Gslb) GslbIngressExposedIPs(gslb *k8gbv1beta1.Gslb) ([]string, error) {
 	return gslbIngressIPs, nil
 }
 
+// GslbServiceExposedIPs retrieves list of IP's exposed by all GSLB LoadBalancer type services
+func (r *Gslb) GslbServiceExposedIPs(gslb *k8gbv1beta1.Gslb) ([]string, error) {
+	nn := types.NamespacedName{
+		Name:      gslb.Spec.LoadBalancer.ServiceName,
+		Namespace: gslb.Namespace,
+	}
+
+	gslbService := &corev1.Service{}
+
+	err := r.client.Get(context.TODO(), nn, gslbService)
+	if err != nil {
+		if errors.IsNotFound(err) {
+			log.Info().
+				Str("gslb", gslb.Spec.LoadBalancer.ServiceName).
+				Msg("Can't find gslb Service")
+		}
+		return nil, err
+	}
+
+	if gslbService.Spec.Type != corev1.ServiceTypeLoadBalancer {
+		return nil, fmt.Errorf("service %s is not of type LoadBalancer", gslb.Spec.LoadBalancer.ServiceName)
+	}
+
+	var gslbServiceIPs []string
+	for _, ip := range gslbService.Status.LoadBalancer.Ingress {
+		if len(ip.IP) > 0 {
+			gslbServiceIPs = append(gslbServiceIPs, ip.IP)
+		}
+		if len(ip.Hostname) > 0 {
+			IPs, err := utils.Dig(ip.Hostname, r.edgeDNSServers...)
+			if err != nil {
+				log.Warn().Err(err).Msg("Dig error")
+				return nil, err
+			}
+			gslbServiceIPs = append(gslbServiceIPs, IPs...)
+		}
+	}
+
+	return gslbServiceIPs, nil
+}
+
 // SaveDNSEndpoint update DNS endpoint or create new one if doesnt exist
 func (r *Gslb) SaveDNSEndpoint(namespace string, i *externaldns.DNSEndpoint) error {
 	found := &externaldns.DNSEndpoint{}

controllers/providers/dns/dns.go

@@ -29,6 +29,8 @@ type Provider interface {
 	CreateZoneDelegationForExternalDNS(*k8gbv1beta1.Gslb) error
 	// GslbIngressExposedIPs retrieves list of IP's exposed by all GSLB ingresses
 	GslbIngressExposedIPs(*k8gbv1beta1.Gslb) ([]string, error)
+	// GslbServiceExposedIPs retrieves list of IP's exposed by all LoadBalancer type Services
+	GslbServiceExposedIPs(*k8gbv1beta1.Gslb) ([]string, error)
 	// GetExternalTargets retrieves list of external targets for specified host
 	GetExternalTargets(string) assistant.Targets
 	// SaveDNSEndpoint update DNS endpoint in gslb or create new one if doesn't exist

controllers/providers/dns/empty.go

@@ -46,6 +46,10 @@ func (p *EmptyDNSProvider) GslbIngressExposedIPs(gslb *k8gbv1beta1.Gslb) (r []st
 	return p.assistant.GslbIngressExposedIPs(gslb)
 }
 
+func (p *EmptyDNSProvider) GslbServiceExposedIPs(gslb *k8gbv1beta1.Gslb) (r []string, err error) {
+	return p.assistant.GslbServiceExposedIPs(gslb)
+}
+
 func (p *EmptyDNSProvider) GetExternalTargets(host string) (targets assistant.Targets) {
 	return p.assistant.GetExternalTargets(host, p.config.GetExternalClusterNSNames())
 }

controllers/providers/dns/external.go

@@ -113,6 +113,10 @@ func (p *ExternalDNSProvider) GslbIngressExposedIPs(gslb *k8gbv1beta1.Gslb) ([]s
 	return p.assistant.GslbIngressExposedIPs(gslb)
 }
 
+func (p *ExternalDNSProvider) GslbServiceExposedIPs(gslb *k8gbv1beta1.Gslb) ([]string, error) {
+	return p.assistant.GslbServiceExposedIPs(gslb)
+}
+
 func (p *ExternalDNSProvider) SaveDNSEndpoint(gslb *k8gbv1beta1.Gslb, i *externaldns.DNSEndpoint) error {
 	return p.assistant.SaveDNSEndpoint(gslb.Namespace, i)
 }

controllers/providers/dns/infoblox.go

@@ -210,6 +210,10 @@ func (p *InfobloxProvider) GslbIngressExposedIPs(gslb *k8gbv1beta1.Gslb) ([]stri
 	return p.assistant.GslbIngressExposedIPs(gslb)
 }
 
+func (p *InfobloxProvider) GslbServiceExposedIPs(gslb *k8gbv1beta1.Gslb) ([]string, error) {
+	return p.assistant.GslbServiceExposedIPs(gslb)
+}
+
 func (p *InfobloxProvider) SaveDNSEndpoint(gslb *k8gbv1beta1.Gslb, i *externaldns.DNSEndpoint) error {
 	return p.assistant.SaveDNSEndpoint(gslb.Namespace, i)
 }