argocd.Cluster

import * as pulumi from "@pulumi/pulumi";
import * as argocd from "@three14/pulumi-argocd";
import * as aws from "@pulumi/aws";
import * as gcp from "@pulumi/gcp";
import * as kubernetes from "@pulumi/kubernetes";
import * as std from "@pulumi/std";

//# Bearer token Authentication
const kubernetes = new argocd.Cluster("kubernetes", {
    server: "https://1.2.3.4:12345",
    config: {
        bearerToken: "eyJhbGciOiJSUzI...",
        tlsClientConfig: {
            caData: std.file({
                input: "path/to/ca.pem",
            }).then(invoke => invoke.result),
        },
    },
});
//# GCP GKE cluster
const cluster = gcp.container.getCluster({
    name: "cluster",
    location: "europe-west1",
});
const argocdManager = new kubernetes.core.v1.ServiceAccount("argocd_manager", {metadata: {
    name: "argocd-manager",
    namespace: "kube-system",
}});
const argocdManagerClusterRole = new kubernetes.rbac.v1.ClusterRole("argocd_manager", {
    metadata: {
        name: "argocd-manager-role",
    },
    rules: [
        {
            apiGroups: ["*"],
            resources: ["*"],
            verbs: ["*"],
        },
        {
            nonResourceUrls: ["*"],
            verbs: ["*"],
        },
    ],
});
const argocdManagerClusterRoleBinding = new kubernetes.rbac.v1.ClusterRoleBinding("argocd_manager", {
    metadata: {
        name: "argocd-manager-role-binding",
    },
    roleRef: {
        apiGroup: "rbac.authorization.k8s.io",
        kind: "ClusterRole",
        name: argocdManagerClusterRole.metadata.apply(metadata => metadata.name),
    },
    subjects: [{
        kind: "ServiceAccount",
        name: argocdManager.metadata.apply(metadata => metadata.name),
        namespace: argocdManager.metadata.apply(metadata => metadata.namespace),
    }],
});
const argocdManagerSecret = new kubernetes.core.v1.Secret("argocd_manager", {metadata: {
    name: argocdManager.defaultSecretName,
    namespace: argocdManager.metadata.apply(metadata => metadata.namespace),
}});
const gke = new argocd.Cluster("gke", {
    server: cluster.then(cluster => std.join({
        separator: "",
        input: [
            "https://%s",
            cluster.endpoint,
        ],
    })).then(invoke => invoke.result),
    name: "gke",
    config: {
        bearerToken: argocdManagerKubernetesSecret.data.token,
        tlsClientConfig: {
            caData: cluster.then(cluster => std.base64decode({
                input: cluster.masterAuths?.[0]?.clusterCaCertificate,
            })).then(invoke => invoke.result),
        },
    },
});
//# AWS EKS cluster
const clusterGetCluster = aws.eks.getCluster({
    name: "cluster",
});
const eks = new argocd.Cluster("eks", {
    server: clusterGetCluster.then(clusterGetCluster => std.join({
        separator: "",
        input: [
            "https://%s",
            clusterGetCluster.endpoint,
        ],
    })).then(invoke => invoke.result),
    name: "eks",
    namespaces: [
        "default",
        "optional",
    ],
    config: {
        awsAuthConfigs: [{
            clusterName: "myekscluster",
            roleArn: "arn:aws:iam::<123456789012>:role/<role-name>",
        }],
        tlsClientConfig: {
            caData: clusterGetCluster.then(clusterGetCluster => std.base64decode({
                input: clusterGetCluster.certificateAuthorities?.[0]?.data,
            })).then(invoke => invoke.result),
        },
    },
});

import pulumi
import pulumi_argocd as argocd
import pulumi_aws as aws
import pulumi_gcp as gcp
import pulumi_kubernetes as kubernetes
import pulumi_std as std

## Bearer token Authentication
kubernetes = argocd.Cluster("kubernetes",
    server="https://1.2.3.4:12345",
    config={
        "bearer_token": "eyJhbGciOiJSUzI...",
        "tls_client_config": {
            "ca_data": std.file(input="path/to/ca.pem").result,
        },
    })
