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

Question

Pulumi · Accepted Answer

To deploy the `redis-cart` Helm chart on Azure Kubernetes Service (AKS), we need to perform several steps:

1. **Create an AKS Cluster**: Before deploying any service, we need to have a Kubernetes cluster running. Azure Kubernetes Service (AKS) provides a managed Kubernetes cluster that can be used to deploy and manage your containerized applications easily.

2. **Install and Configure Helm**: Helm is a package manager for Kubernetes that allows you to define, install, and upgrade complex Kubernetes applications. We will use Helm to deploy the `redis-cart` chart.

3. **Deploy Redis-Chart Helm Chart**: Using Pulumi's `Chart` resource from the Kubernetes provider, we can deploy the `redis-cart` Helm chart to our AKS cluster.

Below is a Pulumi TypeScript program that creates an AKS cluster and deploys the `redis-cart` Helm chart. For simplicity, we're assuming all Azure and Pulumi configurations are already set up, such as credentials and the desired region to deploy to.

Before running this program, make sure you have the `@pulumi/azure-native` and `@pulumi/kubernetes` NPM packages installed in your project.

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

// Create an 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: 3, // Number of nodes in the node pool
        maxPods: 110, // The maximum number of pods that can run on a node.
        mode: "System", // System nodes are managed by AKS and user workloads should not be placed on them.
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "aksk8s", // Ensure a unique DNS prefix where the cluster's API server will be accessible.
    enableRBAC: true,
    kubernetesVersion: "1.18.14", // Ensure you're using a version that supports required features.
    location: resourceGroup.location,
    nodeResourceGroup: `NodeResourceGroup`,
});

// Export the kubeconfig for the cluster, used to connect to the cluster with kubectl
export const kubeconfig = pulumi
    .all([cluster.name, resourceGroup.name])
    .apply(([clusterName, rgName]) => {
        return azure_native.containerservice.listManagedClusterUserCredentials({
            resourceGroupName: rgName,
            resourceName: clusterName,
        });
    })
    .apply(creds => {
        const encoded = creds.kubeconfigs[0].value;
        if (!encoded) throw new Error("Kubeconfig was not found!");
        return Buffer.from(encoded, "base64").toString();
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploy the redis-cart helm chart using the kubernetes provider
const redisCartChart = new k8s.helm.v3.Chart("redis-cart", {
    chart: "redis",
    version: "10.5.7",
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    // You can specify additional chart values here if necessary
    values: {
        usePassword: false,
        cluster: {
            enabled: true,
            slaveCount: 2,
        },
    },
}, { provider: k8sProvider }); // Make sure to associate the helm chart with the AKS provider

// Export the Redis host
export const redisHost = redisCartChart.getResourceProperty("v1/Service", "redis-cart-redis-master", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);

```

This program performs the following actions:

1. **Resource Group Creation**: A new Azure resource group is created to contain all our resources.

2. **AKS Cluster Creation**: It instantiates a new AKS managed cluster with a specified node pool configuration.

3. **Kubeconfig Retrieval**: It exports the kubeconfig needed to communicate with the Kubernetes cluster via kubectl or other Kubernetes tooling.

4. **Kubernetes Provider Setup**: This code sets up the Kubernetes provider with the kubeconfig from the cluster we created.

5. **Redis-Cart Helm Chart Deployment**: It declares a `redis-cart` Helm chart from the Bitnami repository to be installed with certain values such as disabling passwords and enabling a Redis cluster. This chart is applied to our AKS cluster through the Kubernetes provider we configured.

Please replace `"redis-cart"` with the actual name of the chart if different and ensure that the Helm chart and its version are correct. The values specified in the `values` object configure the Redis deployment, which you might need to adjust according to your specific needs.

6. **Exported Outputs**: The program exports the Redis host which can be used to connect to the Redis instance once it’s up and running.

This is a complete program that you should be able to run with `pulumi up`, assuming your Pulumi and Azure configurations are set up correctly. It will provision an AKS cluster in Azure and deploy the Helm chart for Redis as specified.