Deploy the bff-vrecli-service helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Azure Managed OpenShift Service using Pulumi, you’ll need to:

1. Create an Azure Managed OpenShift cluster.
2. Deploy the Helm chart to the created cluster.

In the following guide and TypeScript program, I will go over creating an OpenShift Managed Cluster and then using the Kubernetes `helm.v3.Chart` resource to deploy the specified Helm chart.

### Prerequisites:

Before you run the provided Pulumi code, make sure that:

- You have installed the Pulumi CLI.
- You have installed Node.js and the TypeScript compiler.
- You have an active Azure subscription and the Azure CLI.
- You're logged in to Azure using the Azure CLI (`az login`).

### Step 1: Define the Azure Managed OpenShift cluster

First, we need to set up an Azure Managed OpenShift cluster using the `azure-native.containerservice.OpenShiftManagedCluster` resource. You'll need to specify various details about your cluster, such as location, agent pool profiles, and network profiles. Ensure that the provided parameters match the specific requirements you have for your environment, like the geolocation or size of your worker nodes.

### Step 2: Deploy the Helm Chart

After the cluster is provisioned, we can deploy the Helm chart to it. For that, we'll use the `helm.v3.Chart` class from the Pulumi Kubernetes package. It allows you to provide the chart name, version, and any additional configurations necessary for your Helm deployment.

### Step 3: Execute the Program

You will compile the TypeScript code into JavaScript, and then use the Pulumi CLI to create and deploy resources specified by the program. Remember that you would need `kubectl` configured with credentials to the OpenShift cluster to be able to deploy the Helm chart to the cluster.

Below is the complete TypeScript program for creating the OpenShift Managed Cluster and deploying the Helm chart:

```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("resourceGroup", {
    location: "eastus", // You can change the location as needed
});

// Create an Azure Managed OpenShift cluster
const openshiftManagedCluster = new azure_native.containerservice.OpenShiftManagedCluster("openshiftManagedCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    openShiftVersion: "4.6", // Specify which OpenShift version to use
    // Define the network profile, master and worker profiles, etc.
    networkProfile: {
        vnetCidr: "10.0.0.0/8"
    },
    masterPoolProfile: {
        count: 3, // Number of master nodes
        vmSize: "Standard_D4s_v3", // Master node virtual machine size
    },
    agentPoolProfiles: [{
        name: "agentpool",
        count: 3, // Number of worker nodes
        vmSize: "Standard_D4s_v3", // Worker node virtual machine size
    }],
    // Other necessary configurations go here
}, { dependsOn: resourceGroup });

// Pulumi stack export to obtain the kubeconfig of the created OpenShift cluster
export const kubeconfig = openshiftManagedCluster.config;

// Deployment of the Helm chart to the OpenShift Managed Cluster
const helmChart = new k8s.helm.v3.Chart("bff-vrecli-service-chart", {
    chart: "bff-vrecli-service",
    version: "1.0.0", // Specify the version of the Helm chart
    fetchOpts: {
        repo: "http://example.com/charts", // Specify the Helm chart repository URL
    },
    // Values to override the default chart values if necessary
    values: {
        key: "value",
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig }) });

// Use `pulumi up` to deploy when the program is ready
```

Replace the placeholders with the actual values for your use case. The `repo` URL should be the location of your Helm repository, and the `chart` and `version` should correspond to your `bff-vrecli-service` chart. Additionally, if your Helm chart requires it, you can set `values` to override its default configurations.

To run this program:

1. Save the code into a file named `index.ts`.
2. Run `npm init` and follow the prompts to create a `package.json` for your project.
3. Install required dependencies by running:
   ```shell
   npm install @pulumi/pulumi @pulumi/azure-native @pulumi/kubernetes
   ```
4. Compile the TypeScript program by running `tsc`.
5. Execute the deployment with the Pulumi CLI:
   ```shell
   pulumi up
   ```

Upon successful execution, the resources defined by the program will be created in your Azure account, and your Helm chart will be deployed to the Azure Managed OpenShift cluster.

Finally, you can access the output of the `kubeconfig` stack export which will contain the Kubernetes configuration file for accessing your OpenShift cluster. Store this securely, as it contains sensitive information that provides administrative access to your cluster.

That's it! You have now deployed the `bff-vrecli-service` Helm chart on the managed OpenShift cluster in Azure using Pulumi.