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

Question

Pulumi · Accepted Answer

To deploy the `argocd-version-exporter` Helm chart on Azure Kubernetes Service (AKS) using Pulumi, you'll need to follow these steps:

1. **Set Up an AKS Cluster**: Before you can deploy a Helm chart, you need an AKS cluster where the application will be hosted. The `azure-native.hybridcontainerservice.ProvisionedCluster` resource will be used to provision an AKS cluster in Azure.

2. **Install Argo CD**: While not explicitly handled by Pulumi, you would typically have Argo CD installed on your Kubernetes cluster as a prerequisite for deploying the `argocd-version-exporter` chart, since it's an Argo CD component.

3. **Deploy the Helm Chart**: To deploy the Helm chart, Pulumi provides the `kubernetes.helm.v3.Chart` resource which will be instructed to install the `argocd-version-exporter` Helm chart to your AKS cluster.

Below is a Pulumi program in TypeScript that performs these steps:

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

// Step 1: Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("myResourceGroup", {
    location: "West US", // You can choose a different region
});

// Step 2: Create the AKS cluster
const aksCluster = new azure_native.containerservice.ManagedCluster("myAksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    kubernetesVersion: "1.18.14", // Pick a supported Kubernetes version
    dnsPrefix: "my-aks-cluster", // Replace with a DNS prefix of your choice
    agentPoolProfiles: [{
        count: 1, // Number of nodes in the node pool
        maxPods: 110, // Maximum number of pods per node
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2", // Choose a different VM size if needed
    }],
});

// Retrieve the KubeConfig from AKS
const creds = pulumi.all([resourceGroup.name, aksCluster.name]).apply(([rgName, clusterName]) =>
    azure_native.containerservice.listManagedClusterUserCredentials({
        resourceGroupName: rgName,
        resourceName: clusterName,
    }),
);

// Step 3: Use the KubeConfig to connect to the AKS cluster
const aksKubeConfig = creds.kubeconfigs[0].value.apply(kubeconfig =>
    Buffer.from(kubeconfig, 'base64').toString(),
);

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksKubeConfig,
});

// Step 4: Deploy the argocd-version-exporter Helm chart
const chart = new k8s.helm.v3.Chart("argocd-version-exporter", {
    chart: "argocd-version-exporter",
    version: "1.0.0", // Use the version number of the Helm chart you're deploying
    namespace: "default",
    // You can specify additional values here that you'd want to override.
}, { provider: k8sProvider });

// Export the AKS cluster's kubeconfig.
export const kubeConfig = aksKubeConfig;
```

In this program:
- We start by creating an Azure resource group that will contain the AKS cluster.
- We then create an AKS cluster within the resource group. You'll need to specify the `kubernetesVersion`, `dnsPrefix`, and `agentPoolProfiles` as appropriate for your environment.
- We retrieve the kubeconfig for our AKS cluster which will be used to interact with the cluster.
- With the Kubernetes provider configured with the kubeconfig from the AKS cluster, we proceed to deploy the `argocd-version-exporter` Helm chart. We specify the chart name and version, adjust these values accordingly if you're using a different chart or chart version.
- Finally, we export the kubeconfig to enable interaction with the AKS cluster using `kubectl` or other Kubernetes tooling outside of Pulumi.

To run this Pulumi program, make sure you have Pulumi installed and configured for use with Azure. Then, install the necessary NPM packages (`@pulumi/pulumi`, `@pulumi/azure-native`, `@pulumi/kubernetes`) in your project and run `pulumi up`. This will provision the resources as described in the script. Remember to ensure you have permission to create resources in your Azure subscription and the Pulumi CLI is logged in.