Add support to configure multiple service ports

api/apps/v1alpha1/common_types.go

@@ -21,6 +21,14 @@ import (
 	autoscalingv2 "k8s.io/api/autoscaling/v2"
 	corev1 "k8s.io/api/core/v1"
 	networkingv1 "k8s.io/api/networking/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
+)
+
+const (
+	// DefaultNamedPortAPI is the default named API port
+	DefaultNamedPortAPI = "api"
+	// DefaultNamedPortMetrics is the default named Metrics port
+	DefaultNamedPortMetrics = "metrics"
 )
 
 // Expose defines attributes to expose the service
@@ -115,3 +123,59 @@ type CertConfig struct {
 	// MountPath is the path where the certificates should be mounted in the container.
 	MountPath string `json:"mountPath"`
 }
+
+// selectNamedPort returns the first occurrence of a given named port, or an empty string if not found.
+func selectNamedPort(serviceSpec Service, portNames ...string) string {
+	for _, name := range portNames {
+		for _, port := range serviceSpec.Ports {
+			if port.Name == name {
+				return name
+			}
+		}
+	}
+	return ""
+}
+
+// getProbePort determines the appropriate port for probes based on the service spec.
+func getProbePort(serviceSpec Service) intstr.IntOrString {
+	switch len(serviceSpec.Ports) {
+	case 1:
+		port := serviceSpec.Ports[0]
+		if port.Name != "" {
+			return intstr.FromString(port.Name)
+		}
+		return intstr.FromInt(int(port.Port))
+	case 0:
+		// Default to "api" as the operator always adds a default named port with 8000
+		return intstr.FromString(DefaultNamedPortAPI)
+	default:
+		// Multiple ports: Prefer "api"
+		if portName := selectNamedPort(serviceSpec, DefaultNamedPortAPI); portName != "" {
+			return intstr.FromString(portName)
+		}
+		// Default when multiple ports exist
+		return intstr.FromString(DefaultNamedPortAPI)
+	}
+}
+
+// getMetricsPort determines the appropriate port for metrics based on the service spec.
+func getMetricsPort(serviceSpec Service) intstr.IntOrString {
+	switch len(serviceSpec.Ports) {
+	case 1:
+		port := serviceSpec.Ports[0]
+		if port.Name != "" {
+			return intstr.FromString(port.Name)
+		}
+		return intstr.FromInt(int(port.Port))
+	case 0:
+		// Default to "api" as the operator always adds a default named port with 8000
+		return intstr.FromString(DefaultNamedPortAPI)
+	default:
+		// Multiple ports: Prefer "metrics", fallback to "api"
+		if portName := selectNamedPort(serviceSpec, DefaultNamedPortMetrics, DefaultNamedPortAPI); portName != "" {
+			return intstr.FromString(portName)
+		}
+		// Default when multiple ports exist
+		return intstr.FromString(DefaultNamedPortMetrics)
+	}
+}

api/apps/v1alpha1/common_types_test.go

