Deploy the kubernetes-diff-logger helm chart on Opensshift

Question

Pulumi · Accepted Answer

In this guide, I will show you how to deploy a Helm chart on an OpenShift cluster using Pulumi. Pulumi provides a Kubernetes provider which allows us to manage Kubernetes resources including deploying applications with Helm charts.

The `kubernetes.helm.v3.Chart` resource is the Pulumi abstraction for a Helm chart. This resource enables you to deploy Helm charts to your Kubernetes clusters. When using this resource, you specify the chart name, version, and the values you want to override, similar to how you would when using the `helm` CLI command. The chart can come from any Helm chart repository or from a local path. For OpenShift, which is essentially a Kubernetes distribution, the approach is the same.

Now, let's write the Pulumi program in TypeScript:

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

// Assuming you have a pre-configured kubeconfig file for authentication to the OpenShift cluster,
// Pulumi will use that configuration to deploy resources to the right cluster.

const chartName = "kubernetes-diff-logger";
const chartVersion = "1.0.0"; // Please replace with the actual chart version you intend to deploy
const releaseName = "kubernetes-diff-logger-release";
const namespace = "default"; // Make sure to replace with the namespace where you want it deployed

// Define a Helm chart resource for the kubernetes-diff-logger chart.
// This example uses a chart from a remote Helm repository. If you have a local chart, you would use the `path` parameter.
const diffLoggerChart = new k8s.helm.v3.Chart(releaseName, {
    chart: chartName,
    version: chartVersion,
    namespace: namespace,
    // If you have custom values you'd like to specify, define them in an object as shown below:
    // values: {
    //     key: "value",
    // },
    // If the chart requires repository information, you can also specify the repo URL:
    // fetchOpts:{
    //     repo: "http://helm-repository-url/charts",
    // },
}, {
    // This option allows to skip awaiting the Helm chart resources to be ready (Optional).
    skipAwait: true,
});

// Export the URL of the deployed application. This may vary depending on the chart, and 
// you might need other outputs such as an IP address, a domain name, or API endpoints.
export const applicationUrl = diffLoggerChart.getResourceProperty("v1/Service", "kubernetes-diff-logger-service", "status").apply(status => status.loadBalancer.ingress[0].ip ?? status.loadBalancer.ingress[0].hostname);
```

In the above program, a Pulumi `Chart` resource is created, which represents the `kubernetes-diff-logger` Helm chart. This chart is assumed to be a pre-existing chart that you want to deploy to your OpenShift cluster. Replace the `chartVersion` with the actual version of the chart you want to deploy.

The `namespace` indicates where in the OpenShift cluster the chart should be deployed. If the Helm chart is located in a private or custom repository, you need to specify the `repo` option inside `fetchOpts` with the URL of the Helm repository.

By default, Pulumi waits until all the resources described by the Helm Chart are fully created in the cluster before marking the deployment as complete. If you set the `skipAwait` option to `true`, Pulumi returns immediately without waiting for readiness which might be preferable during development cycles.

Lastly, the code demonstrates how to export a URL associated with the deployed application. Note that obtaining such a URL will largely depend on the resources and outputs defined in the Helm chart, so you may need to adjust this part based on what the `kubernetes-diff-logger` chart exposes.

Make sure your OpenShift cluster is properly configured in your kubeconfig file as Pulumi uses it to communicate with the cluster. With your kubeconfig in place, you should be able to run this Pulumi program without any issues to deploy the `kubernetes-diff-logger` helm chart.

Run the Pulumi program with:

```shell
pulumi up
```

This will initialize Pulumi, build the program, and preview the changes. Confirm the deployment to proceed with the actual update, which will apply the changes to your OpenShift cluster. After the completion, if the Helm chart generates an external endpoint, Pulumi will output the URL of the application for you to access.