Target Allocator implementation (Part 1 - OTEL Operator Enhancements)

api/v1alpha1/opentelemetrycollector_types.go

@@ -41,6 +41,11 @@ type OpenTelemetryCollectorSpec struct {
 	// +operator-sdk:gen-csv:customresourcedefinitions.specDescriptors=true
 	Image string `json:"image,omitempty"`
 
+	// TargetAllocator indicates a value which determines whether to spawn a target allocation resource or not.
+	// +optional
+	// +operator-sdk:gen-csv:customresourcedefinitions.specDescriptors=true
+	TargetAllocator OpenTelemetryTargetAllocator `json:"targetAllocator,omitempty"`
+
 	// Mode represents how the collector should be deployed (deployment, daemonset, statefulset or sidecar)
 	// +optional
 	// +operator-sdk:gen-csv:customresourcedefinitions.specDescriptors=true
@@ -116,6 +121,17 @@ type OpenTelemetryCollectorStatus struct {
 	Messages []string `json:"messages,omitempty"`
 }
 
+// OpenTelemetryTargetAllocator defines the configurations for the Prometheus target allocator.
+type OpenTelemetryTargetAllocator struct {
+	// Enabled indicates whether to use a target allocation mechanism for Prometheus targets or not.
+	// +optional
+	Enabled bool `json:"enabled,omitempty"`
+
+	// Image indicates the container image to use for the OpenTelemetry TargetAllocator.
+	// +optional
+	Image string `json:"image,omitempty"`
+}
+
 // +kubebuilder:object:root=true
 // +kubebuilder:resource:shortName=otelcol;otelcols
 // +kubebuilder:subresource:status

bundle/manifests/opentelemetry-operator.clusterserviceversion.yaml

@@ -21,7 +21,7 @@ metadata:
     containerImage: quay.io/opentelemetry/opentelemetry-operator
     createdAt: "2020-12-16T13:37:00+00:00"
     description: Provides the OpenTelemetry components, including the Collector
-    operators.operatorframework.io/builder: operator-sdk-v1.8.0+git
+    operators.operatorframework.io/builder: operator-sdk-v1.8.0
     operators.operatorframework.io/project_layout: go.kubebuilder.io/v2
     repository: github.com/open-telemetry/opentelemetry-operator
     support: OpenTelemetry Community
@@ -77,6 +77,14 @@ spec:
           verbs:
           - list
           - watch
+        - apiGroups:
+          - ""
+          resources:
+          - pods
+          verbs:
+          - get
+          - list
+          - watch
         - apiGroups:
           - ""
           resources:
@@ -174,6 +182,26 @@ spec:
           - get
           - patch
           - update
+        - apiGroups:
+          - rbac.authorization.k8s.io
+          resources:
+          - rolebindings
+          verbs:
+          - create
+          - delete
+          - get
+          - list
+          - watch
+        - apiGroups:
+          - rbac.authorization.k8s.io
+          resources:
+          - roles
+          verbs:
+          - create
+          - delete
+          - get
+          - list
+          - watch
         - apiGroups:
           - authentication.k8s.io
           resources:

bundle/manifests/opentelemetry.io_opentelemetrycollectors.yaml

@@ -431,6 +431,19 @@ spec:
                 description: ServiceAccount indicates the name of an existing service
                   account to use with this instance.
                 type: string
+              targetAllocator:
+                description: TargetAllocator indicates a value which determines whether
+                  to spawn a target allocation resource or not.
+                properties:
+                  enabled:
+                    description: Enabled indicates whether to use a target allocation
+                      mechanism for Prometheus targets or not.
+                    type: boolean
+                  image:
+                    description: Image indicates the container image to use for the
+                      OpenTelemetry TargetAllocator.
+                    type: string
+                type: object
               tolerations:
                 description: Toleration to schedule OpenTelemetry Collector pods.
                   This is only relevant to daemonsets, statefulsets and deployments

config/crd/bases/opentelemetry.io_opentelemetrycollectors.yaml

@@ -419,6 +419,19 @@ spec:
                 description: ServiceAccount indicates the name of an existing service
                   account to use with this instance.
                 type: string
+              targetAllocator:
+                description: TargetAllocator indicates a value which determines whether
+                  to spawn a target allocation resource or not.
+                properties:
+                  enabled:
+                    description: Enabled indicates whether to use a target allocation
+                      mechanism for Prometheus targets or not.
+                    type: boolean
+                  image:
+                    description: Image indicates the container image to use for the
+                      OpenTelemetry TargetAllocator.
+                    type: string
+                type: object
               tolerations:
                 description: Toleration to schedule OpenTelemetry Collector pods.
                   This is only relevant to daemonsets, statefulsets and deployments

config/rbac/role.yaml

@@ -32,6 +32,14 @@ rules:
   verbs:
   - list
   - watch
+- apiGroups:
+  - ""
+  resources:
+  - pods
+  verbs:
+  - get
+  - list
+  - watch
 - apiGroups:
   - ""
   resources:
@@ -129,3 +137,23 @@ rules:
   - get
   - patch
   - update
+- apiGroups:
+  - rbac.authorization.k8s.io
+  resources:
+  - rolebindings
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - watch
+- apiGroups:
+  - rbac.authorization.k8s.io
+  resources:
+  - roles
+  verbs:
+  - create
+  - delete
+  - get
+  - list
+  - watch

controllers/targetallocator_controller.go

@@ -0,0 +1,156 @@
+// Copyright The OpenTelemetry Authors
+//
+// 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 controllers contains the main controller, where the reconciliation starts.
+package controllers
+
+import (
+	"context"
+	"fmt"
+
+	ctrl "sigs.k8s.io/controller-runtime"
+
+	"github.com/go-logr/logr"
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	rbacv1 "k8s.io/api/rbac/v1"
+	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+
+	"github.com/open-telemetry/opentelemetry-operator/api/v1alpha1"
+	"github.com/open-telemetry/opentelemetry-operator/internal/config"
+	"github.com/open-telemetry/opentelemetry-operator/pkg/targetallocator/reconcile"
+)
+
+// OpenTelemetryTargetAllocatorReconciler reconciles a OpenTelemetryTargetAllocator object.
+type OpenTelemetryTargetAllocatorReconciler struct {
+	client.Client
+	log    logr.Logger
+	scheme *runtime.Scheme
+	config config.Config
+	tasks  []TgAlTask
+}
+
+// TgAlTask represents a reconciliation task to be executed by the reconciler.
+type TgAlTask struct {
+	Name        string
+	Do          func(context.Context, reconcile.Params) error
+	BailOnError bool
+}
+
+// TgAlParams is the set of options to build a new OpenTelemetryTargetAllocatorReconciler.
+type TgAlParams struct {
+	client.Client
+	Log    logr.Logger
+	Scheme *runtime.Scheme
+	Config config.Config
+	Tasks  []TgAlTask
+}
+
+// NewTgAlReconciler creates a new reconciler for OpenTelemetryTargetAllocator objects.
+func NewTgAlReconciler(p TgAlParams) *OpenTelemetryTargetAllocatorReconciler {
+	if len(p.Tasks) == 0 {
+		p.Tasks = []TgAlTask{
+			{
+				"roles",
+				reconcile.Roles,
+				true,
+			},
+			{
+				"role bindings",
+				reconcile.RoleBindings,
+				true,
+			},
+			{
+				"config maps",
+				reconcile.ConfigMaps,
+				true,
+			},
+			{
+				"deployments",
+				reconcile.Deployments,
+				true,
+			},
+			{
+				"services",
+				reconcile.Services,
+				true,
+			},
+		}
+	}
+
+	return &OpenTelemetryTargetAllocatorReconciler{
+		Client: p.Client,
+		log:    p.Log,
+		scheme: p.Scheme,
+		config: p.Config,
+		tasks:  p.Tasks,
+	}
+}
+
+// Reconcile the current state of an OpenTelemetry target allocation resource with the desired state.
+// follows the same design as the opentelemetrycollector controller where an empty context is passed
+// and a new context initialized inside.
+func (r *OpenTelemetryTargetAllocatorReconciler) Reconcile(_ context.Context, req ctrl.Request) (ctrl.Result, error) {
+	ctx := context.Background()
+	log := r.log.WithValues("opentelemtrytargetallocator", req.NamespacedName)
+
+	var instance v1alpha1.OpenTelemetryCollector
+	if err := r.Get(ctx, req.NamespacedName, &instance); err != nil {
+		if !apierrors.IsNotFound(err) {
+			log.Error(err, "unable to fetch OpenTelemetryTargetAllocator")
+		}
+		return ctrl.Result{}, client.IgnoreNotFound(err)
+	}
+
+	params := reconcile.Params{
+		Config:   r.config,
+		Client:   r.Client,
+		Instance: instance,
+		Log:      log,
+		Scheme:   r.scheme,
+	}
+
+	if err := r.RunTasks(ctx, params); err != nil {
+		return ctrl.Result{}, err
+	}
+
+	return ctrl.Result{}, nil
+}
+
+// RunTasks runs all the tasks associated with this reconciler.
+func (r *OpenTelemetryTargetAllocatorReconciler) RunTasks(ctx context.Context, params reconcile.Params) error {
+	for _, task := range r.tasks {
+		if err := task.Do(ctx, params); err != nil {
+			r.log.Error(err, fmt.Sprintf("failed to reconcile %s", task.Name))
+			if task.BailOnError {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// SetupWithManager tells the manager what our controller is interested in.
+func (r *OpenTelemetryTargetAllocatorReconciler) SetupWithManager(mgr ctrl.Manager) error {
+	return ctrl.NewControllerManagedBy(mgr).
+		For(&v1alpha1.OpenTelemetryCollector{}).
+		Owns(&rbacv1.Role{}).
+		Owns(&rbacv1.RoleBinding{}).
+		Owns(&corev1.ConfigMap{}).
+		Owns(&corev1.Service{}).
+		Owns(&appsv1.Deployment{}).
+		Complete(r)
+}