Deploy the openfunction helm chart on Opensshift

Question

Pulumi · Accepted Answer

We will be deploying the OpenFunction Helm chart to an OpenShift cluster using Pulumi. To achieve this, we will use the kubernetes.helm.v3.Chart resource, which allows us to deploy Helm charts on a Kubernetes cluster. This process assumes you have an OpenShift cluster up and running and that you have configured your local environment with the appropriate credentials to interact with it.

The steps to accomplish the deployment are:

Set up a Pulumi project with the necessary configurations. I'll assume you have Pulumi installed and configured with your cloud provider.
Import necessary libraries and create a stack in Pulumi.
Use the Helm chart resource to deploy OpenFunction.

Here's the TypeScript program that demonstrates these steps:

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

// You must have your OpenShift kubeconfig file pointed to by your KUBECONFIG environment variable,
// or have the kubeconfig at the default location (`~/.kube/config`), and Pulumi will use it to connect to the cluster.
// Additionally, ensure your current context is set to the OpenShift cluster where you want to deploy OpenFunction.

// Creating a new Helm Chart to deploy OpenFunction
const openFunctionChart = new k8s.helm.v3.Chart("openfunction", {
    // In the `repo` property, specify the repository that holds the OpenFunction chart.
    // For instance, if it's a public repository you can specify its URL directly.
    // If the OpenFunction Helm chart is not hosted in a public repository, you need to add the repository that contains the chart.
    // repo: "https://charts.example.com/"
    chart: "openfunction",
    // Specify which namespace to install into.
    namespace: "openfunction-namespace",
    // If you have a specific version of OpenFunction you want to use, you can set it here.
    version: "0.1.0",
    // Values allow you to provide a custom configuration for OpenFunction.
    // This would be similar to what you would pass using `-f config.yaml` or `--set key=value` with Helm CLI.
    values: {
        // Place your custom values here
        // For example:
        // serviceType: "LoadBalancer",
    },
    // Set this only if you need to fetch the chart from a private helm repo that requires authentication
    // fetchOpts: {
    //     // Provide authentication credentials here, if required.
    //     username: "<YOUR-HELM-REPO-USERNAME>",
    //     password: "<YOUR-HELM-REPO-PASSWORD>",
    // },
    // Transformations can be used to programmatically alter the Kubernetes manifests that the Helm chart generates.
    // For example, you might want to add common labels or annotations on all resources.
    transformations: [
        (obj: any) => {
            // Add your transformations here
        },
    ],
});

// Export the URL for the deployed application
export const openFunctionUrl = openFunctionChart.getResourceProperty(
    "v1/Service", "openfunction-dashboard", "status"
).apply(status => status.loadBalancer.ingress[0].hostname || status.loadBalancer.ingress[0].ip);

Here's a breakdown of what the code is doing:

We import the @pulumi/kubernetes package which provides us the capability to interact with Kubernetes and deploy Helm charts.
We create a new instance of k8s.helm.v3.Chart which represents the OpenFunction Helm chart.
We configure the Helm chart by specifying the chart, namespace, version, and values. These values correspond to the chart's name, the namespace to deploy into, the version of the chart you want to deploy, and any custom configuration you wish to provide to the Helm chart when deploying it.
(Optional) We use fetchOpts if we need to provide authentication details for fetching the chart from a private Helm repository.
(Optional) We provide an example of how to use the transformations array to programmatically modify the manifests before they are applied to the cluster.
The openFunctionChart.getResourceProperty method is being used to export the URL of the service. This URL can be used to access the OpenFunction dashboard once it's deployed. This assumes that there is a service created by the chart called openfunction-dashboard.

Remember to customize the chart, namespace, version, and values fields as per the OpenFunction Helm chart's requirements and your setup. Ensure you specify the correct repository if the chart is not located in the public Helm repository.

To deploy this Pulumi program:

Create a new directory and cd into it,
Run pulumi new typescript to create a new Pulumi TypeScript project,
Paste the above program into index.ts,
Run pulumi up to preview and deploy the changes.

For more information on creating Helm charts within Pulumi, you can check out the Pulumi Helm documentation.