Deploy the vmme helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Azure Managed OpenShift Service using Pulumi, you will need to follow these high-level steps:

Set up an Azure Managed OpenShift Cluster: This involves creating a resource group and the OpenShift cluster itself.
Install a Helm Chart: After setting up your cluster, you will use the Pulumi Kubernetes provider to deploy your Helm chart to it.

Below, I will walk you through a Pulumi program written in TypeScript that carries out these steps to deploy the "vmme" Helm chart to an Azure Managed OpenShift Service.

Prerequisites

Make sure you have the following prerequisites installed and set up:

Pulumi CLI
Azure CLI
Proper Azure credentials configured locally, which Pulumi will use to interact with Azure
kubectl: To interact with the Kubernetes cluster
Node.js and npm or yarn: To execute the Pulumi TypeScript program

Pulumi Program

The following is a Pulumi program that accomplishes the deployment:

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

// Step 1: Create an Azure Managed OpenShift Cluster
const resourceGroup = new azureNative.resources.ResourceGroup("myResourceGroup");

const openshiftCluster = new azureNative.redhatopenshift.OpenShiftCluster("myOpenShiftCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    openShiftVersion: "4.3",  // specify the desired OpenShift version
    clusterProfile: {
        pullSecret: "<pullSecret>",  // provide your OpenShift pull secret
        domain: "example-openshift",
        resourceGroupId: resourceGroup.id,
    },
    masterProfile: {
        vmSize: "Standard_D8s_v3",
        subnetId: pulumi.interpolate`${resourceGroup.id}/subnets/mastersubnet`,
    },
    workerProfiles: [{
        name: "worker",
        vmSize: "Standard_D4s_v3",
        subnetId: pulumi.interpolate`${resourceGroup.id}/subnets/workersubnet`,
        count: 3,  // specify the desired number of workers
    }],
    servicePrincipalProfile: {
        clientId: "<clientId>",  // Azure service principal clientId
        clientSecret: "<clientSecret>",  // Azure service principal clientSecret
    },
    networkProfile: {
        podCidr: "10.128.0.0/14",
        serviceCidr: "172.30.0.0/16",
    },
});

// Step 2: Install a Helm Chart on the cluster
// Configure the Kubernetes provider to connect to the created OpenShift cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: openshiftCluster.kubeconfig,
});

// Deploy the vmme Helm chart using the Kubernetes provider
const vmmeChart = new k8s.helm.v3.Chart("vmme", {
    chart: "vmme",
    version: "1.0.0",  // specify the chart version if needed
    // Add any required values here
    values: {},
}, { provider: k8sProvider });

// Export the kubeconfig and the public URL to access your application
export const kubeConfig = openshiftCluster.kubeconfig;
export const publicUrl = vmmeChart.getResourceProperty("v1/Service", "vmme", "status").apply(status => status.loadBalancer.ingress[0].ip);

Explanation

We start by importing the Pulumi SDK, Azure Native Pulumi provider, and Kubernetes Pulumi provider.
In the first step, azureNative.resources.ResourceGroup, we create a new Azure resource group which will contain all resources.
Using azureNative.redhatopenshift.OpenShiftCluster, we define an Azure Red Hat OpenShift cluster, specifying details about the cluster we want to create, including location, OpenShift version, profile details for the master, workers, and networking, along with credential information for the Azure service principal.
- Replace the values <pullSecret>, <clientId>, and <clientSecret> with your specific configurations.
In the second step, we configure the Kubernetes provider with the kubeconfig from the newly created OpenShift cluster.
The Helm chart "vmme" is then deployed to the cluster using k8s.helm.v3.Chart. This example assumes that "vmme" Helm chart is available in your configured Helm repository. Replace 1.0.0 with the actual version of your Helm chart and provide any necessary values using the values object.
Finally, we export the kubeconfig and the public URL of the service for the deployed application. With the kubeconfig, you can manage your cluster using kubectl. The public URL can be used to access your "vmme" application running on Azure OpenShift once it's deployed.

Make sure to replace placeholders with actual values as needed before running the program. When you're ready, navigate to the directory containing your Pulumi program and run:

pulumi up

This command will start the deployment process with Pulumi managing the creation and configuration of all the Azure and Kubernetes resources automatically. After the deployment is complete, you will get outputs for the kubeconfig and the public URL for your application that you can use to interact with it.