Allow multiple ports to be defined explicitly

Add a `ports` field in the canary service specs that allows full
control over port mapping and protocol, as an alternative to port
discovery.

If the new `ports` field is set, it takes precedence over both the
single port fields and port discovery.

Fixes #927

Signed-off-by: Yap Sok Ann <sokann@gmail.com>

Author: sayap

charts/flagger/crds/crd.yaml

@@ -219,6 +219,25 @@ spec:
                     delegation:
                       description: enable behaving as a delegate VirtualService
                       type: boolean
+                    ports:
+                      description: Service ports
+                      type: array
+                      items:
+                        type: object
+                        required: ["port"]
+                        properties:
+                          port:
+                            description: Container port number
+                            type: number
+                          portName:
+                            description: Container port name
+                            type: string
+                          appProtocol:
+                            description: Application protocol of the port
+                            type: string
+                          targetPort:
+                            description: Container target port name
+                            x-kubernetes-int-or-string: true
                     match:
                       description: URI match conditions
                       type: array

docs/gitbook/usage/how-it-works.md

@@ -161,6 +161,26 @@ If port discovery is enabled, Flagger scans the target workload and extracts the
 excluding the port specified in the canary service and service mesh sidecar ports.
 These ports will be used when generating the ClusterIP services.
 
+Alternatively, you can explicitly define multiple ports using the `ports` field, which provides more control
+over port configuration and takes precedence over the single `port` fields and port discovery:
+
+```yaml
+spec:
+  service:
+    name: podinfo
+    ports:
+      - port: 9999
+        portName: grpc
+        appProtocol: grpc
+        targetPort: 9090
+      - port: 8888
+        portName: http
+        appProtocol: http
+        targetPort: web
+```
+
+When `ports` is specified, it overrides the `port`, `portName`, `targetPort`, `appProtocol`, and `portDiscovery` fields.
+
 Based on the canary spec service, Flagger creates the following Kubernetes ClusterIP service:
 
 * `<service.name>.<namespace>.svc.cluster.local`  

pkg/apis/flagger/v1beta1/canary.go

@@ -223,6 +223,32 @@ type CanaryService struct {
 	// Canary is the metadata to add to the canary service
 	// +optional
 	Canary *CustomMetadata `json:"canary,omitempty"`
+
+	// For service with more than 1 port->targetPort mappings, which can't be done
+	// with `PortDiscovery`. Should work with providers that support multiple
+	// ports, e.g. Istio and Linkerd.
+	// When this field is set, it will override the fields `Port` / `PortName` /
+	// `TargetPort` / `AppProtocol` / `PortDiscovery`.
+	// +optional
+	Ports []ServicePort `json:"ports,omitempty"`
+}
+
+type ServicePort struct {
+	// Port of the generated Kubernetes service
+	Port int32 `json:"port"`
+
+	// Port name of the generated Kubernetes service
+	PortName string `json:"portName"`
+
+	// Target port number or name of the generated Kubernetes service
+	// Defaults to CanaryService.Port
+	// +optional
+	TargetPort intstr.IntOrString `json:"targetPort,omitempty"`
+
+	// AppProtocol of the service
+	// https://kubernetes.io/docs/concepts/services-networking/service/#application-protocol
+	// +optional
+	AppProtocol string `json:"appProtocol,omitempty"`
 }
 
 // CanaryAnalysis is used to describe how the analysis should be done

pkg/controller/scheduler_deployment_test.go

@@ -533,6 +533,52 @@ func TestScheduler_DeploymentPortDiscovery(t *testing.T) {
 	}
 }
 
