Deploy the ibm-cp4d-watson-studio-instance helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy the IBM Cloud Pak for Data (CP4D) Watson Studio instance using a Helm chart on Kubernetes, you can utilize the `kubernetes.helm.v3.Chart` resource provided by Pulumi's Kubernetes provider. This resource allows you to deploy Helm charts into a Kubernetes cluster from within Pulumi programs.

Here's a step-by-step guide and TypeScript program that will help you with the deployment:

### Prerequisites:
- Ensure you have access to a Kubernetes cluster.
- Have `kubectl` configured to communicate with your cluster.
- You have Helm configured with the repositories required for deploying IBM CP4D.
- Ensure Pulumi CLI is installed and configured for TypeScript.
- Your Pulumi stack is already set up and selected.

### Steps in the Program:
1. Import the necessary Pulumi and Kubernetes packages.
2. Define a Helm chart resource for IBM CP4D Watson Studio.
3. Parameterize the chart deployment with the `values` object to provide custom configuration.
4. Export any necessary stack outputs, such as the instance endpoint.

Here is the TypeScript program for deployment:

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

// Define the settings for IBM CP4D Watson Studio Helm chart.
const watsonStudioChart = new k8s.helm.v3.Chart("ibm-cp4d-watson-studio", {
    // Specify Helm chart repository and chart name.
    chart: "ibm-cp4d-watson-studio",
    version: "3.5.0", // Replace with the desired chart version
    // Define the Kubernetes namespace to deploy the chart to.
    namespace: "ibm-cp4d", // Replace with your preferred namespace
    // Include custom values for the Helm chart.
    values: {
        // For example, you can specify the license acceptance to true.
        // Check the chart's default `values.yaml` for configurable parameters.
        license: {
            accept: true
        },
        // Additional configuration parameters go here.
    },
    // Configure the fetch options to specify the Helm repository URL.
    fetchOpts: {
        repo: "https://charts.ibm.com/ibmcp", // Replace with the IBM Helm chart repository URL,
    },
}, {
    provider: k8sProvider, // Optional: specify your Kubernetes provider if it's not the default one.
});

// Export the Kubernetes Service endpoint for IBM CP4D Watson Studio.
export const watsonStudioEndpoint = watsonStudioChart.getResourceProperty("v1/Service", "ibm-cp4d-watson-studio", "status").apply(status => {
  return status.loadBalancer.ingress[0].hostname; // Might change based on your Service type and configuration
});
```

### Explanation of the Program:

- We import the Kubernetes package from Pulumi (`"@pulumi/kubernetes"`) to interact with the Kubernetes cluster.
- We create an instance of `Chart` from the two available Pulumi Kubernetes Package helm modules, which represents a Helm chart deployment. `Chart` is a higher-level abstraction that simplifies deploying Helm charts.
- We use `values` to customize the installation. Every Helm chart has a default `values.yaml` file with parameters that can be overridden. Here, `license.accept` is set to `true`, which might be required for IBM charts to acknowledge acceptance of the terms and conditions. You should check the chart's documentation for appropriate values.
- In the `fetchOpts` field, we specify the repository URL where the Helm chart is located (`repo`), which should be the URL of the IBM Helm chart repository.
- Optionally, if you're operating on a non-default Kubernetes provider within Pulumi, you specify the provider.
- Finally, we export an endpoint, which depends on the service deployed by the Helm chart. Note that retrieving the correct endpoint might require additional steps based on how the IBM Cloud Pak for Data Watson Studio service is exposed (e.g., LoadBalancer, NodePort, Ingress).
- The `ibm-cp4d-watson-studio` chart name, version, namespace, and repository URL used are placeholders and should be replaced with the actual values corresponding to the IBM CP4D Watson Studio instance you wish to deploy.

To run this Pulumi program, you would save this code in a file named `index.ts` within your Pulumi project. Make sure to install the required dependencies by running:

```bash
npm install @pulumi/kubernetes
```

Then, use the Pulumi CLI to create and update the resources:

```bash
pulumi up
```

This will initiate the deployment process, and you will be presented with a summary of the planned changes before they are applied. Once you confirm, Pulumi will proceed with the deployment to your Kubernetes cluster.