Deploy the redis-cache helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the Redis cache Helm chart on an Azure Managed OpenShift Service, you will need to take the following steps:

1. Create an Azure OpenShift Managed Cluster via the `azure-native.containerservice.OpenShiftManagedCluster` resource.
2. Deploy the Redis Helm chart onto the cluster using the `kubernetes.helm.sh/v3.Chart` resource.

This program assumes that you've already set up Pulumi and have authenticated with both Azure and your Kubernetes cluster.

First, we'll define our OpenShift Managed Cluster within Azure. This cluster will provide the Kubernetes environment where our Redis instance will run.

Then, we'll use the `Chart` resource to deploy Redis using a pre-existing Helm chart. The Helm chart is a pre-packaged set of resource definitions that are deployed on the cluster to run Redis.

Here is the complete program to create an Azure Managed OpenShift cluster and deploy the Redis cache using a Helm chart:

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

// Before using this code, ensure you have the correct configuration in your Pulumi.yaml file.

// Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("resourceGroup");

// Create an Azure OpenShift Managed Cluster
const managedCluster = new azure.containerservice.OpenShiftManagedCluster("openshiftCluster", {
  resourceName: "openshiftCluster",
  resourceGroupName: resourceGroup.name,
  location: resourceGroup.location,
  openShiftVersion: "v4.3", // Specify your desired OpenShift version
  networkProfile: {
    vnetId: "/subscriptions/yourSubscriptionId/resourceGroups/yourResourceGroup/providers/Microsoft.Network/virtualNetworks/yourVnetName",
    // Replace with your VNet ID
    peerVnetId: "/subscriptions/yourSubscriptionId/resourceGroups/yourResourceGroup/providers/Microsoft.Network/virtualNetworks/yourPeerVnetName",
    // Optional: If you have a peer VNet
  },
  // Define other necessary cluster parameters here
});

// Deploy the Redis cache using Helm chart on the Kubernetes cluster
const redis = new k8s.helm.v3.Chart("redis-cache", {
  chart: "redis",
  version: "10.5.7", // Use the version of chart you need
  fetchOpts: {
    repo: "https://charts.bitnami.com/bitnami",
  },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: managedCluster.kubeconfig }) });

// Export the cluster's kubeconfig
export const kubeconfig = managedCluster.kubeconfig;
```

This TypeScript program should be included into a Pulumi project. Below are the steps to follow:

1. **Setting Up the Pulumi Project:** Create a new Pulumi project or use an existing one and define the necessary configuration values such as the Azure subscription ID and resource group.
2. **Defining Resources:**
    - **Resource Group**: We create a new resource group within Azure to maintain all related resources for our deployment.
    - **OpenShift Managed Cluster**: Here we define the actual OpenShift cluster providing the location from the resource group, the desired OpenShift version, and VNet settings to define the networking for the cluster.
    - **Redis Helm Chart**: We reference the Redis Helm chart from the Bitnami repository and specify the version we'd like to deploy. A `k8s.Provider` resource is created using the `kubeconfig` from the newly created OpenShift cluster to interact with it.
3. **Running the Program**: With the Pulumi CLI, running `pulumi up` will execute the program, provisioning the resources accordingly.
4. **Accessing the Cluster**: After the deployment finishes successfully, the `kubeconfig` will be exported. This allows you to interact with the OpenShift cluster using `kubectl` or other Kubernetes tools.

Remember to replace placeholders such as subscription IDs, resource groups, and VNet names with actual values from your Azure environment. It is also important to ensure that you have the required permissions in your Azure account to create such resources.