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

Question

Pulumi · Accepted Answer

To deploy the Redis Cache Helm chart on Azure Kubernetes Service (AKS), you will need to perform the following steps:

Create an AKS Cluster: You need an AKS cluster where the Redis helm chart will be deployed.
Install and Configure Helm: Helm is a package manager for Kubernetes which allows you to easily install and manage Kubernetes applications. Helm must be installed and configured to interact with your Kubernetes cluster.
Deploy Redis using Helm: After configuring Helm, you can use it to deploy the Redis chart to your AKS cluster.

Below is a complete Pulumi program in TypeScript that does this. The program uses the Pulumi Azure Native provider to create an AKS cluster and the Pulumi Kubernetes provider to deploy a Redis cache using Helm.

Before you proceed, ensure you have the following prerequisites:

Pulumi Account: Ensure you have an account set up with Pulumi and have installed the Pulumi CLI.
Azure Account: You should have an Azure account with permissions to create AKS clusters.
Configured Azure CLI: The Azure CLI must be installed and configured on your system to authenticate with Azure. Pulumi will use this configuration.
Helm: Ensure Helm is installed locally and is configured (if performing Helm operations outside Pulumi).

Here's the detailed Pulumi program to achieve the goal:

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
export async function createAksCluster(): Promise<azure_native.containerservice.ManagedCluster> {
    // Create an instance of the Azure resource group
    const resourceGroup = new azure_native.resources.ResourceGroup('myResourceGroup');

    // Create an AKS cluster
    const cluster = new azure_native.containerservice.ManagedCluster('myAksCluster', {
        resourceGroupName: resourceGroup.name,
        agentPoolProfiles: [{
            count: 1,
            vmSize: 'Standard_DS2_v2',
            name: 'agentpool',
            mode: 'System',
        }],
        dnsPrefix: 'myakscluster',
        enableRBAC: true,
    });

    return cluster;
}

// Get the credentials for the AKS cluster to use with the K8s provider
function getK8sCredentials(clusterName: string, resourceGroupName: pulumi.Input<string>): pulumi.Output<azure_native.containerservice.ListManagedClusterUserCredentialsResult> {
    return pulumi.all([resourceGroupName, clusterName])
        .apply(([resourceGroupName, clusterName]) =>
            azure_native.containerservice.listManagedClusterUserCredentials({
                resourceGroupName: resourceGroupName,
                resourceName: clusterName,
            }),
        );
}

// Step 2: Deploy Redis using Helm
export async function deployRedisHelmChart(kubeconfig: pulumi.Output<any>) {
    // Configure the Kubernetes provider using the AKS cluster credentials
    const k8sProvider = new k8s.Provider('k8sProvider', {
        kubeconfig: kubeconfig,
    });

    // Deploy the Redis helm chart
    const redisChart = new k8s.helm.v3.Chart('redis-cache', {
        chart: 'redis',
        version: '15.0.3', // Use a specific version to ensure compatibility
        fetchOpts: {
            repo: 'https://charts.bitnami.com/bitnami', // The Bitnami Helm repository
        },
    }, { provider: k8sProvider });

    return redisChart;
}

// Example to call the async functions for the creation of AKS and deployment of Redis
async function main() {
    const cluster = await createAksCluster();
    const creds = getK8sCredentials(cluster.name, cluster.id.apply(id => id.split('/')[4]));
    const kubeconfig = creds.apply(creds => Buffer.from(creds.kubeconfigs[0].value, 'base64').toString());
    await deployRedisHelmChart(kubeconfig);
}

main();

Explanation:

The createAksCluster function is responsible for creating an AKS cluster inside a new resource group. We specify the VM size and the number of nodes for the agent pool of the cluster.
The getK8sCredentials function then retrieves the credentials for the created AKS cluster using the Azure API. This function decodes the kubeconfig needed for the Kubernetes provider.
We then pass the kubeconfig to the Pulumi Kubernetes provider which configures it to work with the newly created AKS cluster.
The deployRedisHelmChart function uses the Kubernetes provider and the Helm package redis from the Bitnami repository to deploy Redis to the cluster.

Running this program with Pulumi will provision the necessary Azure resources and deploy Redis to the AKS cluster. Please ensure you have the necessary permissions and configurations in place for Azure and Pulumi before running this program.