Deploy the helm-amq-streams helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `helm-amq-streams` Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, you'll first need to set up an AKS cluster. Then, you can use Pulumi's Helm support to deploy charts directly to that cluster.

Below is a Pulumi TypeScript program that demonstrates how to create an AKS cluster and deploy that Helm chart onto it.

Firstly, we'll create the AKS cluster using the `azure-native.containerservice.KubernetesCluster` resource from the `azure-native` provider. We'll then configure the Kubernetes provider to use the AKS cluster's credentials to apply the Helm chart.

Here's what each part of the program does:

1. **Import Necessary Libraries**: To interact with Azure and Kubernetes, we import the necessary Pulumi libraries.
2. **Create an AKS Cluster**: Use the `KubernetesCluster` resource to create an AKS cluster.
3. **Export Kubeconfig**: Once the AKS is provisioned, we'll export the kubeconfig which is required to interact with the Kubernetes cluster.
4. **Helm Chart Deployment**: Using the kubeconfig, we deploy the `helm-amq-streams` Helm chart to the AKS cluster by utilizing the `Chart` class from the `@pulumi/kubernetes/helm` module.

Let's look at the Pulumi program code:

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

// Create an AKS cluster.
const cluster = new azure_native.containerservice.KubernetesCluster("aksCluster", {
    // Define your resource settings here, like location, resource group name, etc.
    // This example considers that the required resource group is already created.
    resourceGroupName: "myResourceGroup",
    location: "westus",
    agentPoolProfiles: [{
        count: 2,
        // Select the VM size as per your requirements.
        vmSize: "Standard_DS2_v2",
        mode: "System",
        name: "agentpool",
        osType: "Linux",
    }],
    dnsPrefix: "myakscluster",
    // Choose the appropriate Kubernetes version.
    kubernetesVersion: "1.20.7",
    linuxProfile: {
        // Replace with a secure username.
        adminUsername: "aksuser",
        ssh: {
            publicKeys: [{
                // Replace with your SSH public key string.
                keyData: "ssh-rsa AAAAB3Nza...",
            }],
        },
    },
    servicePrincipalProfile: {
        // Replace with your Azure AD Application details.
        clientId: "my-app-client-id",
        secret: "my-app-client-secret",
    },
});

// Once the cluster is created, we can obtain the kubeconfig file that will be used by the
// k8s package to deploy the Helm chart in the cluster.
const creds = pulumi.all([cluster.name, cluster.resourceGroupName]).apply(([clusterName, rgName]) => {
    return azure_native.containerservice.listManagedClusterUserCredentials({
        resourceGroupName: rgName,
        resourceName: clusterName,
    });
});
const kubeconfig = creds.apply(cred => Buffer.from(cred.kubeconfigs[0].value, 'base64').toString());

// Define the settings of the Helm chart.
const helmChart = new k8s.helm.v3.Chart("helm-amq-streams", {
    chart: "amq-streams",
    version: "1.7.0",
    fetchOpts: {
        // Add the repository where the helm-amq-streams chart is located
        repo: "https://charts.bitnami.com/bitnami",
    },
    // Specify the values file or config for the AMQ Streams Helm chart.
    values: {
        // You can define the chart's values here or point to a values file.
        // For instance, `replicaCount: 1`.
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });

// Export the kubeconfig of the cluster and the status of the Helm deployment.
export const kubeconfigFile = kubeconfig;
export const helmChartStatus = helmChart.status;
```

Please make sure to replace placeholders like `myResourceGroup`, `ssh-rsa AAAAB3Nza...`, `my-app-client-id`, and `my-app-client-secret` with actual values relevant to your Azure environment.

This Pulumi program should be placed in a file named `index.ts`. Make sure you have your Pulumi environment set up with Azure credentials before running the program. Once set up, you can deploy the infrastructure with the following Pulumi CLI commands:

```bash
pulumi up        # Preview and deploy changes
pulumi stack     # Show all stack outputs (including the kubeconfigFile)
```

After the deployment is complete, you will see the outputs in your terminal including the kubeconfig file data. You can use the `pulumi stack output kubeconfigFile` command to retrieve the kubeconfig and interact with your AKS cluster using `kubectl`.