Deploy the openshift-networkpolicy helm chart on Opensshift

Question

Pulumi · Accepted Answer

Deploying a Helm chart on OpenShift using Pulumi is fundamentally similar to deploying on any Kubernetes cluster. Pulumi's Kubernetes provider wraps the Helm tooling with Resource classes that you can use to declaratively deploy Helm charts.

In this case, we're going to use the `kubernetes.helm.v3.Chart` class from Pulumi's Kubernetes provider to deploy the `openshift-networkpolicy` Helm chart on an OpenShift cluster.

Here's a step-by-step guide on how to achieve this, followed by the Pulumi TypeScript program:

1. **Set up your OpenShift cluster**: Before running the Pulumi program, you need an accessible OpenShift cluster. Ensure you have `kubectl` access configured or appropriate `kubeconfig` file that Pulumi can use to connect to the OpenShift cluster.

2. **Choose the Helm chart**: Ensure the `openshift-networkpolicy` Helm chart is available in the Helm repository you plan to use or is packaged locally.

3. **Configure Pulumi**: You will need to set up Pulumi for your environment if you have not done so already, which includes [installing Pulumi](https://www.pulumi.com/docs/get-started/install/) and [setting up your Pulumi account](https://www.pulumi.com/docs/intro/pulumi-service/accounts/).

4. **Write the Pulumi program**: Your Pulumi program specifies what Helm chart to deploy and provides configuration details.

Now let's look at the program that accomplishes this deployment:

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

// Define the Helm chart to deploy. In this case, it's the 'openshift-networkpolicy' chart.
const openshiftNetworkPolicyChart = new k8s.helm.v3.Chart("openshift-networkpolicy", {
    // Specify the namespace where the Helm chart will be installed.
    namespace: "default", // Change this to the namespace you wish the policy to be applied to.
    // Define the chart source, including repository and name. You'll need to replace 'repo_url'
    // with the URL of the repository containing the 'openshift-networkpolicy' chart.
    chart: "openshift-networkpolicy",
    // If necessary, specify the version of the chart you wish to deploy.
    version: "1.0.0", // Replace with the specific chart version you wish to use.
    // Optionally, you can pass configuration values to the chart.
    values: {
        // Add any specific values you want to set for the chart.
        // These must correspond to values expected by the 'openshift-networkpolicy' Helm chart.
    },
    // If the Helm chart is not from a public repository, 
    // you may need to configure access by providing repository options.
    fetchOpts: {
        repo: "https://example.com/helm-charts", // Replace with the actual Helm repo URL
        // If authentication is required, setup additional properties accordingly.
    },
}, { provider: kubeProvider }); // Pass the OpenShift provider if you have one configured.

// Export the name of the chart which can be used to reference the deployed chart later on,
// such as if you wish to upgrade or delete it, using Pulumi commands.
export const chartName = openshiftNetworkPolicyChart.id;
```

As we can see from the code above, the `kubernetes.helm.v3.Chart` class provides a straightforward way to deploy Helm charts programmatically. You'll notice placeholders for the Helm chart version, repository URL, and any custom values you wish to provide. Ensure that you replace these placeholders with the specific details that apply to your situation.

The `fetchOpts` property is where you'd specify the details of the private repository if the chart isn't available in public repos.

Please adjust the `namespace`, `chart`, and other details as per your environment and requirements. After running the Pulumi program, the chart will be deployed to your OpenShift cluster specified by the active kubeconfig context, or the provider you explicitly pass.

Before you execute this program with Pulumi commands (`pulumi up`), make sure you've installed Pulumi CLI, logged in to the Pulumi service, and have the Pulumi project and stack configured. This way, Pulumi knows where to deploy the resources you've described in your program.