Deploy the dapr-dashboard helm chart on Azure Managed Openshift Service

Question

Pulumi · Accepted Answer

To deploy the dapr-dashboard Helm chart on an Azure Managed OpenShift Service, you'll first need to ensure the OpenShift Managed Cluster is in place. The `azure-native.containerservice.OpenShiftManagedCluster` resource is used to create and manage an OpenShift cluster in Azure. Once the cluster is set up, you can use the `kubernetes.helm.sh/v3.Chart` resource to deploy Helm charts like dapr-dashboard to the cluster.

Below is a Pulumi program written in TypeScript that outlines the steps needed. The program will:

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

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

// Create an Azure resource group
const resourceGroup = new azure_native.resources.ResourceGroup("myResourceGroup");

// Create an Azure Managed OpenShift cluster.
const openshiftCluster = new azure_native.containerservice.OpenShiftManagedCluster("myOpenShiftCluster", {
    location: resourceGroup.location,
    resourceName: "myOpenShiftCluster",
    resourceGroupName: resourceGroup.name,
    openShiftVersion: "4.3", // specify your desired OpenShift version
    // Define the network profile for your cluster with the requisite values like vnetCidr...
    networkProfile: { 
        vnetCidr: "10.0.0.0/8"
    },
    masterPoolProfile: {
        count: 3, // number of master nodes
        vmSize: "Standard_D4s_v3" // Size of the master VM
    },
    agentPoolProfiles: [{
        name: "agentpool", // The name of the agent pool
        count: 3, // number of worker nodes
        vmSize: "Standard_D4s_v3", // Size of the worker VMs
        role: "compute" // The role of the nodes as compute
    }],
});

// Set up the Kubernetes provider to deploy Helm charts using the OpenShift cluster credentials.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: openshiftCluster.config.kubeconfig,
});

// Deploy the dapr-dashboard Helm chart.
const daprDashboardChart = new k8s.helm.v3.Chart("dapr-dashboard", {
    chart: "dapr-dashboard",
    version: "0.6.0", // specify your desired Helm chart version
    fetchOpts: {
        repo: "https://dapr.github.io/helm-charts/" // the Helm chart repository
    },
}, { provider: k8sProvider });

// Export the Kubernetes ingress endpoint to access the dapr-dashboard.
export const kubeIngressEndpoint = daprDashboardChart.getResourceProperty("v1/Service", "dapr-dashboard-dapr-dashboard", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

This program performs the following:

- An **Azure resource group** is created as a logical container for the OpenShift cluster resources.
- The **OpenShiftManagedCluster** is provisioned with a designated version, a network profile, master, and agent pool profiles to define the size and count of the master and worker nodes.
- We instantiate the **Kubernetes provider** using the kubeconfig from the newly created OpenShift cluster, which allows Pulumi to perform actions on this K8s cluster.
- Using the **Helm Chart** resource, we deploy the dapr-dashboard to the OpenShift cluster, specifying the chart's name, version, and repository.
- Finally, we **export the ingress endpoint** which can be used to access the dapr-dashboard once deployed.

After running this program with `pulumi up`, you should have a fully operational Azure Managed OpenShift cluster with the dapr-dashboard Helm chart deployed. You can visit the exported Kubernetes ingress endpoint from your browser to access the dapr-dashboard.