Add operator agent install method

common/config/environment.go

@@ -22,6 +22,7 @@ const (
 	DDTestingWorkloadNamespace = "ddtestworkload"
 	DDDogstatsdNamespace       = "dddogstatsd"
 	DDUpdaterConfigNamespace   = "ddupdater"
+	DDOperatorConfigNamespace  = "ddoperator"
 
 	// Infra namespace
 	DDInfraEnvironment                      = "env"
@@ -34,12 +35,15 @@ const (
 
 	// Agent Namespace
 	DDAgentDeployParamName               = "deploy"
+	DDAgentDeployWithOperatorParamName   = "deployWithOperator"
 	DDAgentVersionParamName              = "version"
 	DDAgentPipelineID                    = "pipeline_id"
 	DDAgentCommitSHA                     = "commit_sha"
 	DDAgentFullImagePathParamName        = "fullImagePath"
 	DDClusterAgentVersionParamName       = "clusterAgentVersion"
 	DDClusterAgentFullImagePathParamName = "clusterAgentFullImagePath"
+	DDOperatorVersionParamName           = "operatorVersion"
+	DDOperatorFullImagePathParamName     = "operatorFullImagePath"
 	DDImagePullRegistryParamName         = "imagePullRegistry"
 	DDImagePullUsernameParamName         = "imagePullUsername"
 	DDImagePullPasswordParamName         = "imagePullPassword"
@@ -71,6 +75,7 @@ type CommonEnvironment struct {
 	TestingWorkloadConfig *sdkconfig.Config
 	DogstatsdConfig       *sdkconfig.Config
 	UpdaterConfig         *sdkconfig.Config
+	OperatorConfig        *sdkconfig.Config
 
 	username string
 }
@@ -98,6 +103,8 @@ type Env interface {
 	ClusterAgentVersion() string
 	AgentFullImagePath() string
 	ClusterAgentFullImagePath() string
+	OperatorFullImagePath() string
+	OperatorVersion() string
 	ImagePullRegistry() string
 	ImagePullUsername() string
 	ImagePullPassword() pulumi.StringOutput
@@ -132,6 +139,7 @@ func NewCommonEnvironment(ctx *pulumi.Context) (CommonEnvironment, error) {
 		DogstatsdConfig:       sdkconfig.New(ctx, DDDogstatsdNamespace),
 		UpdaterConfig:         sdkconfig.New(ctx, DDUpdaterConfigNamespace),
 		commonNamer:           namer.NewNamer(ctx, ""),
+		OperatorConfig:        sdkconfig.New(ctx, DDOperatorConfigNamespace),
 		providerRegistry:      newProviderRegistry(ctx),
 	}
 	// store username
@@ -147,6 +155,8 @@ func NewCommonEnvironment(ctx *pulumi.Context) (CommonEnvironment, error) {
 	ctx.Log.Debug(fmt.Sprintf("pipeline id: %s", env.PipelineID()), nil)
 	ctx.Log.Debug(fmt.Sprintf("deploy: %v", env.AgentDeploy()), nil)
 	ctx.Log.Debug(fmt.Sprintf("full image path: %v", env.AgentFullImagePath()), nil)
+	ctx.Log.Debug(fmt.Sprintf("deploy with Operator: %v", env.AgentDeployWithOperator()), nil)
+	ctx.Log.Debug(fmt.Sprintf("operator full image path: %v", env.OperatorFullImagePath()), nil)
 	return env, nil
 }
 
@@ -226,6 +236,10 @@ func (e *CommonEnvironment) AgentDeploy() bool {
 	return e.GetBoolWithDefault(e.AgentConfig, DDAgentDeployParamName, true)
 }
 
+func (e *CommonEnvironment) AgentDeployWithOperator() bool {
+	return e.GetBoolWithDefault(e.AgentConfig, DDAgentDeployWithOperatorParamName, false)
+}
+
 func (e *CommonEnvironment) AgentVersion() string {
 	return e.AgentConfig.Get(DDAgentVersionParamName)
 }
@@ -250,6 +264,14 @@ func (e *CommonEnvironment) ClusterAgentFullImagePath() string {
 	return e.AgentConfig.Get(DDClusterAgentFullImagePathParamName)
 }
 
+func (e *CommonEnvironment) OperatorVersion() string {
+	return e.OperatorConfig.Get(DDOperatorVersionParamName)
+}
+
+func (e *CommonEnvironment) OperatorFullImagePath() string {
+	return e.OperatorConfig.Get(DDOperatorFullImagePathParamName)
+}
+
 func (e *CommonEnvironment) ImagePullRegistry() string {
 	return e.AgentConfig.Get(DDImagePullRegistryParamName)
 }

common/config/helpers.go

@@ -33,6 +33,10 @@ func ClusterAgentSemverVersion(e Env) (*semver.Version, error) {
 	return anyAgentSemverVersion(e.ClusterAgentVersion())
 }
 
+func OperatorSemverVersion(e Env) (*semver.Version, error) {
+	return anyAgentSemverVersion(e.OperatorVersion())
+}
+
 func tagListToKeyValueMap(tagList []string) (map[string]string, error) {
 	tags := map[string]string{}
 	for _, tag := range tagList {

common/utils/kubernetes.go

@@ -1,12 +1,19 @@
 package utils
 
 import (
+	"encoding/base64"
 	"encoding/json"
 
+	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
+	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 	"gopkg.in/yaml.v3"
+
+	"github.com/DataDog/test-infra-definitions/common/config"
 )
 
+const imagePullSecretName = "registry-credentials"
+
 // KubeConfigYAMLToJSON safely converts a yaml kubeconfig to a json string.
 func KubeConfigYAMLToJSON(kubeConfig pulumi.StringOutput) pulumi.StringInput {
 	return kubeConfig.ApplyT(func(config string) (string, error) {
@@ -23,3 +30,35 @@ func KubeConfigYAMLToJSON(kubeConfig pulumi.StringOutput) pulumi.StringInput {
 		return string(jsonConfig), nil
 	}).(pulumi.StringInput)
 }
+
+// NewImagePullSecret creates an image pull secret based on environment
+func NewImagePullSecret(e config.Env, namespace string, opts ...pulumi.ResourceOption) (*corev1.Secret, error) {
+	dockerConfigJSON := e.ImagePullPassword().ApplyT(func(password string) (string, error) {
+		dockerConfigJSON, err := json.Marshal(map[string]map[string]map[string]string{
+			"auths": {
+				e.ImagePullRegistry(): {
+					"username": e.ImagePullUsername(),
+					"password": password,
+					"auth":     base64.StdEncoding.EncodeToString([]byte(e.ImagePullUsername() + ":" + password)),
+				},
+			},
+		})
+		return string(dockerConfigJSON), err
+	}).(pulumi.StringOutput)
+
+	return corev1.NewSecret(
+		e.Ctx(),
+		imagePullSecretName,
+		&corev1.SecretArgs{
+			Metadata: metav1.ObjectMetaArgs{
+				Namespace: pulumi.StringPtr(namespace),
+				Name:      pulumi.StringPtr(imagePullSecretName),
+			},
+			StringData: pulumi.StringMap{
+				".dockerconfigjson": dockerConfigJSON,
+			},
+			Type: pulumi.StringPtr("kubernetes.io/dockerconfigjson"),
+		},
+		opts...,
+	)
+}

components/datadog/agent/kubernetes_operator.go

@@ -0,0 +1,68 @@
+package agent
+
+import (
+	"github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+
+	"github.com/DataDog/test-infra-definitions/common/config"
+	"github.com/DataDog/test-infra-definitions/common/utils"
+	"github.com/DataDog/test-infra-definitions/components"
+	"github.com/DataDog/test-infra-definitions/components/datadog/agentwithoperatorparams"
+	"github.com/DataDog/test-infra-definitions/components/datadog/apps/dda"
+	"github.com/DataDog/test-infra-definitions/components/datadog/operator"
+	"github.com/DataDog/test-infra-definitions/components/datadog/operatorparams"
+)
+
+func NewDDAWithOperator(e config.Env, resourceName string, kubeProvider *kubernetes.Provider, operatorOpts []operatorparams.Option, ddaOptions ...agentwithoperatorparams.Option) (*KubernetesAgent, error) {
+	return components.NewComponent(e, resourceName, func(comp *KubernetesAgent) error {
+
+		operatorParams, err := operatorparams.NewParams(e, operatorOpts...)
+		if err != nil {
+			return err
+		}
+
+		ddaParams, err := agentwithoperatorparams.NewParams(ddaOptions...)
+
+		if err != nil {
+			return err
+		}
+
+		operatorComp, err := operator.NewOperator(e, resourceName, kubeProvider, operatorOpts...)
+
+		if err != nil {
+			return err
+		}
+
+		_, err = dda.K8sAppDefinition(e, kubeProvider, "datadog", ddaParams.FakeIntake, ddaParams.KubeletTLSVerify, e.Ctx().Stack(), ddaParams.DDAConfig, utils.PulumiDependsOn(operatorComp))
+
+		if err != nil {
+			return err
+		}
+
+		baseName := "dda-linux"
+
+		comp.LinuxNodeAgent, err = NewKubernetesObjRef(e, baseName+"-nodeAgent", operatorParams.Namespace, "Pod", pulumi.String("appVersion").ToStringOutput(), pulumi.String("Version").ToStringOutput(), map[string]string{"app": baseName + "-datadog"})
+
+		if err != nil {
+			return err
+		}
+
+		comp.LinuxClusterAgent, err = NewKubernetesObjRef(e, baseName+"-clusterAgent", operatorParams.Namespace, "Pod", pulumi.String("appVersion").ToStringOutput(), pulumi.String("Version").ToStringOutput(), map[string]string{
+			"app": baseName + "-datadog-cluster-agent",
+		})
+
+		if err != nil {
+			return err
+		}
+
+		comp.LinuxClusterChecks, err = NewKubernetesObjRef(e, baseName+"-clusterChecks", operatorParams.Namespace, "Pod", pulumi.String("appVersion").ToStringOutput(), pulumi.String("version").ToStringOutput(), map[string]string{
+			"app": baseName + "-datadog-clusterchecks",
+		})
+
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+}

components/datadog/agentwithoperatorparams/params.go

@@ -0,0 +1,68 @@
+package agentwithoperatorparams
+
+import (
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+
+	"github.com/DataDog/test-infra-definitions/common"
+	"github.com/DataDog/test-infra-definitions/common/utils"
+	"github.com/DataDog/test-infra-definitions/components/datadog/fakeintake"
+)
+
+type Params struct {
+	PulumiResourceOptions []pulumi.ResourceOption
+
+	Namespace        string
+	FakeIntake       *fakeintake.Fakeintake
+	DDAConfig        string
+	KubeletTLSVerify bool
+}
+
+type Option = func(*Params) error
+
+func NewParams(options ...Option) (*Params, error) {
+	version := &Params{
+		Namespace: "datadog",
+	}
+	return common.ApplyOption(version, options)
+}
+
+// WithNamespace sets the namespace to deploy the agent to.
+func WithNamespace(namespace string) func(*Params) error {
+	return func(p *Params) error {
+		p.Namespace = namespace
+		return nil
+	}
+}
+
+// WithTLSKubeletVerify toggles kubelet TLS verification.
+func WithTLSKubeletVerify(verify bool) func(*Params) error {
+	return func(p *Params) error {
+		p.KubeletTLSVerify = verify
+		return nil
+	}
+}
+
+// WithPulumiResourceOptions sets the resources to depend on.
+func WithPulumiResourceOptions(resources ...pulumi.ResourceOption) func(*Params) error {
+	return func(p *Params) error {
+		p.PulumiResourceOptions = append(p.PulumiResourceOptions, resources...)
+		return nil
+	}
+}
+
+// WithDDAConfig configures the DatadogAgent resource.
+func WithDDAConfig(config string) func(*Params) error {
+	return func(p *Params) error {
+		p.DDAConfig = p.DDAConfig + config
+		return nil
+	}
+}
+
+// WithFakeIntake configures the Agent to use the given fake intake.
+func WithFakeIntake(fakeintake *fakeintake.Fakeintake) func(*Params) error {
+	return func(p *Params) error {
+		p.PulumiResourceOptions = append(p.PulumiResourceOptions, utils.PulumiDependsOn(fakeintake))
+		p.FakeIntake = fakeintake
+		return nil
+	}
+}