## GCP GKE cluster
cluster = gcp.container.get_cluster(name="cluster",
    location="europe-west1")
argocd_manager = kubernetes.core.v1.ServiceAccount("argocd_manager", metadata={
    "name": "argocd-manager",
    "namespace": "kube-system",
})
argocd_manager_cluster_role = kubernetes.rbac.v1.ClusterRole("argocd_manager",
    metadata={
        "name": "argocd-manager-role",
    },
    rules=[
        {
            "api_groups": ["*"],
            "resources": ["*"],
            "verbs": ["*"],
        },
        {
            "non_resource_urls": ["*"],
            "verbs": ["*"],
        },
    ])
argocd_manager_cluster_role_binding = kubernetes.rbac.v1.ClusterRoleBinding("argocd_manager",
    metadata={
        "name": "argocd-manager-role-binding",
    },
    role_ref={
        "api_group": "rbac.authorization.k8s.io",
        "kind": "ClusterRole",
        "name": argocd_manager_cluster_role.metadata.name,
    },
    subjects=[{
        "kind": "ServiceAccount",
        "name": argocd_manager.metadata.name,
        "namespace": argocd_manager.metadata.namespace,
    }])
argocd_manager_secret = kubernetes.core.v1.Secret("argocd_manager", metadata={
    "name": argocd_manager.default_secret_name,
    "namespace": argocd_manager.metadata.namespace,
})
gke = argocd.Cluster("gke",
    server=std.join(separator="",
        input=[
            "https://%s",
            cluster.endpoint,
        ]).result,
    name="gke",
    config={
        "bearer_token": argocd_manager_kubernetes_secret["data"]["token"],
        "tls_client_config": {
            "ca_data": std.base64decode(input=cluster.master_auths[0].cluster_ca_certificate).result,
        },
    })
## AWS EKS cluster
cluster_get_cluster = aws.eks.get_cluster(name="cluster")
eks = argocd.Cluster("eks",
    server=std.join(separator="",
        input=[
            "https://%s",
            cluster_get_cluster.endpoint,
        ]).result,
    name="eks",
    namespaces=[
        "default",
        "optional",
    ],
    config={
        "aws_auth_configs": [{
            "cluster_name": "myekscluster",
            "role_arn": "arn:aws:iam::<123456789012>:role/<role-name>",
        }],
        "tls_client_config": {
            "ca_data": std.base64decode(input=cluster_get_cluster.certificate_authorities[0].data).result,
        },
    })

package main

