feat(ingress): ingresses datatable with add/edit ingresses EE-2615 (#7672)

api/http/handler/kubernetes/configmaps_and_secrets.go

@@ -0,0 +1,33 @@
+package kubernetes
+
+import (
+	"net/http"
+
+	httperror "github.com/portainer/libhttp/error"
+	"github.com/portainer/libhttp/request"
+	"github.com/portainer/libhttp/response"
+)
+
+func (handler *Handler) getKubernetesConfigMaps(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	cli := handler.KubernetesClient
+
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	configmaps, err := cli.GetConfigMapsAndSecrets(namespace)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+
+	return response.JSON(w, configmaps)
+}

api/http/handler/kubernetes/handler.go

@@ -2,11 +2,15 @@ package kubernetes
 
 import (
 	"errors"
-	"github.com/portainer/portainer/api/kubernetes"
 	"net/http"
 
+	portainer "github.com/portainer/portainer/api"
+	portainerDsErrors "github.com/portainer/portainer/api/dataservices/errors"
+	"github.com/portainer/portainer/api/kubernetes"
+
 	"github.com/gorilla/mux"
 	httperror "github.com/portainer/libhttp/error"
+	"github.com/portainer/libhttp/request"
 	"github.com/portainer/portainer/api/dataservices"
 	"github.com/portainer/portainer/api/http/middlewares"
 	"github.com/portainer/portainer/api/http/security"
@@ -23,10 +27,11 @@ type Handler struct {
 	jwtService               dataservices.JWTService
 	kubernetesClientFactory  *cli.ClientFactory
 	kubeClusterAccessService kubernetes.KubeClusterAccessService
+	KubernetesClient         portainer.KubeClient
 }
 
 // NewHandler creates a handler to process pre-proxied requests to external APIs.
-func NewHandler(bouncer *security.RequestBouncer, authorizationService *authorization.Service, dataStore dataservices.DataStore, jwtService dataservices.JWTService, kubeClusterAccessService kubernetes.KubeClusterAccessService, kubernetesClientFactory *cli.ClientFactory) *Handler {
+func NewHandler(bouncer *security.RequestBouncer, authorizationService *authorization.Service, dataStore dataservices.DataStore, jwtService dataservices.JWTService, kubeClusterAccessService kubernetes.KubeClusterAccessService, kubernetesClientFactory *cli.ClientFactory, kubernetesClient portainer.KubeClient) *Handler {
 	h := &Handler{
 		Router:                   mux.NewRouter(),
 		authorizationService:     authorizationService,
@@ -34,6 +39,7 @@ func NewHandler(bouncer *security.RequestBouncer, authorizationService *authoriz
 		jwtService:               jwtService,
 		kubeClusterAccessService: kubeClusterAccessService,
 		kubernetesClientFactory:  kubernetesClientFactory,
+		KubernetesClient:         kubernetesClient,
 	}
 
 	kubeRouter := h.PathPrefix("/kubernetes").Subrouter()
@@ -45,15 +51,32 @@ func NewHandler(bouncer *security.RequestBouncer, authorizationService *authoriz
 	endpointRouter := kubeRouter.PathPrefix("/{id}").Subrouter()
 	endpointRouter.Use(middlewares.WithEndpoint(dataStore.Endpoint(), "id"))
 	endpointRouter.Use(kubeOnlyMiddleware)
+	endpointRouter.Use(h.kubeClient)
 
-	endpointRouter.PathPrefix("/nodes_limits").Handler(
-		bouncer.AuthenticatedAccess(httperror.LoggerHandler(h.getKubernetesNodesLimits))).Methods(http.MethodGet)
+	endpointRouter.PathPrefix("/nodes_limits").Handler(httperror.LoggerHandler(h.getKubernetesNodesLimits)).Methods(http.MethodGet)
+	endpointRouter.Handle("/ingresscontrollers", httperror.LoggerHandler(h.getKubernetesIngressControllers)).Methods(http.MethodGet)
+	endpointRouter.Handle("/ingresscontrollers", httperror.LoggerHandler(h.updateKubernetesIngressControllers)).Methods(http.MethodPut)
+	endpointRouter.Handle("/ingresses/delete", httperror.LoggerHandler(h.deleteKubernetesIngresses)).Methods(http.MethodPost)
+	endpointRouter.Handle("/services/delete", httperror.LoggerHandler(h.deleteKubernetesServices)).Methods(http.MethodPost)
+	endpointRouter.Path("/namespaces").Handler(httperror.LoggerHandler(h.createKubernetesNamespace)).Methods(http.MethodPost)
+	endpointRouter.Path("/namespaces").Handler(httperror.LoggerHandler(h.updateKubernetesNamespace)).Methods(http.MethodPut)
+	endpointRouter.Path("/namespaces").Handler(httperror.LoggerHandler(h.getKubernetesNamespaces)).Methods(http.MethodGet)
+	endpointRouter.Path("/namespace/{namespace}").Handler(httperror.LoggerHandler(h.deleteKubernetesNamespaces)).Methods(http.MethodDelete)
 
 	// namespaces
 	// in the future this piece of code might be in another package (or a few different packages - namespaces/namespace?)
 	// to keep it simple, we've decided to leave it like this.
 	namespaceRouter := endpointRouter.PathPrefix("/namespaces/{namespace}").Subrouter()
 	namespaceRouter.Handle("/system", bouncer.RestrictedAccess(httperror.LoggerHandler(h.namespacesToggleSystem))).Methods(http.MethodPut)
+	namespaceRouter.Handle("/ingresscontrollers", httperror.LoggerHandler(h.getKubernetesIngressControllersByNamespace)).Methods(http.MethodGet)
+	namespaceRouter.Handle("/ingresscontrollers", httperror.LoggerHandler(h.updateKubernetesIngressControllersByNamespace)).Methods(http.MethodPut)
+	namespaceRouter.Handle("/configmaps", httperror.LoggerHandler(h.getKubernetesConfigMaps)).Methods(http.MethodGet)
+	namespaceRouter.Handle("/ingresses", httperror.LoggerHandler(h.createKubernetesIngress)).Methods(http.MethodPost)
+	namespaceRouter.Handle("/ingresses", httperror.LoggerHandler(h.updateKubernetesIngress)).Methods(http.MethodPut)
+	namespaceRouter.Handle("/ingresses", httperror.LoggerHandler(h.getKubernetesIngresses)).Methods(http.MethodGet)
+	namespaceRouter.Handle("/services", httperror.LoggerHandler(h.createKubernetesService)).Methods(http.MethodPost)
+	namespaceRouter.Handle("/services", httperror.LoggerHandler(h.updateKubernetesService)).Methods(http.MethodPut)
+	namespaceRouter.Handle("/services", httperror.LoggerHandler(h.getKubernetesServices)).Methods(http.MethodGet)
 
 	return h
 }
@@ -75,3 +98,51 @@ func kubeOnlyMiddleware(next http.Handler) http.Handler {
 		next.ServeHTTP(rw, request)
 	})
 }
+
+func (handler *Handler) kubeClient(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		endpointID, err := request.RetrieveNumericRouteVariableValue(r, "id")
+		if err != nil {
+			httperror.WriteError(
+				w,
+				http.StatusBadRequest,
+				"Invalid environment identifier route variable",
+				err,
+			)
+		}
+
+		endpoint, err := handler.dataStore.Endpoint().Endpoint(portainer.EndpointID(endpointID))
+		if err == portainerDsErrors.ErrObjectNotFound {
+			httperror.WriteError(
+				w,
+				http.StatusNotFound,
+				"Unable to find an environment with the specified identifier inside the database",
+				err,
+			)
+		} else if err != nil {
+			httperror.WriteError(
+				w,
+				http.StatusInternalServerError,
+				"Unable to find an environment with the specified identifier inside the database",
+				err,
+			)
+		}
+
+		if handler.kubernetesClientFactory == nil {
+			next.ServeHTTP(w, r)
+			return
+		}
+		kubeCli, err := handler.kubernetesClientFactory.GetKubeClient(endpoint)
+		if err != nil {
+			httperror.WriteError(
+				w,
+				http.StatusInternalServerError,
+				"Unable to create Kubernetes client",
+				err,
+			)
+
+		}
+		handler.KubernetesClient = kubeCli
+		next.ServeHTTP(w, r)
+	})
+}

api/http/handler/kubernetes/ingresses.go

@@ -0,0 +1,410 @@
+package kubernetes
+
+import (
+	"fmt"
+	"net/http"
+
+	httperror "github.com/portainer/libhttp/error"
+	"github.com/portainer/libhttp/request"
+	"github.com/portainer/libhttp/response"
+	portainer "github.com/portainer/portainer/api"
+	"github.com/portainer/portainer/api/database/models"
+	portainerDsErrors "github.com/portainer/portainer/api/dataservices/errors"
+)
+
+func (handler *Handler) getKubernetesIngressControllers(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	endpointID, err := request.RetrieveNumericRouteVariableValue(r, "id")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid environment identifier route variable",
+			Err:        err,
+		}
+	}
+
+	endpoint, err := handler.dataStore.Endpoint().Endpoint(portainer.EndpointID(endpointID))
+	if err == portainerDsErrors.ErrObjectNotFound {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusNotFound,
+			Message:    "Unable to find an environment with the specified identifier inside the database",
+			Err:        err,
+		}
+	} else if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to find an environment with the specified identifier inside the database",
+			Err:        err,
+		}
+	}
+
+	cli, err := handler.kubernetesClientFactory.GetKubeClient(endpoint)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to create Kubernetes client",
+			Err:        err,
+		}
+	}
+
+	controllers := cli.GetIngressControllers()
+	existingClasses := endpoint.Kubernetes.Configuration.IngressClasses
+	for i := range controllers {
+		controllers[i].Availability = true
+		controllers[i].New = true
+
+		// Check if the controller is blocked globally.
+		for _, a := range existingClasses {
+			controllers[i].New = false
+			if controllers[i].ClassName != a.Name {
+				continue
+			}
+			controllers[i].New = false
+
+			// Skip over non-global blocks.
+			if len(a.BlockedNamespaces) > 0 {
+				continue
+			}
+
+			if controllers[i].ClassName == a.Name {
+				controllers[i].Availability = !a.Blocked
+			}
+		}
+		// TODO: Update existingClasses to take care of New and remove no longer
+		// existing classes.
+	}
+	return response.JSON(w, controllers)
+}
+
+func (handler *Handler) getKubernetesIngressControllersByNamespace(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	endpointID, err := request.RetrieveNumericRouteVariableValue(r, "id")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid environment identifier route variable",
+			Err:        err,
+		}
+	}
+
+	endpoint, err := handler.dataStore.Endpoint().Endpoint(portainer.EndpointID(endpointID))
+	if err == portainerDsErrors.ErrObjectNotFound {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusNotFound,
+			Message:    "Unable to find an environment with the specified identifier inside the database",
+			Err:        err,
+		}
+	} else if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to find an environment with the specified identifier inside the database",
+			Err:        err,
+		}
+	}
+
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	cli, err := handler.kubernetesClientFactory.GetKubeClient(endpoint)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to create Kubernetes client",
+			Err:        err,
+		}
+	}
+
+	controllers := cli.GetIngressControllers()
+	existingClasses := endpoint.Kubernetes.Configuration.IngressClasses
+	for i := range controllers {
+		controllers[i].Availability = true
+		controllers[i].New = true
+
+		// Check if the controller is blocked globally or in the current
+		// namespace.
+		for _, a := range existingClasses {
+			if controllers[i].ClassName != a.Name {
+				continue
+			}
+			controllers[i].New = false
+
+			// If it's not blocked we're all done!
+			if !a.Blocked {
+				continue
+			}
+
+			// Global blocks.
+			if len(a.BlockedNamespaces) == 0 {
+				controllers[i].Availability = false
+				continue
+			}
+
+			// Also check the current namespace.
+			for _, ns := range a.BlockedNamespaces {
+				if namespace == ns {
+					controllers[i].Availability = false
+				}
+			}
+		}
+		// TODO: Update existingClasses to take care of New and remove no longer
+		// existing classes.
+	}
+	return response.JSON(w, controllers)
+}
+
+func (handler *Handler) updateKubernetesIngressControllers(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	endpointID, err := request.RetrieveNumericRouteVariableValue(r, "id")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid environment identifier route variable",
+			Err:        err,
+		}
+	}
+
+	endpoint, err := handler.dataStore.Endpoint().Endpoint(portainer.EndpointID(endpointID))
+	if err == portainerDsErrors.ErrObjectNotFound {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusNotFound,
+			Message:    "Unable to find an environment with the specified identifier inside the database",
+			Err:        err,
+		}
+	} else if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to find an environment with the specified identifier inside the database",
+			Err:        err,
+		}
+	}
+
+	var payload models.K8sIngressControllers
+	err = request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	classes := endpoint.Kubernetes.Configuration.IngressClasses
+	for _, p := range payload {
+		for i := range classes {
+			if p.ClassName == classes[i].Name {
+				classes[i].Blocked = !p.Availability
+			}
+		}
+	}
+	endpoint.Kubernetes.Configuration.IngressClasses = classes
+	fmt.Printf("%#v\n", endpoint.Kubernetes.Configuration.IngressClasses)
+	err = handler.dataStore.Endpoint().UpdateEndpoint(
+		portainer.EndpointID(endpointID),
+		endpoint,
+	)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to update the BlockedIngressClasses inside the database",
+			Err:        err,
+		}
+	}
+	return nil
+}
+
+func (handler *Handler) updateKubernetesIngressControllersByNamespace(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	endpointID, err := request.RetrieveNumericRouteVariableValue(r, "id")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid environment identifier route variable",
+			Err:        err,
+		}
+	}
+
+	endpoint, err := handler.dataStore.Endpoint().Endpoint(portainer.EndpointID(endpointID))
+	if err == portainerDsErrors.ErrObjectNotFound {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusNotFound,
+			Message:    "Unable to find an environment with the specified identifier inside the database",
+			Err:        err,
+		}
+	} else if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to find an environment with the specified identifier inside the database",
+			Err:        err,
+		}
+	}
+
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	var payload models.K8sIngressControllers
+	err = request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	classes := endpoint.Kubernetes.Configuration.IngressClasses
+PayloadLoop:
+	for _, p := range payload {
+		for i := range classes {
+			if p.ClassName == classes[i].Name {
+				if p.Availability == true {
+					classes[i].Blocked = false
+					classes[i].BlockedNamespaces = []string{}
+					continue PayloadLoop
+				}
+
+				// If it's meant to be blocked we need to add the current
+				// namespace. First, check if it's already in the
+				// BlockedNamespaces and if not we append it.
+				classes[i].Blocked = true
+				for _, ns := range classes[i].BlockedNamespaces {
+					if namespace == ns {
+						continue PayloadLoop
+					}
+				}
+				classes[i].BlockedNamespaces = append(
+					classes[i].BlockedNamespaces,
+					namespace,
+				)
+			}
+		}
+	}
+	endpoint.Kubernetes.Configuration.IngressClasses = classes
+	fmt.Printf("%#v\n", endpoint.Kubernetes.Configuration.IngressClasses)
+	err = handler.dataStore.Endpoint().UpdateEndpoint(
+		portainer.EndpointID(endpointID),
+		endpoint,
+	)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to update the BlockedIngressClasses inside the database",
+			Err:        err,
+		}
+	}
+	return nil
+}
+
+func (handler *Handler) getKubernetesIngresses(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	cli := handler.KubernetesClient
+	ingresses, err := cli.GetIngresses(namespace)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+
+	return response.JSON(w, ingresses)
+}
+
+func (handler *Handler) createKubernetesIngress(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	var payload models.K8sIngressInfo
+	err = request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	cli := handler.KubernetesClient
+	err = cli.CreateIngress(namespace, payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+	return nil
+}
+
+func (handler *Handler) deleteKubernetesIngresses(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	cli := handler.KubernetesClient
+
+	var payload models.K8sIngressDeleteRequests
+	err := request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return httperror.BadRequest("Invalid request payload", err)
+	}
+
+	err = cli.DeleteIngresses(payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+	return nil
+}
+
+func (handler *Handler) updateKubernetesIngress(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	var payload models.K8sIngressInfo
+	err = request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	cli := handler.KubernetesClient
+	err = cli.UpdateIngress(namespace, payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+	return nil
+}

api/http/handler/kubernetes/namespaces.go

@@ -0,0 +1,97 @@
+package kubernetes
+
+import (
+	"net/http"
+
+	httperror "github.com/portainer/libhttp/error"
+	"github.com/portainer/libhttp/request"
+	"github.com/portainer/libhttp/response"
+	"github.com/portainer/portainer/api/database/models"
+)
+
+func (handler *Handler) getKubernetesNamespaces(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	cli := handler.KubernetesClient
+
+	namespaces, err := cli.GetNamespaces()
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+
+	return response.JSON(w, namespaces)
+}
+
+func (handler *Handler) createKubernetesNamespace(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	cli := handler.KubernetesClient
+
+	var payload models.K8sNamespaceInfo
+	err := request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	err = cli.CreateNamespace(payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+	return nil
+}
+
+func (handler *Handler) deleteKubernetesNamespaces(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	cli := handler.KubernetesClient
+
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	err = cli.DeleteNamespace(namespace)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+
+	return nil
+}
+
+func (handler *Handler) updateKubernetesNamespace(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	cli := handler.KubernetesClient
+
+	var payload models.K8sNamespaceInfo
+	err := request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	err = cli.UpdateNamespace(payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+	return nil
+}

api/http/handler/kubernetes/services.go

@@ -0,0 +1,121 @@
+package kubernetes
+
+import (
+	"net/http"
+
+	httperror "github.com/portainer/libhttp/error"
+	"github.com/portainer/libhttp/request"
+	"github.com/portainer/libhttp/response"
+	"github.com/portainer/portainer/api/database/models"
+)
+
+func (handler *Handler) getKubernetesServices(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	cli := handler.KubernetesClient
+	services, err := cli.GetServices(namespace)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve services",
+			Err:        err,
+		}
+	}
+
+	return response.JSON(w, services)
+}
+
+func (handler *Handler) createKubernetesService(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	var payload models.K8sServiceInfo
+	err = request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	cli := handler.KubernetesClient
+	err = cli.CreateService(namespace, payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+	return nil
+}
+
+func (handler *Handler) deleteKubernetesServices(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	cli := handler.KubernetesClient
+
+	var payload models.K8sServiceDeleteRequests
+	err := request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	err = cli.DeleteServices(payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+	return nil
+}
+
+func (handler *Handler) updateKubernetesService(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
+	namespace, err := request.RetrieveRouteVariableValue(r, "namespace")
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid namespace identifier route variable",
+			Err:        err,
+		}
+	}
+
+	var payload models.K8sServiceInfo
+	err = request.DecodeAndValidateJSONPayload(r, &payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusBadRequest,
+			Message:    "Invalid request payload",
+			Err:        err,
+		}
+	}
+
+	cli := handler.KubernetesClient
+	err = cli.UpdateService(namespace, payload)
+	if err != nil {
+		return &httperror.HandlerError{
+			StatusCode: http.StatusInternalServerError,
+			Message:    "Unable to retrieve nodes limits",
+			Err:        err,
+		}
+	}
+	return nil
+}