@@ -0,0 +1,72 @@
+/*
+Copyright 2025.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1alpha1
+
+import (
+	"testing"
+
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/util/intstr"
+)
+
+// assertEqual checks if the actual result matches the expected result.
+func assertEqual(t *testing.T, actual, expected intstr.IntOrString) {
+	if actual != expected {
+		t.Errorf("Got %v, expected %v", actual, expected)
+	}
+}
+
+func TestGetProbePort(t *testing.T) {
+	tests := []struct {
+		name        string
+		serviceSpec Service
+		expected    intstr.IntOrString
+	}{
+		{"Single named port", Service{Ports: []corev1.ServicePort{{Name: "api", Port: 8080}}}, intstr.FromString("api")},
+		{"Single unnamed port", Service{Ports: []corev1.ServicePort{{Port: 9090}}}, intstr.FromInt(9090)},
+		{"Multiple ports - prefers 'api'", Service{Ports: []corev1.ServicePort{{Name: "metrics", Port: 9090}, {Name: "api", Port: 8080}}}, intstr.FromString("api")},
+		{"No ports - uses legacy Port field", Service{Port: 7070}, intstr.FromString("api")},
+		{"No ports at all - defaults to 'api'", Service{}, intstr.FromString("api")},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assertEqual(t, getProbePort(tt.serviceSpec), tt.expected)
+		})
+	}
+}
+
+func TestGetMetricsPort(t *testing.T) {
+	tests := []struct {
+		name        string
+		serviceSpec Service
+		expected    intstr.IntOrString
+	}{
+		{"Single named port", Service{Ports: []corev1.ServicePort{{Name: "metrics", Port: 8081}}}, intstr.FromString("metrics")},
+		{"Single unnamed port", Service{Ports: []corev1.ServicePort{{Port: 8181}}}, intstr.FromInt(8181)},
+		{"Multiple ports - prefers 'metrics'", Service{Ports: []corev1.ServicePort{{Name: "api", Port: 8080}, {Name: "metrics", Port: 9090}}}, intstr.FromString("metrics")},
+		{"Multiple ports - no 'metrics', uses 'api'", Service{Ports: []corev1.ServicePort{{Name: "grpc", Port: 5050}, {Name: "api", Port: 8080}}}, intstr.FromString("api")},
+		{"No ports - uses legacy Port field", Service{Port: 6060}, intstr.FromString("api")},
+		{"No ports at all - defaults to 'metrics'", Service{}, intstr.FromString("api")},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			assertEqual(t, getMetricsPort(tt.serviceSpec), tt.expected)
+		})
+	}
+}

api/apps/v1alpha1/nemo_customizer_types.go

@@ -31,10 +31,13 @@ import (
 	networkingv1 "k8s.io/api/networking/v1"
 	rbacv1 "k8s.io/api/rbac/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/util/intstr"
 )
 
 const (
+	// CustomizerAPIPort is the default port that customizer serves on
+	CustomizerAPIPort = 8000
+	// CustomizerInternalPort is the default port used for syncing training progress
+	CustomizerInternalPort = 9009
 	// NemoCustomizerConditionReady indicates that the NEMO CustomizerService is ready.
 	NemoCustomizerConditionReady = "Ready"
 	// NemoCustomizerConditionFailed indicates that the NEMO CustomizerService has failed.
@@ -428,18 +431,15 @@ func (n *NemoCustomizer) GetStartupProbe() *corev1.Probe {
 // GetDefaultStartupProbe returns the default startup probe for the NemoCustomizer container
 func (n *NemoCustomizer) GetDefaultStartupProbe() *corev1.Probe {
 	probe := corev1.Probe{
-		FailureThreshold:    5,
-		InitialDelaySeconds: 10,
+		FailureThreshold:    30,
+		InitialDelaySeconds: 30,
 		PeriodSeconds:       10,
 		SuccessThreshold:    1,
 		TimeoutSeconds:      1,
 		ProbeHandler: corev1.ProbeHandler{
 			HTTPGet: &corev1.HTTPGetAction{
 				Path: "/v1/health/ready",
-				Port: intstr.IntOrString{
-					Type:   intstr.Type(1),
-					StrVal: "api",
-				},
+				Port: getProbePort(n.Spec.Expose.Service),
 			},
 		},
 	}
@@ -466,11 +466,7 @@ func (n *NemoCustomizer) GetDefaultLivenessProbe() *corev1.Probe {
 		ProbeHandler: corev1.ProbeHandler{
 			HTTPGet: &corev1.HTTPGetAction{
 				Path: "/v1/health/live",
-				Port: intstr.IntOrString{
-					Type:   intstr.Type(1),
-					StrVal: "api",
-				},
-				Scheme: "HTTP",
+				Port: getProbePort(n.Spec.Expose.Service),
 			},
 		},
 	}
@@ -496,10 +492,7 @@ func (n *NemoCustomizer) GetDefaultReadinessProbe() *corev1.Probe {
 		ProbeHandler: corev1.ProbeHandler{
 			HTTPGet: &corev1.HTTPGetAction{
 				Path: "/v1/health/ready",
-				Port: intstr.IntOrString{
-					Type:   intstr.Type(1),
-					StrVal: "api",
-				},
+				Port: getProbePort(n.Spec.Expose.Service),
 			},
 		},
 	}
@@ -569,19 +562,14 @@ func (n *NemoCustomizer) GetInternalServicePort() int32 {
 	}
 
 	// Default to 9009 if no internal port is found
-	return 9009
+	return CustomizerInternalPort
 }
 
 // GetServicePorts returns the service ports for the NemoCustomizer deployment
 func (n *NemoCustomizer) GetServicePorts() []corev1.ServicePort {
 	return n.Spec.Expose.Service.Ports
 }
 
-// GetServicePort returns the service port for the NemoCustomizer deployment
-func (n *NemoCustomizer) GetServicePort() int32 {
-	return n.Spec.Expose.Service.Port
-}
-
 // GetServiceType returns the service type for the NemoCustomizer deployment
 func (n *NemoCustomizer) GetServiceType() string {
 	return string(n.Spec.Expose.Service.Type)
@@ -661,24 +649,22 @@ func (n *NemoCustomizer) GetDeploymentParams() *rendertypes.DeploymentParams {
 	// Set runtime class
 	params.RuntimeClassName = n.GetRuntimeClass()
 
-	// Extract ports from spec and update rendering params
-	if len(n.GetServicePorts()) > 0 {
-		var containerPorts []corev1.ContainerPort
-		for _, svcPort := range n.GetServicePorts() {
-			containerPorts = append(containerPorts, corev1.ContainerPort{
-				Name:          svcPort.Name,
-				Protocol:      svcPort.Protocol,
-				ContainerPort: svcPort.Port,
-			})
-		}
-		params.Ports = containerPorts
-	} else {
-		params.Ports = []corev1.ContainerPort{{
-			Name:          "api",
+	// Setup container ports for customizer
+	// TODO: set these to use defined values in the service spec
+	// once that is allowed by the customizer through env variables
+	containerPorts := []corev1.ContainerPort{
+		{
+			Name:          DefaultNamedPortAPI,
 			Protocol:      corev1.ProtocolTCP,
-			ContainerPort: n.GetServicePort(),
-		}}
+			ContainerPort: CustomizerAPIPort,
+		},
+		{
+			Name:          "internal",
+			Protocol:      corev1.ProtocolTCP,
+			ContainerPort: CustomizerInternalPort,
+		},
 	}
+	params.Ports = containerPorts
 
 	return params
 }
@@ -749,13 +735,19 @@ func (n *NemoCustomizer) GetServiceParams() *rendertypes.ServiceParams {
 	if len(servicePorts) != 0 {
 		params.Ports = servicePorts
 	} else {
-		// Use corev1.ServicePort instead of deprecated params.Port
-		params.Ports = []corev1.ServicePort{{
-			Name:       "api",
-			Port:       8000,
-			TargetPort: intstr.FromInt(8000),
-			Protocol:   corev1.ProtocolTCP,
-		}}
+		// Set default ports
+		params.Ports = []corev1.ServicePort{
+			{
+				Name:     DefaultNamedPortAPI,
+				Port:     CustomizerAPIPort,
+				Protocol: corev1.ProtocolTCP,
+			},
+			{
+				Name:     "internal",
+				Port:     CustomizerInternalPort,
+				Protocol: corev1.ProtocolTCP,
+			},
+		}
 	}
 
 	return params
@@ -892,11 +884,20 @@ func (n *NemoCustomizer) GetServiceMonitorParams() *rendertypes.ServiceMonitorPa
 	params.Labels = svcLabels
 	params.Annotations = n.GetServiceMonitorAnnotations()
 
+	// Determine the appropriate port for monitoring
+	metricsPort := getMetricsPort(n.Spec.Expose.Service)
+
 	// Set Service Monitor spec
 	smSpec := monitoringv1.ServiceMonitorSpec{
 		NamespaceSelector: monitoringv1.NamespaceSelector{MatchNames: []string{n.Namespace}},
 		Selector:          metav1.LabelSelector{MatchLabels: n.GetServiceLabels()},
-		Endpoints:         []monitoringv1.Endpoint{{Port: "service-port", ScrapeTimeout: serviceMonitor.ScrapeTimeout, Interval: serviceMonitor.Interval}},
+		Endpoints: []monitoringv1.Endpoint{
+			{
+				Port:          metricsPort.StrVal,
+				ScrapeTimeout: serviceMonitor.ScrapeTimeout,
+				Interval:      serviceMonitor.Interval,
+			},
+		},
 	}
 	params.SMSpec = smSpec
 	return params