Deploy the dapr-dashboard helm chart on Opensshift

Question

Pulumi · Accepted Answer

Deploying a Helm chart on an OpenShift cluster using Pulumi is a process that involves several key steps. To accomplish this, you will use Pulumi's Kubernetes provider to interact with your OpenShift cluster. To deploy the `dapr-dashboard` Helm chart, you'll specifically use the `Chart` resource from Pulumi's Kubernetes Helm package.

The following detailed guide will walk you through the necessary components of the Pulumi program written in TypeScript to deploy the `dapr-dashboard` Helm chart on OpenShift.

### Prerequisites

Before you begin with the Pulumi program, you need to meet the following prerequisites:

- You have access to an OpenShift cluster and the `oc` command-line tool is configured to interact with your cluster.
- You have installed Node.js and Pulumi on your machine.
- You're logged in to your Pulumi account and have selected the appropriate stack that corresponds to your OpenShift environment.

### Detailed Explanation of the Program

When you define a Helm chart in Pulumi, you need to specify the chart name, the version, and optionally, additional values to customize the deployment. If the chart is not from the stable repository, you will also need to provide the repository URL.

In the case of deploying the `dapr-dashboard` chart, you will start by creating a new Pulumi project and stack by running `pulumi new` in your terminal. This provides you with a basic `index.ts` file, which you will update with the code we discuss next.

Next, you will use the `Chart` resource to deploy the Helm chart. This resource is an abstraction that manages the installation of the chart into the cluster. You need to provide the repository URL for the `dapr-dashboard` Helm chart and any other configuration parameters you might need. For the purposes of this explanation, we'll assume that you are deploying the chart with default configurations.

Once your Pulumi program is written, you run `pulumi up` to preview and deploy the changes to your OpenShift cluster.

### Pulumi Program

Below is the TypeScript code that you would place in your `index.ts` file:

```typescript
import * as k8s from '@pulumi/kubernetes';

// Create a Kubernetes provider instance that represents the OpenShift cluster. 
// The `kubeconfig` is assumed to be configured in the environment or via the Pulumi configuration.
const provider = new k8s.Provider("openshift", { kubeconfig: process.env.KUBECONFIG });

// Deploy the dapr-dashboard Helm chart.
const daprDashboardChart = new k8s.helm.v3.Chart("dapr-dashboard", {
    // Replace with the correct repository and chart name for dapr-dashboard if needed.
    repo: "dapr",
    chart: "dapr-dashboard",
    version: "x.y.z", // Specify the version of the chart you want to deploy
    // You can include `values` to configure the chart with custom values.
    values: {
        // Your custom values go here.
    },
}, { provider });

// Export the URL to access the dapr-dashboard 
export const dashboardUrl = daprDashboardChart.getResourceProperty("v1/Service", "dapr-dashboard", "status").apply(status => {
    return status.loadBalancer.ingress[0].hostname;
});

```

In the code above:

- `@pulumi/kubernetes` is imported, which is the Pulumi package for interfacing with Kubernetes clusters.
- A new `Provider` object is created, which tells Pulumi how to communicate with the OpenShift cluster by using the `kubeconfig` from your environment.
- The `Chart` resource called `daprDashboardChart` represents the `dapr-dashboard` Helm chart. You would replace `"x.y.z"` with the actual version of the Helm chart you intend on using.
- An optional `values` object can be provided to customize the Helm chart installation with configuration parameters specific to the `dapr-dashboard`.
- We export a stack output `dashboardUrl` which is a Kubernetes Service that points to the dapr-dashboard. You can use this URL to access the dashboard after it's deployed.

After the Pulumi program executes, it will print the exported `dashboardUrl`. Use this URL in a web browser to access the Dapr dashboard.

To deploy this code:

1. Save the code in an `index.ts` file in a new Pulumi project directory.
2. Run `pulumi up` to preview and deploy the changes.
3. Once the deployment is successful, access the Dapr dashboard using the URL provided by the stack output.

Remember to replace the `repo`, `chart`, and `version` placeholders with appropriate values for the `dapr-dashboard` Helm chart. The chart might have different configuration options which you would need to provide in the `values` object according to your requirements.