Deploy the openrefine helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the OpenRefine Helm chart on Oracle Kubernetes Engine (OKE), we will undertake the following steps in our Pulumi program:

1. Ensure that we have the Oracle OCI provider configured for our project. This provider will enable us to interact with the Oracle Cloud Infrastructure services.

2. Next, we set up an Oracle Container Engine for Kubernetes (OKE) cluster using the `oci.ContainerEngine.Cluster` resource type. An OKE cluster will be the Kubernetes environment where we will run the OpenRefine application.

3. Following the setup of the OKE cluster, we will use the `kubernetes.helm.sh/v3.Chart` resource type provided by the Kubernetes provider to deploy the OpenRefine Helm chart to our cluster. This will involve specifying the chart repository where the OpenRefine chart is located, as well as any configuration parameters required by the chart.

4. Finally, we will verify the deployment and retrieve any output that may be useful, such as the cluster endpoint or the application URL.

Here is how the Pulumi TypeScript program may look:

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

// Create an OCI Kubernetes cluster (OKE)
const cluster = new oci.ContainerEngine.Cluster("myOkeCluster", {
    // Specify required OKE cluster properties here
    // For example, compartmentId, name, vcnId, etc.
    // These are typically sourced from your OCI environment
});

// After the cluster is created, we need to get the Kubeconfig to interact with it
const kubeconfig = pulumi.all([cluster.id]).apply(([clusterId]) => {
    // This function is a placeholder to represent fetching the kubeconfig.
    // In a real scenario, you would invoke the appropriate OCI functions using the SDK.
    return oci.containerEngine.getClusterKubeconfig({
        clusterId: clusterId,
    });
});

// Create a Kubernetes provider instance using the kubeconfig from the OKE cluster
const k8sProvider = new k8s.Provider("myK8sProvider", {
    kubeconfig: kubeconfig.apply(kc => kc.content), // Extract content from the fetched kubeconfig
});

// Deploy the OpenRefine Helm chart to the created Kubernetes cluster
const openRefineChart = new k8s.helm.v3.Chart("openRefine", {
    chart: "openrefine",
    version: "x.y.z", // Specify the version of OpenRefine Helm chart you want to deploy
    fetchOpts: {
        repo: "https://charts.example.com/", // The Helm repository URL where the OpenRefine chart is hosted
    },
}, { provider: k8sProvider });

// Export relevant outputs
export const clusterName = cluster.name;
export const openRefineChartStatus = openRefineChart.status;

// When running `pulumi up`, this program will:
// 1. Provision an OKE cluster on the Oracle Cloud Infrastructure.
// 2. Retrieve the kubeconfig to allow K8s provider to interact with the new cluster.
// 3. Deploy the specified version of the OpenRefine Helm chart from the given repository to the OKE cluster.
```

In this program, you'll need to replace placeholder values for cluster properties and Helm chart configuration with the actual parameters suited to your environment and needs. The `version` and `repo` values for the OpenRefine Helm chart should correspond to the correct Helm repository and chart version you intend to use.

It is recommended to run this Pulumi program in an environment where OCI CLI is configured with appropriate permissions, so that the call to `oci.containerEngine.getClusterKubeconfig` can authenticate and retrieve the kubeconfig file content.

Once the Pulumi program is successfully executed with the `pulumi up` command, it will deploy the OpenRefine application onto the OKE cluster. The status of the Helm release and additional information like the cluster name are exported as program outputs. These outputs can be used to further interact with the cluster or the deployed application.