Deploy the tyk-data-plane helm chart on Opensshift

Question

Pulumi · Accepted Answer

To deploy the `tyk-data-plane` Helm chart on an OpenShift cluster using Pulumi, you will need to write a Pulumi program that sets up the necessary Kubernetes resources. OpenShift is a Kubernetes distribution, so deploying Helm charts on OpenShift doesn't differ much from deploying them on a generic Kubernetes cluster.

The following Pulumi TypeScript program provides an illustration of how you could do this. First, we need to ensure you have installed the necessary Pulumi packages for interacting with Kubernetes resources. You can install the packages using npm or yarn:

```shell
npm install @pulumi/kubernetes
```

or

```shell
yarn add @pulumi/kubernetes
```

Now, here is the detailed Pulumi TypeScript program to deploy the `tyk-data-plane` Helm chart:

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

// Create an instance of the Kubernetes provider connected to your OpenShift cluster.
// You would typically configure the provider using your kubeconfig file.
const provider = new k8s.Provider("openshift-provider", {
    // Adjust this to point to your actual kubeconfig path or file content
    kubeconfig: process.env.KUBECONFIG,
});

// Define the settings for the tyk-data-plane helm chart
const tykDataPlaneChart = new k8s.helm.v3.Chart("tyk-data-plane", {
  // Specify the chart repository and name
  chart: "tyk-headless",
  // Specify the chart version you want to deploy
  version: "0.6.0",
  // Specify which namespace the chart should be deployed into
  namespace: "tyk",
  // If the namespace does not exist, Pulumi can create it for you
  // Specify any custom values you want to pass to your Helm chart
  values: {
    // In this object, you would specify your custom values that are specific to the tyk-data-plane chart.
    // As an example, you may want to specify the MongoDB address and port if tyk is using MongoDB.
    mongodb: {
      enabled: true,
      addr: "my-mongodb", // Replace with the actual MongoDB service address
      port: 27017, // Replace with the actual MongoDB service port if different
    },
    // You could also set other values such as Redis configuration, extra environment variables, etc.
    // Check the tyk-data-plane Helm chart's 'values.yaml' file for all available options.
  },
  // Use the provider we configured earlier to ensure we deploy to the correct cluster
  fetchOpts: {
    repo: "https://helm.tyk.io/public/helm/charts/",
  },
}, { provider: provider });

// Export the resources created by the Helm chart that could be useful to access the application
export const chartStatus = tykDataPlaneChart.status;

// After deploying the Helm chart, you can access the exported `chartStatus` to verify
// if the deployment succeeded and the resources are running as expected.
```

In the code above, we do the following:

1. Import the Kubernetes package from Pulumi which allows us to interact with Kubernetes resources including Helm charts.
2. Create a Kubernetes `Provider` instance connected to your OpenShift cluster, pointing to your kubeconfig file.
3. Define the deployment of the `tyk-data-plane` Helm chart using the `Chart` resource from Pulumi's Kubernetes provider. You will need to specify the chart name, version, and namespace where you want it deployed.
4. Optionally, through the `values` parameter of the `Chart` resource, pass configuration parameters to the Helm chart (e.g., MongoDB and Redis settings).
5. As part of the chart definition, specify the `fetchOpts` to provide the Helm repository where the `tyk-data-plane` chart is located.
6. Assign the status of the Helm chart deployment to an exportable variable called `chartStatus` which can be used to check the outcome of the deployment.

Make sure to replace the placeholders and adjust the configurations according to the specific needs of your deployment, such as MongoDB or Redis settings.

To run this Pulumi program, you would navigate to the directory containing the program, ensure you have authenticated against your OpenShift cluster with your `kubeconfig`, and then use the Pulumi CLI to create and deploy the resources:

```shell
pulumi up
```

This command triggers Pulumi to preview and deploy your resources to the OpenShift cluster you are connected to. Pulumi will show a preview of the actions it's going to take, and after confirming, it will proceed with the deployment. If everything is configured correctly, the `tyk-data-plane` Helm chart will be deployed in your OpenShift cluster.