Deploy the turbonomic-importer helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Azure Kubernetes Service (AKS) using Pulumi, you first need an AKS cluster where the Helm chart will be deployed. Then you can use Pulumi's Helm support to deploy your chart to the cluster.

In the following program written in TypeScript, we'll go through the process. We'll begin by creating the necessary resources for an AKS cluster. Once the AKS cluster is ready, we'll proceed with deploying the `turbonomic-importer` Helm chart onto it.

The resources we'll be using are as follows:

- `ProvisionedCluster`: This is an AKS cluster resource from the `azure-native` provider.
- `Chart`: This is a Pulumi resource that represents a Helm chart from the `kubernetes` provider, and it allows you to deploy Helm charts to a Kubernetes cluster.

Here is the TypeScript program that accomplishes your goal:

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

// Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("resourceGroup");

// Create an Azure AD service principal for the AKS cluster
const adApp = new azure.ad.Application("adApp");
const adSp = new azure.ad.ServicePrincipal("adSp", {
    applicationId: adApp.applicationId,
});

const adSpPassword = new azure.ad.ServicePrincipalPassword("adSpPassword", {
    servicePrincipalId: adSp.id,
    value: "YOUR_PASSWORD", // replace this with a suitable password
    endDate: "2099-01-01T00:00:00Z",
});

// Create the AKS cluster using the ProvisionedCluster resource
const aksCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 2,
        vmSize: "Standard_DS2_v2",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
    }],
    dnsPrefix: pulumi.interpolate`${pulumi.getStack()}-k8s`,
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{ keyData: "YOUR_SSH_PUBLIC_KEY" }], // replace with your SSH public key
        },
    },
    servicePrincipal: {
        clientId: adApp.applicationId,
        secret: adSpPassword.value,
    },
    kubernetesVersion: "1.18.14",
}, { dependsOn: [adApp, adSp, adSpPassword] });

// Create a Kubernetes provider instance using the kubeconfig obtained from the AKS cluster
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Deploy the turbonomic-importer Helm chart to the AKS cluster
const turbonomicImporter = new kubernetes.helm.v3.Chart("turbonomic-importer", {
    chart: "turbonomic-importer",
    version: "1.0.0", // replace with the actual chart version you want to deploy
    fetchOpts: {
        repo: "http://your-helm-chart-repository.com/", // replace with the actual Helm chart repository
    },
}, { provider: k8sProvider });

// Export the AKS cluster's kubeconfig
export const kubeconfig = aksCluster.kubeConfigRaw;
```

Remember to replace `"YOUR_PASSWORD"`, `"YOUR_SSH_PUBLIC_KEY"`, and the details of the `turbonomic-importer` Helm chart (such as version and the chart repository URL) with your actual values.

In this program:

- We set up a new Azure resource group.
- We create an Azure AD application and a service principal, which AKS uses to interact with other Azure resources securely.
- We deploy the AKS cluster with two nodes using the specified configuration.
- We create a Kubernetes provider to manage resources in the AKS cluster.
- We deploy the `turbonomic-importer` Helm chart using Pulumi's Helm support.

After the deployment, the AKS cluster's kubeconfig is exported. This allows you to interact with your AKS cluster using `kubectl` or any other Kubernetes tooling.

To run this Pulumi program:
- Ensure you have Pulumi CLI installed and the Azure CLI configured with the respective credentials.
- Save the above TypeScript code to a file (e.g., `index.ts`).
- Install the necessary Pulumi packages by running `npm install @pulumi/azure-native @pulumi/kubernetes @pulumi/pulumi`.
- Compile the TypeScript code by running `tsc`.
- Run `pulumi up` to create the resources and deploy the Helm chart.