Deploy the python-app helm chart on Opensshift

Question

Pulumi · Accepted Answer

To deploy a Helm chart called `python-app` on OpenShift using Pulumi, we're going to use the `kubernetes` package that provides the `Chart` resource—this allows us to deploy Helm charts to a Kubernetes cluster, which includes OpenShift as it's a Kubernetes distribution.

Before proceeding, make sure you have:
1. Installed Pulumi CLI.
2. OpenShift CLI (`oc`) configured to interact with your OpenShift cluster.
3. Helm CLI on your local machine to manage Helm charts.
4. Configured the Kubernetes provider for Pulumi to interact with your OpenShift cluster.

Here's a step-by-step TypeScript program that demonstrates how to deploy the `python-app` Helm chart to OpenShift:

1. We will use the `kubernetes` package's `Chart` class to create the Helm chart deployment in our OpenShift cluster.
2. The `Chart` class expects at least the `chart` and `version` properties to be provided, where `chart` is the name of the Helm chart to deploy, and `version` denotes the chart version.

Please replace `CHART_VERSION` with the actual version number of the `python-app` chart you wish to deploy. Also, if the chart is in a custom Helm repository, you will need to add the `repo` property with the repository URL.

Now, let's write the TypeScript program:

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

const projectName = "python-app-deployment";

// Creates a Helm chart deployment of the `python-app` in the specified namespace.
const chart = new k8s.helm.v3.Chart(projectName, {
    chart: "python-app",
    version: "CHART_VERSION", // Replace with the actual chart version.
    namespace: "your-namespace", // Specify the namespace, if applicable.
    // If your chart is in a custom repository, uncomment and configure the 'repo' property.
    // repo: "https://example.com/helm-charts",
    // You can specify custom values for your Helm chart release here.
    values: {
        // Provide any chart values here, like image version, replicas, etc.
        // example:
        // image: {
        //     tag: "latest",
        // },
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: "your-kubeconfig-path" }) });

// Export the URL of the deployed application (adjust the resource names accordingly)
export const appUrl = pulumi.interpolate`http://api.${chart.getResourceProperty("v1/Service", "python-app-service", "status")?.loadBalancer.ingress[0].hostname}/`;
```

**Explanation:**
- First, we import the necessary package (`@pulumi/kubernetes`).
- We then create a new Helm chart resource using the `Chart` class. This resource abstracts the Helm CLI's operation of deploying a chart.
- We give our chart a project name which will be used to prefix Helm releases and Kubernetes resources deployed by the chart.
- We define the chart name and version we want to deploy. Optionally, we specify the namespace where we want the Helm chart to be deployed in the cluster—replace `"your-namespace"` with the appropriate one. If you have a custom Helm repository, you need to provide the `repo` URL.
- The `values` object allows us to set values in the chart's `values.yaml` file, similar to using `helm install -f values.yaml` or `helm upgrade -f values.yaml`.
- We provide the `kubeconfig` path if necessary, which Pulumi uses to communicate with your OpenShift cluster. This should point to the correct kubeconfig file that accesses your OpenShift cluster.
- Lastly, we export the URL of the deployed application. Adjust the `getResourceProperty` calls to match the actual service resources created by your Helm chart.

To run this program, save it to a file named `index.ts`, and then run `pulumi up` in the same directory. Pulumi will perform the deployment.

Please ensure to replace placeholders like `"CHART_VERSION"`, `"your-namespace"`, and `"your-kubeconfig-path"` with your specific chart version, desired OpenShift namespace, and the path to your OpenShift `kubeconfig`, respectively. If you're deploying a Helm chart that's publicly available in the default repositories, you may omit the `repo` key.

**Note**: The final exported `appUrl` in the code is an example and might not directly apply. The actual way to access your application depends on how it's exposed in your `python-app` Helm chart. If it creates an Ingress, you should refer to that Ingress' hostname or IP. If it creates a LoadBalancer Service (common on cloud providers, but not typically for bare metal or local OpenShift clusters), you would use the Service's LoadBalancer IP or hostname. Adjust accordingly based on your chart's output.