Deploy the redis-setup helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `redis-setup` Helm chart on Azure Kubernetes Service (AKS), you first need to create an AKS cluster and then use the `Chart` resource from the Pulumi Kubernetes provider to deploy the Helm chart onto that cluster. Below is a step-by-step guide along with the corresponding Pulumi TypeScript program that demonstrates this process.

### Prerequisites
Before running the Pulumi program, make sure the following prerequisites are met:
1. You have installed the Pulumi CLI and configured it for use with your Azure account.
2. You have installed Node.js and npm, which are required to write and run the Pulumi program using TypeScript.
3. The `@pulumi/azure-native` and `@pulumi/kubernetes` NPM packages are installed in your project.

### Step 1: Setting up AKS Cluster
We will start by creating an AKS cluster using the `azure-native` provider. The provider offers the `ManagedCluster` resource which represents an AKS cluster in Azure.

### Step 2: Deploying a Helm Chart
Once the AKS cluster is up and running, we will configure the Pulumi Kubernetes provider to use the kubeconfig from the created AKS cluster. This allows us to deploy Kubernetes resources to that cluster.

The `Chart` resource from the `@pulumi/kubernetes` package will be used to deploy the `redis-setup` Helm chart. This resource is a high-level component that encapsulates deploying Helm charts into Kubernetes clusters in a declarative way.

Here is the program that accomplishes 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 AKS cluster (Azure Kubernetes Service)
const resourceGroupName = new azure_native.resources.ResourceGroup("myResourceGroup");

const aksCluster = new azure_native.containerservice.ManagedCluster("myAksCluster", {
    resourceGroupName: resourceGroupName.name,
    agentPoolProfiles: [{
        count: 1,
        vmSize: "Standard_DS2_v2",
        mode: "System",
    }],
    dnsPrefix: "myakscluster",
    identity: {
        type: "SystemAssigned",
    },
    resourceGroupName: resourceGroupName.name,
});

// Export the kubeconfig for the cluster
export const kubeconfig = pulumi.
    all([aksCluster.name, resourceGroupName.name]).
    apply(([clusterName, rgName]) => {
        return azure_native.containerservice.listManagedClusterUserCredentials({
            resourceGroupName: rgName,
            resourceName: clusterName,
        });
    }).
    apply(creds => {
        const encoded = creds.kubeconfigs[0].value;
        return Buffer.from(encoded, 'base64').toString();
    });

// Step 2: Deploy the `redis-setup` Helm chart on the AKS cluster
const redisChart = new k8s.helm.v3.Chart("redis-setup", {
    repo: "bitnami", // Assuming that the `redis-setup` chart is from the Bitnami repository
    chart: "redis",
    version: "14.8.8", // Specify the version of the Helm chart you want to deploy
    // Values to pass to the Helm chart, can be customized depending on needs
    values: {
        usePassword: false
    },
}, {
    provider: new k8s.Provider("k8sProvider", {
        kubeconfig: kubeconfig,
    }),
});

// Optional: Exports to obtain URLs or other data from the deployed resources
// For example, to export the Redis master service endpoint:
export const redisMasterEndpoint = redisChart.getResourceProperty("v1/Service", "redis-setup-redis-master", "status").apply(status => status.loadBalancer?.ingress[0].ip);
```

### Explanation
- We start by creating a new resource group which will contain our AKS cluster.
- Next, we define our AKS cluster with a single node pool and system-assigned managed identity. We also export the kubeconfig which will be used to communicate with our Kubernetes cluster.
- In the second step, we deploy the `redis-setup` Helm chart. We specify the Bitnami Helm repository (