Deploy the glowroot helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the Glowroot helm chart on an Azure Managed OpenShift Service, we will approach the task in two high-level steps:

1. **Provision an Azure Red Hat OpenShift Cluster**: We'll use the `azure-native.redhatopenshift.OpenShiftCluster` resource for this. This resource allows us to create and manage an instance of Azure Red Hat OpenShift, which is a fully managed OpenShift service partnered by Microsoft and Red Hat. 
   
2. **Deploy the Glowroot Helm Chart**: After the OpenShift cluster is ready, we will use the `kubernetes.helm.sh/v3.Chart` resource to deploy the Glowroot helm chart onto our OpenShift cluster. The Helm Chart resource from the Kubernetes provider in Pulumi lets us deploy applications packaged as Helm charts.

Here is the step-by-step TypeScript code that achieves the above:

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

// Define the configuration for your Azure Environment
const location = "East US"; // Choose an Azure location for the cluster
const resourceGroupName = "myResourceGroup"; // Replace with your desired Resource Group name

// Create an Azure Resource Group if not exist
const rg = new azureNative.resources.ResourceGroup("myResourceGroup", {
    location: location,
    resourceName: resourceGroupName,
});

// Deploy Azure Red Hat OpenShift Cluster
const openshiftCluster = new azureNative.redhatopenshift.OpenShiftCluster("myOpenShiftCluster", {
    resourceGroupName: rg.name,
    location,
    clusterProfile: {
        pullSecret: "", // provide the pull secret for accessing Red Hat container registry
    },
    masterProfile: {
        vmSize: "Standard_D8s_v3",
    },
    workerProfiles: [
        {
            name: "worker",
            vmSize: "Standard_D8s_v3",
            count: 3,
        },
    ],
    // Additional properties can be configured as per need
});

// Set up a Kubernetes Provider pointing to the OpenShift cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
  kubeconfig: openshiftCluster.kubeconfig, // This will get the kubeconfig from the new OpenShift cluster
});

// Deploy Glowroot Helm Chart into the Azure OpenShift Cluster
const glowrootChart = new k8s.helm.v3.Chart("glowroot", {
    chart: "glowroot",
    // If the chart is in a specific repository, you need to specify the repo and version here
    fetchOpts: {
        repo: "https://glowroot.github.io/glowroot/", // Replace with the actual Helm chart repository URL if different
    },
    values: {
        // Provide any specific configuration values for the Glowroot chart here
        // For example:
        // service: {
        //   type: "LoadBalancer"
        // }
    },
}, { provider: k8sProvider });

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

This program creates a resource group and then sets up an Azure Red Hat OpenShift cluster within that resource group. Once the cluster is provisioned, the program sets up a Pulumi Kubernetes provider to interact with the OpenShift cluster; this is done by using the `kubeconfig` emitted from the OpenShift cluster resource. Finally, it deploys the Glowroot helm chart into the cluster using the Pulumi Kubernetes `Chart` resource with the previously set up Kubernetes provider.

Please note that you need to replace placeholders like `<YOUR_PULL_SECRET>` with appropriate values. For the Glowroot helm chart, adjust the `chart`, `repo`, and `values` to match the specific Helm chart you're deploying.

You will need Pulumi CLI installed and configured with your Azure account. When you are ready, you can run `pulumi up` to create the resources on Azure. After deployment, the kubeconfig to access your OpenShift cluster will be exported as a stack output, which you can use with `kubectl` or other Kubernetes tooling to interact with your OpenShift cluster.