Deploy the openrefine helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy the OpenRefine Helm chart on a Kubernetes cluster using Pulumi, you will need to use Pulumi's Kubernetes provider to manage Kubernetes resources directly. The Helm chart will be encapsulated in a `Chart` resource, which Pulumi will use to apply the chart to your cluster.

Below is a TypeScript Pulumi program that deploys the OpenRefine Helm chart. The `kubernetes.helm.v3.Chart` resource represents a Helm chart that Pulumi will deploy to your Kubernetes cluster. This resource expects several properties, such as `chart` to specify the chart name, `version` to specify the chart version, and `values` to provide custom values for the Helm chart.

For OpenRefine, the Helm chart might be available in a community Helm repository, so you would need to add that repository URL to the `repo` property. The `values` object could be used to customize the installation, but in this basic example, we're using the default values provided by the Helm chart.

Here's a simplified example of deploying OpenRefine with default values:

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

// Create an instance of the Kubernetes Helm Chart class.
const openRefineChart = new k8s.helm.v3.Chart("openrefine", {
    // The repository where the OpenRefine Helm chart is located.
    repo: "https://repository/url/for/openrefine", // Replace with the actual repository URL
    // The name of the chart.
    chart: "openrefine",
    // Specify the version of the chart you wish to deploy.
    version: "1.0.0", // Replace with the actual chart version
    // Provide any custom values to the Helm chart.
    values: {
        // If the chart requires any custom values, specify them here.
        // For example:
        // service: {
        //     type: "LoadBalancer"
        // },
    },
    // If needed, you could specify the Kubernetes namespace to deploy into. 
    // Otherwise, it will be deployed into the default namespace.
    // For example, to deploy into the "default" namespace:
    namespace: "default",
});

// To access the values of the deployed resources, such as IP addresses or hostnames,
// you can export these values using the following format:
export const openRefineServiceIP = openRefineChart.getResourceProperty("v1/Service", "openrefine", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

This program imports the Kubernetes package from Pulumi's library (`@pulumi/kubernetes`). Then it creates a Helm chart resource with the name `openrefine`, specifying the Helm chart's repository, chart name, version, and any values overrides. It also specifies the Kubernetes namespace for deployment.

If your Helm chart exposes a service with an external IP (typically when using a service of type `LoadBalancer`), you might want to export this IP so you can easily obtain it after deployment. The `getResourceProperty` method retrieves properties of resources, and we're using `apply` to access the nested properties of the load balancer IP address. If your service uses a different setup (like a NodePort or an Ingress), you would need to adjust this part accordingly.

Note: Be sure to replace `"https://repository/url/for/openrefine"` with the actual URL of the Helm repository that contains the OpenRefine chart, and adjust the `version` with the chart version you want to deploy. The `values` object is where you would place any configuration overrides specific to the OpenRefine Helm chart; since this is a simplified example, it's left blank, assuming the defaults are fine for your use case.