import (
	"github.com/Three141/pulumi-argocd/sdk/go/argocd"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/eks"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/container"
	corev1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/core/v1"
	metav1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
	rbacv1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/rbac/v1"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFile, err := std.File(ctx, &std.FileArgs{
			Input: "path/to/ca.pem",
		}, nil)
		if err != nil {
			return err
		}
		// # Bearer token Authentication
		_, err = argocd.NewCluster(ctx, "kubernetes", &argocd.ClusterArgs{
			Server: pulumi.String("https://1.2.3.4:12345"),
			Config: &argocd.ClusterConfigArgs{
				BearerToken: pulumi.String("eyJhbGciOiJSUzI..."),
				TlsClientConfig: &argocd.ClusterConfigTlsClientConfigArgs{
					CaData: pulumi.String(invokeFile.Result),
				},
			},
		})
		if err != nil {
			return err
		}
		// # GCP GKE cluster
		cluster, err := container.LookupCluster(ctx, &container.LookupClusterArgs{
			Name:     "cluster",
			Location: pulumi.StringRef("europe-west1"),
		}, nil)
		if err != nil {
			return err
		}
		argocdManager, err := corev1.NewServiceAccount(ctx, "argocd_manager", &corev1.ServiceAccountArgs{
			Metadata: &metav1.ObjectMetaArgs{
				Name:      pulumi.String("argocd-manager"),
				Namespace: pulumi.String("kube-system"),
			},
		})
		if err != nil {
			return err
		}
		argocdManagerClusterRole, err := rbacv1.NewClusterRole(ctx, "argocd_manager", &rbacv1.ClusterRoleArgs{
			Metadata: &metav1.ObjectMetaArgs{
				Name: pulumi.String("argocd-manager-role"),
			},
			Rules: rbacv1.PolicyRuleArray{
				&rbacv1.PolicyRuleArgs{
					ApiGroups: pulumi.StringArray{
						pulumi.String("*"),
					},
					Resources: pulumi.StringArray{
						pulumi.String("*"),
					},
					Verbs: pulumi.StringArray{
						pulumi.String("*"),
					},
				},
				&rbacv1.PolicyRuleArgs{
					NonResourceUrls: pulumi.StringArray{
						pulumi.String("*"),
					},
					Verbs: pulumi.StringArray{
						pulumi.String("*"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = rbacv1.NewClusterRoleBinding(ctx, "argocd_manager", &rbacv1.ClusterRoleBindingArgs{
			Metadata: &metav1.ObjectMetaArgs{
				Name: pulumi.String("argocd-manager-role-binding"),
			},
			RoleRef: &rbacv1.RoleRefArgs{
				ApiGroup: pulumi.String("rbac.authorization.k8s.io"),
				Kind:     pulumi.String("ClusterRole"),
				Name: argocdManagerClusterRole.Metadata.ApplyT(func(metadata metav1.ObjectMeta) (*string, error) {
					return &metadata.Name, nil
				}).(pulumi.StringPtrOutput),
			},
			Subjects: rbacv1.SubjectArray{
				&rbacv1.SubjectArgs{
					Kind: pulumi.String("ServiceAccount"),
					Name: argocdManager.Metadata.ApplyT(func(metadata metav1.ObjectMeta) (*string, error) {
						return &metadata.Name, nil
					}).(pulumi.StringPtrOutput),
					Namespace: argocdManager.Metadata.ApplyT(func(metadata metav1.ObjectMeta) (*string, error) {
						return &metadata.Namespace, nil
					}).(pulumi.StringPtrOutput),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = corev1.NewSecret(ctx, "argocd_manager", &corev1.SecretArgs{
			Metadata: &metav1.ObjectMetaArgs{
				Name: argocdManager.DefaultSecretName,
				Namespace: argocdManager.Metadata.ApplyT(func(metadata metav1.ObjectMeta) (*string, error) {
					return &metadata.Namespace, nil
				}).(pulumi.StringPtrOutput),
			},
		})
		if err != nil {
			return err
		}
		invokeJoin1, err := std.Join(ctx, &std.JoinArgs{
			Separator: "",
			Input: []interface{}{
				"https://%s",
				cluster.Endpoint,
			},
		}, nil)
		if err != nil {
			return err
		}
		invokeBase64decode2, err := std.Base64decode(ctx, &std.Base64decodeArgs{
			Input: cluster.MasterAuths[0].ClusterCaCertificate,
		}, nil)
		if err != nil {
			return err
		}
		_, err = argocd.NewCluster(ctx, "gke", &argocd.ClusterArgs{
			Server: pulumi.String(invokeJoin1.Result),
			Name:   pulumi.String("gke"),
			Config: &argocd.ClusterConfigArgs{
				BearerToken: pulumi.Any(argocdManagerKubernetesSecret.Data.Token),
				TlsClientConfig: &argocd.ClusterConfigTlsClientConfigArgs{
					CaData: pulumi.String(invokeBase64decode2.Result),
				},
			},
		})
		if err != nil {
			return err
		}
		// # AWS EKS cluster
		clusterGetCluster, err := eks.LookupCluster(ctx, &eks.LookupClusterArgs{
			Name: "cluster",
		}, nil)
		if err != nil {
			return err
		}
		invokeJoin3, err := std.Join(ctx, &std.JoinArgs{
			Separator: "",
			Input: []interface{}{
				"https://%s",
				clusterGetCluster.Endpoint,
			},
		}, nil)
		if err != nil {
			return err
		}
		invokeBase64decode4, err := std.Base64decode(ctx, &std.Base64decodeArgs{
			Input: clusterGetCluster.CertificateAuthorities[0].Data,
		}, nil)
		if err != nil {
			return err
		}
		_, err = argocd.NewCluster(ctx, "eks", &argocd.ClusterArgs{
			Server: pulumi.String(invokeJoin3.Result),
			Name:   pulumi.String("eks"),
			Namespaces: pulumi.StringArray{
				pulumi.String("default"),
				pulumi.String("optional"),
			},
			Config: &argocd.ClusterConfigArgs{
				AwsAuthConfigs: argocd.ClusterConfigAwsAuthConfigArray{
					&argocd.ClusterConfigAwsAuthConfigArgs{
						ClusterName: pulumi.String("myekscluster"),
						RoleArn:     pulumi.String("arn:aws:iam::<123456789012>:role/<role-name>"),
					},
				},
				TlsClientConfig: &argocd.ClusterConfigTlsClientConfigArgs{
					CaData: pulumi.String(invokeBase64decode4.Result),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Argocd = Three14.Argocd;
using Aws = Pulumi.Aws;
using Gcp = Pulumi.Gcp;
using Kubernetes = Pulumi.Kubernetes;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    //# Bearer token Authentication
    var kubernetes = new Argocd.Cluster("kubernetes", new()
    {
        Server = "https://1.2.3.4:12345",
        Config = new Argocd.Inputs.ClusterConfigArgs
        {
            BearerToken = "eyJhbGciOiJSUzI...",
            TlsClientConfig = new Argocd.Inputs.ClusterConfigTlsClientConfigArgs
            {
                CaData = Std.File.Invoke(new()
                {
                    Input = "path/to/ca.pem",
                }).Apply(invoke => invoke.Result),
            },
        },
    });

    //# GCP GKE cluster
    var cluster = Gcp.Container.GetCluster.Invoke(new()
    {
        Name = "cluster",
        Location = "europe-west1",
    });

    var argocdManager = new Kubernetes.Core.V1.ServiceAccount("argocd_manager", new()
    {
        Metadata = new Kubernetes.Types.Inputs.Meta.V1.ObjectMetaArgs
        {
            Name = "argocd-manager",
            Namespace = "kube-system",
        },
    });

    var argocdManagerClusterRole = new Kubernetes.Rbac.V1.ClusterRole("argocd_manager", new()
    {
        Metadata = new Kubernetes.Types.Inputs.Meta.V1.ObjectMetaArgs
        {
            Name = "argocd-manager-role",
        },
        Rules = new[]
        {
            new Kubernetes.Types.Inputs.Rbac.V1.PolicyRuleArgs
            {
                ApiGroups = new[]
                {
                    "*",
                },
                Resources = new[]
                {
                    "*",
                },
                Verbs = new[]
                {
                    "*",
                },
            },
            new Kubernetes.Types.Inputs.Rbac.V1.PolicyRuleArgs
            {
                NonResourceUrls = new[]
                {
                    "*",
                },
                Verbs = new[]
                {
                    "*",
                },
            },
        },
    });

    var argocdManagerClusterRoleBinding = new Kubernetes.Rbac.V1.ClusterRoleBinding("argocd_manager", new()
    {
        Metadata = new Kubernetes.Types.Inputs.Meta.V1.ObjectMetaArgs
        {
            Name = "argocd-manager-role-binding",
        },
        RoleRef = new Kubernetes.Types.Inputs.Rbac.V1.RoleRefArgs
        {
            ApiGroup = "rbac.authorization.k8s.io",
            Kind = "ClusterRole",
            Name = argocdManagerClusterRole.Metadata.Apply(metadata => metadata.Name),
        },
        Subjects = new[]
        {
            new Kubernetes.Types.Inputs.Rbac.V1.SubjectArgs
            {
                Kind = "ServiceAccount",
                Name = argocdManager.Metadata.Apply(metadata => metadata.Name),
                Namespace = argocdManager.Metadata.Apply(metadata => metadata.Namespace),
            },
        },
    });

    var argocdManagerSecret = new Kubernetes.Core.V1.Secret("argocd_manager", new()
    {
        Metadata = new Kubernetes.Types.Inputs.Meta.V1.ObjectMetaArgs
        {
            Name = argocdManager.DefaultSecretName,
            Namespace = argocdManager.Metadata.Apply(metadata => metadata.Namespace),
        },
    });

    var gke = new Argocd.Cluster("gke", new()
    {
        Server = Std.Join.Invoke(new()
        {
            Separator = "",
            Input = new[]
            {
                "https://%s",
                cluster.Apply(getClusterResult => getClusterResult.Endpoint),
            },
        }).Apply(invoke => invoke.Result),
        Name = "gke",
        Config = new Argocd.Inputs.ClusterConfigArgs
        {
            BearerToken = argocdManagerKubernetesSecret.Data.Token,
            TlsClientConfig = new Argocd.Inputs.ClusterConfigTlsClientConfigArgs
            {
                CaData = Std.Base64decode.Invoke(new()
                {
                    Input = cluster.Apply(getClusterResult => getClusterResult.MasterAuths[0]?.ClusterCaCertificate),
                }).Apply(invoke => invoke.Result),
            },
        },
    });

    //# AWS EKS cluster
    var clusterGetCluster = Aws.Eks.GetCluster.Invoke(new()
    {
        Name = "cluster",
    });

    var eks = new Argocd.Cluster("eks", new()
    {
        Server = Std.Join.Invoke(new()
        {
            Separator = "",
            Input = new[]
            {
                "https://%s",
                clusterGetCluster.Apply(getClusterResult => getClusterResult.Endpoint),
            },
        }).Apply(invoke => invoke.Result),
        Name = "eks",
        Namespaces = new[]
        {
            "default",
            "optional",
        },
        Config = new Argocd.Inputs.ClusterConfigArgs
        {
            AwsAuthConfigs = new[]
            {
                new Argocd.Inputs.ClusterConfigAwsAuthConfigArgs
                {
                    ClusterName = "myekscluster",
                    RoleArn = "arn:aws:iam::<123456789012>:role/<role-name>",
                },
            },
            TlsClientConfig = new Argocd.Inputs.ClusterConfigTlsClientConfigArgs
            {
                CaData = Std.Base64decode.Invoke(new()
                {
                    Input = clusterGetCluster.Apply(getClusterResult => getClusterResult.CertificateAuthorities[0]?.Data),
                }).Apply(invoke => invoke.Result),
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.argocd.Cluster;
import com.pulumi.argocd.ClusterArgs;
import com.pulumi.argocd.inputs.ClusterConfigArgs;
import com.pulumi.argocd.inputs.ClusterConfigTlsClientConfigArgs;
import com.pulumi.gcp.container.ContainerFunctions;
import com.pulumi.gcp.container.inputs.GetClusterArgs;
import com.pulumi.kubernetes.core_v1.ServiceAccount;
import com.pulumi.kubernetes.core_v1.ServiceAccountArgs;
import com.pulumi.kubernetes.meta_v1.inputs.ObjectMetaArgs;
import com.pulumi.kubernetes.rbac.authorization.k8s.io_v1.ClusterRole;
import com.pulumi.kubernetes.rbac.authorization.k8s.io_v1.ClusterRoleArgs;
import com.pulumi.kubernetes.rbac.authorization.k8s.io_v1.inputs.PolicyRuleArgs;
import com.pulumi.kubernetes.rbac.authorization.k8s.io_v1.ClusterRoleBinding;
import com.pulumi.kubernetes.rbac.authorization.k8s.io_v1.ClusterRoleBindingArgs;
import com.pulumi.kubernetes.rbac.authorization.k8s.io_v1.inputs.RoleRefArgs;
import com.pulumi.kubernetes.rbac.authorization.k8s.io_v1.inputs.SubjectArgs;
import com.pulumi.kubernetes.core_v1.Secret;
import com.pulumi.kubernetes.core_v1.SecretArgs;
import com.pulumi.aws.eks.EksFunctions;
import com.pulumi.aws.eks.inputs.GetClusterArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        //# Bearer token Authentication
        var kubernetes = new Cluster("kubernetes", ClusterArgs.builder()
            .server("https://1.2.3.4:12345")
            .config(ClusterConfigArgs.builder()
                .bearerToken("eyJhbGciOiJSUzI...")
                .tlsClientConfig(ClusterConfigTlsClientConfigArgs.builder()
                    .caData(StdFunctions.file(FileArgs.builder()
                        .input("path/to/ca.pem")
                        .build()).result())
                    .build())
                .build())
            .build());

        //# GCP GKE cluster
        final var cluster = ContainerFunctions.getCluster(GetClusterArgs.builder()
            .name("cluster")
            .location("europe-west1")
            .build());

        var argocdManager = new ServiceAccount("argocdManager", ServiceAccountArgs.builder()
            .metadata(ObjectMetaArgs.builder()
                .name("argocd-manager")
                .namespace("kube-system")
                .build())
            .build());

        var argocdManagerClusterRole = new ClusterRole("argocdManagerClusterRole", ClusterRoleArgs.builder()
            .metadata(ObjectMetaArgs.builder()
                .name("argocd-manager-role")
                .build())
            .rules(            
                PolicyRuleArgs.builder()
                    .apiGroups("*")
                    .resources("*")
                    .verbs("*")
                    .build(),
                PolicyRuleArgs.builder()
                    .nonResourceUrls("*")
                    .verbs("*")
                    .build())
            .build());

        var argocdManagerClusterRoleBinding = new ClusterRoleBinding("argocdManagerClusterRoleBinding", ClusterRoleBindingArgs.builder()
            .metadata(ObjectMetaArgs.builder()
                .name("argocd-manager-role-binding")
                .build())
            .roleRef(RoleRefArgs.builder()
                .apiGroup("rbac.authorization.k8s.io")
                .kind("ClusterRole")
                .name(argocdManagerClusterRole.metadata().applyValue(metadata -> metadata.name()))
                .build())
            .subjects(SubjectArgs.builder()
                .kind("ServiceAccount")
                .name(argocdManager.metadata().applyValue(metadata -> metadata.name()))
                .namespace(argocdManager.metadata().applyValue(metadata -> metadata.namespace()))
                .build())
            .build());

        var argocdManagerSecret = new Secret("argocdManagerSecret", SecretArgs.builder()
            .metadata(ObjectMetaArgs.builder()
                .name(argocdManager.defaultSecretName())
                .namespace(argocdManager.metadata().applyValue(metadata -> metadata.namespace()))
                .build())
            .build());

        var gke = new Cluster("gke", ClusterArgs.builder()
            .server(StdFunctions.join(JoinArgs.builder()
                .separator("")
                .input(                
                    "https://%s",
                    cluster.applyValue(getClusterResult -> getClusterResult.endpoint()))
                .build()).result())
            .name("gke")
            .config(ClusterConfigArgs.builder()
                .bearerToken(argocdManagerKubernetesSecret.data().token())
                .tlsClientConfig(ClusterConfigTlsClientConfigArgs.builder()
                    .caData(StdFunctions.base64decode(Base64decodeArgs.builder()
                        .input(cluster.applyValue(getClusterResult -> getClusterResult.masterAuths()[0].clusterCaCertificate()))
                        .build()).result())
                    .build())
                .build())
            .build());

        //# AWS EKS cluster
        final var clusterGetCluster = EksFunctions.getCluster(GetClusterArgs.builder()
            .name("cluster")
            .build());

        var eks = new Cluster("eks", ClusterArgs.builder()
            .server(StdFunctions.join(JoinArgs.builder()
                .separator("")
                .input(                
                    "https://%s",
                    clusterGetCluster.applyValue(getClusterResult -> getClusterResult.endpoint()))
                .build()).result())
            .name("eks")
            .namespaces(            
                "default",
                "optional")
            .config(ClusterConfigArgs.builder()
                .awsAuthConfigs(ClusterConfigAwsAuthConfigArgs.builder()
                    .clusterName("myekscluster")
                    .roleArn("arn:aws:iam::<123456789012>:role/<role-name>")
                    .build())
                .tlsClientConfig(ClusterConfigTlsClientConfigArgs.builder()
                    .caData(StdFunctions.base64decode(Base64decodeArgs.builder()
                        .input(clusterGetCluster.applyValue(getClusterResult -> getClusterResult.certificateAuthorities()[0].data()))
                        .build()).result())
                    .build())
                .build())
            .build());

    }
}

resources:
  ## Bearer token Authentication
  kubernetes:
    type: argocd:Cluster
    properties:
      server: https://1.2.3.4:12345
      config:
        bearerToken: eyJhbGciOiJSUzI...
        tlsClientConfig:
          caData:
            fn::invoke:
              function: std:file
              arguments:
                input: path/to/ca.pem
              return: result
  argocdManager:
    type: kubernetes:core/v1:ServiceAccount
    name: argocd_manager
    properties:
      metadata:
        name: argocd-manager
        namespace: kube-system
  argocdManagerClusterRole:
    type: kubernetes:rbac.authorization.k8s.io/v1:ClusterRole
    name: argocd_manager
    properties:
      metadata:
        name: argocd-manager-role
      rules:
        - apiGroups:
            - '*'
          resources:
            - '*'
          verbs:
            - '*'
        - nonResourceUrls:
            - '*'
          verbs:
            - '*'
  argocdManagerClusterRoleBinding:
    type: kubernetes:rbac.authorization.k8s.io/v1:ClusterRoleBinding
    name: argocd_manager
    properties:
      metadata:
        name: argocd-manager-role-binding
      roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: ClusterRole
        name: ${argocdManagerClusterRole.metadata.name}
      subjects:
        - kind: ServiceAccount
          name: ${argocdManager.metadata.name}
          namespace: ${argocdManager.metadata.namespace}
  argocdManagerSecret:
    type: kubernetes:core/v1:Secret
    name: argocd_manager
    properties:
      metadata:
        name: ${argocdManager.defaultSecretName}
        namespace: ${argocdManager.metadata.namespace}
  gke:
    type: argocd:Cluster
    properties:
      server:
        fn::invoke:
          function: std:join
          arguments:
            separator: ""
            input:
              - https://%s
              - ${cluster.endpoint}
          return: result
      name: gke
      config:
        bearerToken: ${argocdManagerKubernetesSecret.data.token}
        tlsClientConfig:
          caData:
            fn::invoke:
              function: std:base64decode
              arguments:
                input: ${cluster.masterAuths[0].clusterCaCertificate}
              return: result
  eks:
    type: argocd:Cluster
    properties:
      server:
        fn::invoke:
          function: std:join
          arguments:
            separator: ""
            input:
              - https://%s
              - ${clusterGetCluster.endpoint}
          return: result
      name: eks
      namespaces:
        - default
        - optional
      config:
        awsAuthConfigs:
          - clusterName: myekscluster
            roleArn: arn:aws:iam::<123456789012>:role/<role-name>
        tlsClientConfig:
          caData:
            fn::invoke:
              function: std:base64decode
              arguments:
                input: ${clusterGetCluster.certificateAuthorities[0].data}
              return: result
variables:
  ## GCP GKE cluster
  cluster:
    fn::invoke:
      function: gcp:container:getCluster
      arguments:
        name: cluster
        location: europe-west1
  ## AWS EKS cluster
  clusterGetCluster:
    fn::invoke:
      function: aws:eks:getCluster
      arguments:
        name: cluster

var clusterResource = new Argocd.Cluster("clusterResource", new()
{
    Config = new Argocd.Inputs.ClusterConfigArgs
    {
        AwsAuthConfigs = new[]
        {
            new Argocd.Inputs.ClusterConfigAwsAuthConfigArgs
            {
                ClusterName = "string",
                RoleArn = "string",
            },
        },
        BearerToken = "string",
        ExecProviderConfig = new Argocd.Inputs.ClusterConfigExecProviderConfigArgs
        {
            ApiVersion = "string",
            Args = new[]
            {
                "string",
            },
            Command = "string",
            Env = 
            {
                { "string", "string" },
            },
            InstallHint = "string",
        },
        Password = "string",
        TlsClientConfig = new Argocd.Inputs.ClusterConfigTlsClientConfigArgs
        {
            CaData = "string",
            CertData = "string",
            Insecure = false,
            KeyData = "string",
            ServerName = "string",
        },
        Username = "string",
    },
    Metadatas = new[]
    {
        new Argocd.Inputs.ClusterMetadataArgs
        {
            Annotations = 
            {
                { "string", "string" },
            },
            Labels = 
            {
                { "string", "string" },
            },
        },
    },
    Name = "string",
    Namespaces = new[]
    {
        "string",
    },
    Project = "string",
    Server = "string",
    Shard = "string",
});

example, err := argocd.NewCluster(ctx, "clusterResource", &argocd.ClusterArgs{
	Config: &argocd.ClusterConfigArgs{
		AwsAuthConfigs: argocd.ClusterConfigAwsAuthConfigArray{
			&argocd.ClusterConfigAwsAuthConfigArgs{
				ClusterName: pulumi.String("string"),
				RoleArn:     pulumi.String("string"),
			},
		},
		BearerToken: pulumi.String("string"),
		ExecProviderConfig: &argocd.ClusterConfigExecProviderConfigArgs{
			ApiVersion: pulumi.String("string"),
			Args: pulumi.StringArray{
				pulumi.String("string"),
			},
			Command: pulumi.String("string"),
			Env: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
			InstallHint: pulumi.String("string"),
		},
		Password: pulumi.String("string"),
		TlsClientConfig: &argocd.ClusterConfigTlsClientConfigArgs{
			CaData:     pulumi.String("string"),
			CertData:   pulumi.String("string"),
			Insecure:   pulumi.Bool(false),
			KeyData:    pulumi.String("string"),
			ServerName: pulumi.String("string"),
		},
		Username: pulumi.String("string"),
	},
	Metadatas: argocd.ClusterMetadataArray{
		&argocd.ClusterMetadataArgs{
			Annotations: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
			Labels: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
		},
	},
	Name: pulumi.String("string"),
	Namespaces: pulumi.StringArray{
		pulumi.String("string"),
	},
	Project: pulumi.String("string"),
	Server:  pulumi.String("string"),
	Shard:   pulumi.String("string"),
})

var clusterResource = new Cluster("clusterResource", ClusterArgs.builder()
    .config(ClusterConfigArgs.builder()
        .awsAuthConfigs(ClusterConfigAwsAuthConfigArgs.builder()
            .clusterName("string")
            .roleArn("string")
            .build())
        .bearerToken("string")
        .execProviderConfig(ClusterConfigExecProviderConfigArgs.builder()
            .apiVersion("string")
            .args("string")
            .command("string")
            .env(Map.of("string", "string"))
            .installHint("string")
            .build())
        .password("string")
        .tlsClientConfig(ClusterConfigTlsClientConfigArgs.builder()
            .caData("string")
            .certData("string")
            .insecure(false)
            .keyData("string")
            .serverName("string")
            .build())
        .username("string")
        .build())
    .metadatas(ClusterMetadataArgs.builder()
        .annotations(Map.of("string", "string"))
        .labels(Map.of("string", "string"))
        .build())
    .name("string")
    .namespaces("string")
    .project("string")
    .server("string")
    .shard("string")
    .build());

cluster_resource = argocd.Cluster("clusterResource",
    config={
        "aws_auth_configs": [{
            "cluster_name": "string",
            "role_arn": "string",
        }],
        "bearer_token": "string",
        "exec_provider_config": {
            "api_version": "string",
            "args": ["string"],
            "command": "string",
            "env": {
                "string": "string",
            },
            "install_hint": "string",
        },
        "password": "string",
        "tls_client_config": {
            "ca_data": "string",
            "cert_data": "string",
            "insecure": False,
            "key_data": "string",
            "server_name": "string",
        },
        "username": "string",
    },
    metadatas=[{
        "annotations": {
            "string": "string",
        },
        "labels": {
            "string": "string",
        },
    }],
    name="string",
    namespaces=["string"],
    project="string",
    server="string",
    shard="string")

const clusterResource = new argocd.Cluster("clusterResource", {
    config: {
        awsAuthConfigs: [{
            clusterName: "string",
            roleArn: "string",
        }],
        bearerToken: "string",
        execProviderConfig: {
            apiVersion: "string",
            args: ["string"],
            command: "string",
            env: {
                string: "string",
            },
            installHint: "string",
        },
        password: "string",
        tlsClientConfig: {
            caData: "string",
            certData: "string",
            insecure: false,
            keyData: "string",
            serverName: "string",
        },
        username: "string",
    },
    metadatas: [{
        annotations: {
            string: "string",
        },
        labels: {
            string: "string",
        },
    }],
    name: "string",
    namespaces: ["string"],
    project: "string",
    server: "string",
    shard: "string",
});