implemented adaptive scaling

internal/controller/basic_authenticator/basicauthenticator_controller.go

@@ -23,9 +23,13 @@ import (
 	appv1 "k8s.io/api/apps/v1"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/types"
 	ctrl "sigs.k8s.io/controller-runtime"
 	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/log"
+	"sigs.k8s.io/controller-runtime/pkg/reconcile"
+	"sigs.k8s.io/controller-runtime/pkg/source"
 )
 
 // BasicAuthenticatorReconciler reconciles a BasicAuthenticator object
@@ -41,6 +45,7 @@ type BasicAuthenticatorReconciler struct {
 //+kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch;create;update;patch;delete
 //+kubebuilder:rbac:groups=core,resources=secrets,verbs=get;list;watch;create;update;patch;delete
 //+kubebuilder:rbac:groups=core,resources=configmaps,verbs=get;list;watch;create;update;patch;delete
+//+kubebuilder:rbac:groups=core,resources=services,verbs=get;list;watch;create;update;patch;delete
 
 func (r *BasicAuthenticatorReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	logger := log.FromContext(ctx)
@@ -56,5 +61,29 @@ func (r *BasicAuthenticatorReconciler) SetupWithManager(mgr ctrl.Manager) error
 		Owns(&appv1.Deployment{}).
 		Owns(&corev1.ConfigMap{}).
 		Owns(&corev1.Secret{}).
+		Watches(
+			&source.Kind{Type: &appv1.Deployment{}},
+			handler.EnqueueRequestsFromMapFunc(r.findExternallyManagedDeployments),
+		).
 		Complete(r)
 }
+
+func (r *BasicAuthenticatorReconciler) findExternallyManagedDeployments(deployment client.Object) []reconcile.Request {
+	deploy, ok := deployment.(*appv1.Deployment)
+	if !ok {
+		return nil
+	}
+	if deploy.ObjectMeta.Annotations == nil {
+		return nil
+	}
+	basicAuthName, exists := deploy.ObjectMeta.Annotations[ExternallyManaged]
+	if !exists {
+		return nil
+	}
+
+	return []reconcile.Request{
+		{
+			NamespacedName: types.NamespacedName{Name: basicAuthName, Namespace: deploy.Namespace},
+		},
+	}
+}

internal/controller/basic_authenticator/const.go

@@ -5,5 +5,6 @@ const (
 	nginxDefaultContainerName   = "nginx"
 	SecretAnnotation            = "authenticator.snappcloud.io/secret.name"
 	ConfigmapAnnotation         = "authenticator.snappcloud.io/configmap.name"
-	basicAuthenticatorFinalizer = "basicauthenticators.authenticator.snappcloud.io/finalizer"
+	basicAuthenticatorFinalizer = "basicauthenticator.snappcloud.io/finalizer"
+	ExternallyManaged           = "basicauthenticator.snappcloud.io/externally.managed"
 )

internal/controller/basic_authenticator/provision.go

@@ -9,8 +9,10 @@ import (
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/types"
+	"math"
 	"reflect"
 	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
 
@@ -194,12 +196,26 @@ func (r *BasicAuthenticatorReconciler) CreateDeploymentAuthenticator(ctx context
 			logger.Error(err, "failed to set deployment owner")
 			return subreconciler.RequeueWithError(err)
 		}
+		if basicAuthenticator.Spec.AdaptiveScale && basicAuthenticator.Spec.AppService != "" {
+			replica, err := r.AcquireTargetReplica(ctx, basicAuthenticator)
+			if err != nil {
+				logger.Error(err, "failed to acquire target replica using adaptiveScale")
+				return subreconciler.RequeueWithError(err)
+			}
+			newDeployment.Spec.Replicas = &replica
+		}
+
 		//create deployment
 		err := r.Create(ctx, newDeployment)
 		if err != nil {
 			logger.Error(err, "failed to create new deployment")
 			return subreconciler.RequeueWithError(err)
 		}
+		err = r.Get(ctx, types.NamespacedName{Name: foundDeployment.Name, Namespace: basicAuthenticator.Namespace}, foundDeployment)
+		if err != nil {
+			logger.Error(err, "failed to refetch")
+			return subreconciler.RequeueWithError(err)
+		}
 		logger.Info("created deployment")
 
 		return subreconciler.Requeue()
@@ -210,15 +226,32 @@ func (r *BasicAuthenticatorReconciler) CreateDeploymentAuthenticator(ctx context
 		}
 	} else {
 		//update deployment
+		targetReplica := newDeployment.Spec.Replicas
+		if basicAuthenticator.Spec.AdaptiveScale && basicAuthenticator.Spec.AppService != "" {
+			replica, err := r.AcquireTargetReplica(ctx, basicAuthenticator)
+			if err != nil {
+				logger.Error(err, "failed to acquire target replica using adaptiveScale")
+			}
+			targetReplica = &replica
+		}
 
 		if !reflect.DeepEqual(newDeployment.Spec, foundDeployment.Spec) {
 			logger.Info("updating deployment")
+
 			foundDeployment.Spec = newDeployment.Spec
+			foundDeployment.Spec.Replicas = targetReplica
+
 			err := r.Update(ctx, foundDeployment)
 			if err != nil {
 				logger.Error(err, "failed to update deployment")
 				return subreconciler.RequeueWithError(err)
 			}
+			err = r.Get(ctx, types.NamespacedName{Name: foundDeployment.Name, Namespace: basicAuthenticator.Namespace}, foundDeployment)
+			if err != nil {
+				logger.Error(err, "failed to refetch")
+				return subreconciler.RequeueWithError(err)
+			}
+
 		}
 		logger.Info("updating ready replicas")
 		basicAuthenticator.Status.ReadyReplicas = int(foundDeployment.Status.ReadyReplicas)
@@ -251,3 +284,39 @@ func (r *BasicAuthenticatorReconciler) CreateSidecarAuthenticator(ctx context.Co
 	}
 	return subreconciler.ContinueReconciling()
 }
+
+func (r *BasicAuthenticatorReconciler) AcquireTargetReplica(ctx context.Context, basicAuthenticator *v1alpha1.BasicAuthenticator) (int32, error) {
+	var targetService corev1.Service
+	// service should be in same ns with basic auth
+	if err := r.Get(ctx, types.NamespacedName{Name: basicAuthenticator.Spec.AppService, Namespace: basicAuthenticator.ObjectMeta.Namespace}, &targetService); err != nil {
+		return -1, err
+	}
+	labelSelector := targetService.Spec.Selector
+
+	deployments := &appv1.DeploymentList{}
+	if err := r.List(ctx, deployments, client.MatchingLabels(labelSelector)); err != nil {
+		return -1, err
+	}
+
+	if len(deployments.Items) == 0 {
+		return -1, defaultError.New("no deployment is selected by appService")
+	}
+
+	targetDeploy := deployments.Items[0] //we expect it to be single deployment
+	if targetDeploy.ObjectMeta.Annotations == nil {
+		targetDeploy.ObjectMeta.Annotations = make(map[string]string)
+	}
+	log.FromContext(context.Background()).Info("----- debug", "deployment revision:", targetDeploy.ResourceVersion)
+
+	targetDeploy.ObjectMeta.Annotations[ExternallyManaged] = basicAuthenticator.Name
+
+	err := r.Update(ctx, &targetDeploy)
+	if err != nil {
+		return -1, err
+	}
+	replicas := deployments.Items[0].Spec.Replicas
+	targetReplica := math.Floor(float64((*replicas + 1) / 2))
+	log.FromContext(context.Background()).Info("-------debug", "target Replica inside", targetReplica)
+
+	return int32(targetReplica), nil
+}

internal/controller/basic_authenticator/utility.go

@@ -1,6 +1,8 @@
 package basic_authenticator
 
-import "github.com/snapp-incubator/simple-authenticator/api/v1alpha1"
+import (
+	"github.com/snapp-incubator/simple-authenticator/api/v1alpha1"
+)
 
 func assignAnnotation(authenticator *v1alpha1.BasicAuthenticator, key, value string) {
 	if authenticator.ObjectMeta.Annotations == nil {

tests/e2e/adaptive-scaling/00-assert.yaml

@@ -0,0 +1,7 @@
+apiVersion: authenticator.snappcloud.io/v1alpha1
+kind: BasicAuthenticator
+metadata:
+  name: basicauthenticator-sample
+status:
+  readyReplicas: 2
+

tests/e2e/adaptive-scaling/00-install.yaml

@@ -0,0 +1,52 @@
+apiVersion: authenticator.snappcloud.io/v1alpha1
+kind: BasicAuthenticator
+metadata:
+  labels:
+    app.kubernetes.io/name: basicauthenticator
+    app.kubernetes.io/instance: basicauthenticator-sample
+    app.kubernetes.io/part-of: basicauthenticator
+    app.kubernetes.io/managed-by: kustomize
+    app.kubernetes.io/created-by: basicauthenticator
+  name: basicauthenticator-sample
+spec:
+  type: deployment
+  replicas: 1
+  appPort: 8080
+  appService: my-service
+  adaptiveScale: true
+  authenticatorPort: 8080
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: curl-deployment
+  labels:
+    test: fal
+    foo: bar
+spec:
+  replicas: 4
+  selector:
+    matchLabels:
+      foo: bar
+  template:
+    metadata:
+      labels:
+        foo: bar
+    spec:
+      containers:
+        - name: curl-container
+          image: curlimages/curl:latest
+          command: ["sleep", "infinity"]
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: my-service
+spec:
+  selector:
+    foo: bar
+  ports:
+    - protocol: TCP
+      port: 8080
+      targetPort: 8080
+  type: ClusterIP

tests/e2e/adaptive-scaling/01-assert.yaml

@@ -0,0 +1,7 @@
+apiVersion: authenticator.snappcloud.io/v1alpha1
+kind: BasicAuthenticator
+metadata:
+  name: basicauthenticator-sample
+status:
+  readyReplicas: 3
+

tests/e2e/adaptive-scaling/01-increase-deploy-replicas.yaml

@@ -0,0 +1,8 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: curl-deployment
+  labels:
+    foo: bar
+spec:
+  replicas: 6

tests/e2e/adaptive-scaling/02-assert.yaml

@@ -0,0 +1,7 @@
+apiVersion: authenticator.snappcloud.io/v1alpha1
+kind: BasicAuthenticator
+metadata:
+  name: basicauthenticator-sample
+status:
+  readyReplicas: 2
+

tests/e2e/adaptive-scaling/02-decrease-deploy-replicas.yaml

@@ -0,0 +1,8 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: curl-deployment
+  labels:
+    foo: bar
+spec:
+  replicas: 4