+func TestScheduler_DeploymentExplicitPorts(t *testing.T) {
+	mocks := newDeploymentFixture(nil)
+
+	cd, err := mocks.flaggerClient.FlaggerV1beta1().Canaries("default").Get(context.TODO(), "podinfo", metav1.GetOptions{})
+	require.NoError(t, err)
+	// explicitly define multiple ports
+	cd.Spec.Service.Ports = []flaggerv1.ServicePort{
+		{
+			PortName:   "grpc",
+			Port:       9999,
+			TargetPort: intstr.FromInt(9090),
+		},
+		{
+			PortName:   "http",
+			Port:       8888,
+			TargetPort: intstr.FromString("web"),
+		},
+	}
+	// single port config will be ignored
+	cd.Spec.Service.Port = 80
+	// any port found via discovery will also be ignored
+	cd.Spec.Service.PortDiscovery = true
+	_, err = mocks.flaggerClient.FlaggerV1beta1().Canaries("default").Update(context.TODO(), cd, metav1.UpdateOptions{})
+	require.NoError(t, err)
+
+	mocks.ctrl.advanceCanary("podinfo", "default")
+
+	canarySvc, err := mocks.kubeClient.CoreV1().Services("default").Get(context.TODO(), "podinfo-canary", metav1.GetOptions{})
+	require.NoError(t, err)
+	require.Len(t, canarySvc.Spec.Ports, 2)
+
+	matchPorts := func(lookup string) bool {
+		switch lookup {
+		case
+			"grpc 9999->9090",
+			"http 8888->web":
+			return true
+		}
+		return false
+	}
+
+	for _, port := range canarySvc.Spec.Ports {
+		require.True(t, matchPorts(fmt.Sprintf("%s %v->%v", port.Name, port.Port, port.TargetPort.String())))
+	}
+}
+
 func TestScheduler_DeploymentTargetPortNumber(t *testing.T) {
 	mocks := newDeploymentFixture(nil)
 

pkg/router/kubernetes_default.go

@@ -85,7 +85,7 @@ func (c *KubernetesDefaultRouter) GetRoutes(_ *flaggerv1.Canary) (primaryRoute i
 	return 0, 0, nil
 }
 
-func (c *KubernetesDefaultRouter) reconcileService(canary *flaggerv1.Canary, name string, podSelector string, metadata *flaggerv1.CustomMetadata) error {
+func (c *KubernetesDefaultRouter) getApexServicePort(canary *flaggerv1.Canary) corev1.ServicePort {
 	portName := canary.Spec.Service.PortName
 	if portName == "" {
 		portName = "http"
@@ -100,28 +100,23 @@ func (c *KubernetesDefaultRouter) reconcileService(canary *flaggerv1.Canary, nam
 		targetPort = canary.Spec.Service.TargetPort
 	}
 
-	// set pod selector and apex port
-	svcSpec := corev1.ServiceSpec{
-		Type:     corev1.ServiceTypeClusterIP,
-		Selector: map[string]string{c.labelSelector: podSelector},
-		Ports: []corev1.ServicePort{
-			{
-				Name:       portName,
-				Protocol:   corev1.ProtocolTCP,
-				Port:       canary.Spec.Service.Port,
-				TargetPort: targetPort,
-			},
-		},
-	}
-	if canary.Spec.Service.Headless {
-		svcSpec.ClusterIP = "None"
+	cp := corev1.ServicePort{
+		Name:       portName,
+		Protocol:   corev1.ProtocolTCP,
+		Port:       canary.Spec.Service.Port,
+		TargetPort: targetPort,
 	}
 
 	if v := canary.Spec.Service.AppProtocol; v != "" {
-		svcSpec.Ports[0].AppProtocol = &v
+		cp.AppProtocol = &v
 	}
 
-	// set additional ports
+	return cp
+}
+
+func (c *KubernetesDefaultRouter) getDiscoveryServicePorts(canary *flaggerv1.Canary) []corev1.ServicePort {
+	var ports []corev1.ServicePort
+
 	for n, p := range c.ports {
 		cp := corev1.ServicePort{
 			Name:     n,
@@ -133,9 +128,70 @@ func (c *KubernetesDefaultRouter) reconcileService(canary *flaggerv1.Canary, nam
 			},
 		}
 
-		svcSpec.Ports = append(svcSpec.Ports, cp)
+		ports = append(ports, cp)
 	}
 
+	return ports
+}
+
+func (c *KubernetesDefaultRouter) getExplicitServicePorts(canary *flaggerv1.Canary) []corev1.ServicePort {
+	var ports []corev1.ServicePort
+
+	for _, p := range canary.Spec.Service.Ports {
+		portName := p.PortName
+
+		targetPort := intstr.IntOrString{
+			Type:   intstr.Int,
+			IntVal: p.Port,
+		}
+
+		if p.TargetPort.String() != "0" {
+			targetPort = p.TargetPort
+		}
+
+		cp := corev1.ServicePort{
+			Name:       portName,
+			Protocol:   corev1.ProtocolTCP,
+			Port:       p.Port,
+			TargetPort: targetPort,
+		}
+
+		if v := p.AppProtocol; v != "" {
+			cp.AppProtocol = &v
+		}
+
+		ports = append(ports, cp)
+	}
+
+	return ports
+}
+
+func (c *KubernetesDefaultRouter) getServicePorts(canary *flaggerv1.Canary) []corev1.ServicePort {
+	if len(canary.Spec.Service.Ports) == 0 {
+		return append(
+			[]corev1.ServicePort{
+				c.getApexServicePort(canary),
+			},
+			c.getDiscoveryServicePorts(canary)...,
+		)
+	} else {
+		return c.getExplicitServicePorts(canary)
+	}
+}
+
+func (c *KubernetesDefaultRouter) reconcileService(canary *flaggerv1.Canary, name string, podSelector string, metadata *flaggerv1.CustomMetadata) error {
+	// set pod selector
+	svcSpec := corev1.ServiceSpec{
+		Type:     corev1.ServiceTypeClusterIP,
+		Selector: map[string]string{c.labelSelector: podSelector},
+	}
+
+	if canary.Spec.Service.Headless {
+		svcSpec.ClusterIP = "None"
+	}
+
+	svcSpec.Ports = c.getServicePorts(canary)
+
 	if metadata == nil {
 		metadata = &flaggerv1.CustomMetadata{}
 	}