Deploy the stream helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the stream helm chart on Azure Kubernetes Service (AKS) using Pulumi, we need to follow a series of steps. First, we'll create an AKS cluster where our application will be hosted. Then, we'll deploy the Helm chart to this AKS cluster. Helm charts are packages of pre-configured Kubernetes resources that can be deployed as units. The stream helm chart you're referring to will contain all the Kubernetes resource definitions required to run the stream application.

In this guide, I'm going to provide you with a Pulumi program written in TypeScript that creates an AKS cluster and deploys a Helm chart named "stream" to that cluster. For the Helm chart deployment, we'll be using the `kubernetes.helm.v3.Chart` resource, which is the Pulumi resource to deploy Helm charts in Kubernetes clusters.

Here's a step-by-step guide explaining the Pulumi resources we'll use:

1. **Azure Kubernetes Service (AKS) Cluster**: We'll create an AKS cluster using the `azure-native.containerservice.ManagedCluster` resource from the `azure-native` provider. We choose `azure-native` because it is the most recent representation of Azure resources in Pulumi and is developed in partnership with Microsoft.

2. **Kubernetes Helm Chart**: After creating the AKS cluster, we'll use the `kubernetes.helm.v3.Chart` resource from the `kubernetes` provider to deploy the stream Helm chart on AKS. This is a standard way of deploying packages in Kubernetes.

3. **Pulumi stack exports**: Finally, we'll export any necessary outputs, such as the AKS cluster name and the Kubernetes configuration to connect to and manage the cluster.

Now let's write the Pulumi TypeScript program to achieve your goal.

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

// Define configuration variables for the AKS cluster
const config = new pulumi.Config();
const location = config.require("location");
const resourceGroupName = config.require("resourceGroupName");
const clusterName = config.require("clusterName");

// Create a new resource group
const resourceGroup = new azure_native.resources.ResourceGroup("aksResourceGroup", {
    location: location,
    resourceGroupName: resourceGroupName,
});

// Create an AKS cluster
const managedCluster = new azure_native.containerservice.ManagedCluster("aksCluster", {
    // Ensure you use the supported versions in your region
    kubernetesVersion: "1.20.5",
    location: location,
    resourceGroupName: resourceGroup.name,
    resourceName: clusterName,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: pulumi.interpolate`${clusterName}-kube`,
});

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

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

// Create a provider for the above AKS cluster
const k8sProvider = new k8s.Provider("k8sprovider", {
    kubeconfig: kubeconfig,
});

// Deploy the stream helm chart
const streamChart = new k8s.helm.v3.Chart("stream", {
    chart: "stream",
    version: "1.0.0", // Replace with the correct chart version
    fetchOpts:{
        repo: "http://charts.mycompany.com/", // Replace with the actual Helm chart repository
    },
}, { provider: k8sProvider });

// Export the chart name
export const streamChartName = streamChart.getName();

```
Explanation:

- We begin by importing the necessary Pulumi libraries.
- We specify configuration variables such as the location, resource group name, and cluster name. These could be set using the Pulumi config command or could be included in a `Pulumi.<stack>.yaml` file – for example, `Pulumi.dev.yaml`.
- We create a new Azure resource group to isolate our AKS resources.
- We create an AKS cluster `ManagedCluster` with a single node pool and specify the necessary properties such as Kubernetes version and VM size.
- We export the AKS cluster's kubeconfig, which is needed to communicate with the Kubernetes cluster after it's created.
- We create a Kubernetes provider using the exported kubeconfig. This allows Pulumi to deploy resources to our AKS cluster.
- We deploy the stream Helm chart using the `Chart` resource. You must replace the chart `version` and `repo` fields with the actual values that correspond to your Helm chart.

Please ensure you replace the placeholder values I've used with actual values relevant to your scenario. To run this Pulumi program, you will need to have Pulumi installed and configured on your system, as well as the necessary credentials to create resources in Azure.

To execute the program, navigate to the directory containing this code and run `pulumi up`. This will start the deployment process, which you can monitor through the console output.