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

Question

Pulumi · Accepted Answer

To deploy the Redis helm chart on an Azure Kubernetes Service (AKS) cluster, we will go through the following steps:

Set up an AKS cluster: We need a Kubernetes cluster where the Redis helm chart will be deployed. We will use the AKS service, which allows you to create, configure and manage a Kubernetes cluster hosted on Azure.
Install the Helm chart for Redis: With the cluster up and running, we will then proceed to use Helm, which is a package manager for Kubernetes, simplifying the deployment and management of applications on the Kubernetes cluster. The Redis chart is a pre-configured set of resources optimized for deploying Redis on Kubernetes.
Use Pulumi to script the setup: Pulumi allows you to define infrastructure as code using familiar programming languages. Here, we will use TypeScript.

Below is a TypeScript program which you can run using Pulumi that outlines the steps to create an AKS cluster and deploy the Redis helm chart on it. Please make sure you have the Pulumi CLI installed and configured for use with your Azure account.

Here's the Pulumi program in TypeScript:

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
import * as k8s from "@pulumi/kubernetes";
import * as azuread from "@pulumi/azuread";
import * as random from "@pulumi/random";

// Create a resource group
const resourceGroup = new azure.core.ResourceGroup("aksResourceGroup", {
    location: azure.Locations.WestUS2, // Replace with the desired Azure region
});

// Create an AD service principal for the AKS cluster
const adApp = new azuread.Application("aks");
const adSp = new azuread.ServicePrincipal("aksSp", {applicationId: adApp.applicationId});
const password = new random.RandomPassword("password", {
    length: 20,
    special: true,
});

const adSpPassword = new azuread.ServicePrincipalPassword("aksSpPassword", {
    servicePrincipalId: adSp.id,
    value: password.result,
    endDate: "2099-01-01T00:00:00Z", // An arbitrary far future value
});

// Create the AKS cluster
const k8sCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    agentPoolProfiles: [{
        name: "aksagentpool",
        count: 1, // Number of desired nodes in the node pool
        vmSize: "Standard_B2s", // VM size for each node in the node pool
    }],
    dnsPrefix: pulumi.interpolate`${resourceGroup.name}-kube`,
    linuxProfile: {
        adminUsername: "aksadmin",
        sshKey: {
            keyData: "<YOUR_SSH_PUBLIC_KEY>", // Replace with your own SSH public key
        },
    },
    servicePrincipal: {
        clientId: adApp.applicationId,
        clientSecret: adSpPassword.value,
    },
});

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

// Deploy the Redis helm chart using the Kubernetes provider
const redisChart = new k8s.helm.v3.Chart("redis-helm-chart", {
    chart: "redis", // Name of the Helm chart
    version: "10.5.7", // Specify the version of the chart
    namespace: "default", // Kubernetes namespace to deploy the chart
    // You can specify additional configurations here, based on your needs
}, { provider: k8sProvider });

// Export the cluster's kubeconfig and Redis endpoint
export const kubeConfig = k8sCluster.kubeConfigRaw;
export const redisMasterEndpoint = redisChart.getResourceProperty("v1/Service", "redis-master", "status").apply(status => status.loadBalancer.ingress[0].ip);

Remember to replace <YOUR_SSH_PUBLIC_KEY> with the actual SSH public key that you want to use to create the AKS cluster.

Explanation

The program starts by importing the required Pulumi packages to interact with Azure and Kubernetes.

We define a resource group in Azure to organize the resources.
We create an Azure Active Directory application and a service principal, which is used by AKS to interact with Azure APIs.
The random.RandomPassword generates a strong random password for the service principal authentication.
We define an AKS cluster with a single-node pool. You may adjust the size, count, and type of nodes based on your specific needs.
An instance of a Kubernetes provider is created, which uses the cluster's kubeconfig. This kubeconfig is automatically generated by Pulumi once the AKS cluster is created.
Finally, we define a Redis helm chart resource. The chart is installed in the "default" namespace of our Kubernetes cluster. You may specify different Helm chart values as required.

After running this program with Pulumi, it will output the kubeconfig needed to interact with the AKS cluster and the Redis Master Service endpoint if you decide to make the Redis service externally accessible (you may need to tweak the service type and expose it properly).

To run this code, you'll need to have Pulumi installed, be authenticated with Azure, and then execute pulumi up. Pulumi will show you a preview of the resources that will be created and ask for confirmation before proceeding. Make sure you review that the resources being created match your expectations and budget. After confirmation, Pulumi will provision the resources in Azure and deploy the Redis helm chart to the AKS cluster.