Deploy the tensorflow-serving helm chart on Opensshift

Question

Pulumi · Accepted Answer

To deploy the TensorFlow Serving helm chart on OpenShift, you'll need to use the Pulumi Kubernetes provider, which allows you to write your infrastructure code using programming languages like TypeScript.

Here's a step-by-step guide on how to utilize the Pulumi Kubernetes provider to deploy a helm chart:

1. **Import the necessary packages**: You’ll start by importing the packages you need. In this case, `@pulumi/kubernetes` is the main package that allows you to interact with Kubernetes resources, including deploying Helm charts.

2. **Create a new Kubernetes provider instance**: This step targets OpenShift specifically, as OpenShift is a Kubernetes distribution. You might need to specify certain configurations like the kubeconfig file, which enables Pulumi to communicate with your OpenShift cluster.

3. **Deploy the Helm Chart**: This is where you define the Helm chart you want to deploy. You’ll specify the chart name (`tensorflow-serving`), the version if needed, the repository where the chart can be found if it’s not in the default Helm repository, and any values you want to override in the chart’s default configuration.

Below is a TypeScript program demonstrating these steps. The program assumes that you already have access to an OpenShift cluster and `kubectl` is configured correctly with the necessary rights to deploy resources.

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

// Create an instance of the Kubernetes provider targeting the OpenShift cluster.
const provider = new k8s.Provider("openshift", {
    // This assumes you are using the default kubeconfig.
    // You may need to configure the kubeconfig option if it's located elsewhere.
    kubeconfig: process.env.KUBECONFIG,
});

// Deploy TensorFlow Serving using a Helm Chart.
const tensorflowServingChart = new k8s.helm.v3.Chart("tensorflow-serving", {
    chart: "tensorflow-serving",
    // Specify the version of the Helm chart you wish to deploy.
    // version: "2.4.0", // example version
    // If it's not in the default Helm repo, specify the repo where it can be found.
    // repo: "https://some-repo-url/",
    // You can pass configuration values to customize the deployment.
    values: {
        // Example value override: adjust with actual values required by the chart.
        // image: { tag: "latest" },
    },
}, { provider });

// Export the Chart's status as an output.
export const status = tensorflowServingChart.status;
```

In this code:

- We create a new Kubernetes `Provider` instance configured to interact with OpenShift.
- We deploy TensorFlow Serving using the `Chart` resource from Pulumi’s Kubernetes provider.
- The `values` object is where you’d supply any configuration required by the TensorFlow Serving Helm chart; this varies based on the chart itself and your particular needs.

To run this Pulumi program:

1. Save the code in a file with a `.ts` extension.
2. Run `pulumi up` within the directory where this file is located after initializing a Pulumi project.
   
Pulumi will then show you a preview of the resources that will be created, which upon confirmation will be applied to your OpenShift cluster.

Please ensure to have Pulumi installed and set up to work with your OpenShift cluster before running this program. You might also need to install the required NPM packages (`@pulumi/kubernetes`) using `npm install` or `yarn add` for the program to run.