Deploy the argocd-operator helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the argocd-operator Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, you'll follow a few main steps:

1. Provision an AKS cluster.
2. Install the `argocd-operator` Helm chart on the cluster.

Below, there is a complete TypeScript program for Pulumi that demonstrates how to do this. The program uses the `@pulumi/azure-native` package to create the AKS cluster and the `@pulumi/kubernetes` package to deploy the Helm chart.

First, you'll need to install the necessary dependencies:

```bash
$ npm install @pulumi/pulumi @pulumi/azure-native @pulumi/kubernetes
```

Now, for the Pulumi program:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure-native";
import * as k8s from "@pulumi/kubernetes";

// Step 1: Provision an AKS cluster
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

const managedCluster = new azure.containerservice.ManagedCluster("myAksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        nodeLabels: {},
        osDiskSizeGB: 30,
        osType: "Linux",
        type: "VirtualMachineScaleSets",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "myakscluster",
    enableRBAC: true,
    kubernetesVersion: "1.20.9", 
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa AAAAB3Nza...",
            }],
        },
    },
    nodeResourceGroup: `MC_azure-native_go_${pulumi.getStack()}`,
    resourceGroupName: resourceGroup.name,
});

// Export the cluster's kubeconfig
const creds = pulumi.all([managedCluster.name, resourceGroup.name]).apply(([clusterName, rgName]) => 
    azure.containerservice.listManagedClusterUserCredentials({
        resourceGroupName: rgName,
        resourceName: clusterName,
    }));

const encoded = creds.kubeconfigs[0].value;
export const kubeconfig = encoded.apply(enc => Buffer.from(enc, "base64").toString());

// Step 2: Deploy the argocd-operator Helm chart using the Kubernetes provider
const argocdNamespace = new k8s.core.v1.Namespace("argocd", {}, { provider: k8sProvider });
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

const argocdChart = new k8s.helm.v3.Chart("argocd-operator", {
    chart: "argocd-operator",
    version: "0.0.15", // specify the exact chart version to be deployed
    namespace: argocdNamespace.metadata.name,
    fetchOpts: {
        repo: "https://redhat-cop.github.io/helm-charts", // Helm repo URL where the chart is located
    },
}, { provider: k8sProvider });

// Export the public IP to access ArgoCD
export const argocdServerIp = argocdChart.getResourceProperty("v1/Service", "argocd-operator-argocd-server", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

Here's what the code does, step by step:

- The first part of the program defines a resource group and a managed AKS cluster using the `azure-native` package. This is where you define the specifications for your Kubernetes cluster, like the version, size, and count of VMs.
  
- The second step exports the `kubeconfig` which is used to interact with your AKS cluster through kubectl or other Kubernetes tools.
  
- The third section creates an instance of the Kubernetes provider configured with the `kubeconfig` from the AKS cluster. This allows Pulumi to interact with the AKS cluster.

- The fourth part deploys the `argocd-operator` Helm chart into the AKS cluster in its own namespace. The `fetchOpts` parameter specifies the repository where the chart can be found. You can specify the chart version you wish to deploy, to ensure consistent deployments.

- Finally, we export the public IP address of the ArgoCD server, which can be accessed from the internet to use ArgoCD once it's deployed.

Note: Ensure that you replace the placeholder inside `ssh.publicKeys.keyData` with your actual SSH public key, and adjust the other properties like `kubernetesVersion` and `chart.version` as necessary.

Once the code is ready, deploy it with Pulumi by running `pulumi up`. After the deployment succeeds, Pulumi will output the kubeconfig and ArgoCD IP that you can use to access the cluster and the ArgoCD UI respectively.