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

Question

Pulumi · Accepted Answer

To deploy a Redis instance with persistence enabled on Azure Kubernetes Service (AKS), we'll use Pulumi to:

1. Create an AKS cluster using the `azure-native` provider.
2. Deploy a Redis Helm chart onto the AKS cluster.

The `azure-native` provider is a Pulumi provider for interfacing with Azure resources using the native Azure Resource Manager (ARM) APIs. We use resources from this provider to define an AKS cluster. Then we use the `kubernetes` provider to deploy the Redis Helm chart to the created AKS cluster.

Here are the high-level steps implemented in the following Pulumi program:

- Define a resource group to organize Azure resources.
- Create an AKS cluster within the resource group.
- Configure the Kubernetes provider to use the credentials from the AKS cluster.
- Deploy the `redis-persistent` Helm chart to the AKS cluster.

Now, let's look at the Pulumi TypeScript program to perform these actions:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure-native"; // Native Azure provider
import * as k8s from "@pulumi/kubernetes"; // Kubernetes provider

// Step 1: Create an Azure Resource Group to contain the AKS cluster
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

// Step 2: Create an AKS cluster in the resource group
const aksCluster = new azure.containerservice.ManagedCluster("myAKSCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 2, // Define the number of nodes in the node pool
        vmSize: "Standard_D2_v2", // Define the virtual machine size to use for each node
        mode: "System", // Define the mode for the node pool. System nodes are used for running critical system pods and services.
        name: "agentpool" // Name of the agent pool
    }],
    dnsPrefix: "myakscluster", // Define a DNS prefix which is used to access the cluster
    kubernetesVersion: "1.18.14", // Specify the version of Kubernetes to use for the AKS cluster
    resourceGroupName: resourceGroup.name,
});

// Step 3: Define a provider to deploy resources to the AKS cluster using the cluster credentials
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw, // Get the kubeconfig from AKS cluster
});

// Define the namespace where the Redis Helm chart will be installed
const redisNamespace = new k8s.core.v1.Namespace("redis-namespace", {
    metadata: { name: "redis" },
}, { provider: k8sProvider });

// Step 4: Deploy the redis-persistent Helm chart using the Kubernetes provider
const redisChart = new k8s.helm.v3.Chart("redis-persistent", {
    chart: "redis",
    version: "10.5.7", // Use a specific chart version, ensure this is compatible with your Kubernetes version
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami", // Specify the repository to fetch the chart from
    },
    values: { // Set values for the Helm chart, turning on persistence
        global: {
            storageClass: "default", // Using the default storage class. Make sure this is configured in your AKS cluster
        },
        master: {
            persistence: {
                enabled: true, // Enable persistence using PersistentVolumes
                size: "5Gi" // Size of the persistent volume
            }
        }
    },
    namespace: redisNamespace.metadata.name, // Install the chart in the 'redis' namespace
}, { provider: k8sProvider, dependsOn: [aksCluster] });

// Export the Kubernetes config and Redis service endpoint
export const kubeConfig = aksCluster.kubeConfigRaw;
export const redisEndpoint = pulumi.interpolate`${redisChart.getResourceProperty("v1/Service", "redis-redis-master", "status").apply(status => status.loadBalancer.ingress[0].ip)}`;
```

This Pulumi program can be run after setting up the Pulumi CLI and being logged into the Azure CLI with the appropriate permissions. It will provision the required Azure resources and deploy the Redis instance on AKS.

To understand each part of the program:

- We use `azure-native.resources.ResourceGroup` to create a new Azure resource group to hold our AKS cluster.
- `azure-native.containerservice.ManagedCluster` is used to define an AKS cluster, where `agentPoolProfiles` specifies the size and number of VM nodes, and `kubernetesVersion` sets the version of Kubernetes to run.
- A `k8s.Provider` instance is created with the AKS cluster's kubeconfig to allow Pulumi to interact with the Kubernetes cluster.
- We deploy Redis using the `k8s.helm.v3.Chart` class from the Pulumi Kubernetes provider, referencing a Redis Helm chart from the Bitnami chart repository. The `values` field is used to configure the chart settings, such as enabling persistence.
- We export the AKS cluster's kubeconfig for use with `kubectl` and the LoadBalancer IP address for the Redis service to allow access to the Redis instance from outside the cluster.

After running this Pulumi program, you'll have a Redis instance running with persistent storage on AKS. To manage the lifecycle of your deployed Redis instance and AKS cluster, you can use Pulumi's up, preview, refresh, destroy, and other CLI commands.