Deploy the redis-persistent helm chart on Opensshift

Question

Pulumi · Accepted Answer

To deploy the `redis-persistent` Helm chart on an OpenShift cluster using Pulumi, you will need to use the `kubernetes` package provided by Pulumi. This package allows you to perform the deployment as you would with native Helm, but with the infrastructure as code benefits provided by Pulumi.

Below you will find a Pulumi program written in TypeScript that deploys the `redis-persistent` chart. Here's how it works:

1. The `@pulumi/kubernetes` npm package is used. This package provides the necessary classes and functions to interact with Kubernetes resources, including Helm charts.

2. The `helm.v3.Chart` resource is then used to deploy the chart. You need to specify the chart name, and optionally, you can specify the chart version, values to override the default ones, and the namespace in which to deploy.

3. You also need to ensure that you have access to your OpenShift cluster from your local environment, and you should be logged into the cluster. Pulumi's Kubernetes provider will use your local kubeconfig file by default to communicate with your cluster.

Here's the Pulumi program:

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

// Create an instance of the helm.v3.Chart class, which represents a Helm chart.
const redisPersistentChart = new k8s.helm.v3.Chart("redis-persistent", {
    // Specify the chart name and optionally a repository.
    // If the repository isn't specified here, ensure that it's added to your Helm on your local machine.
    chart: "redis-persistent",
    
    // Specify the version of the chart you want to deploy.
    version: "X.Y.Z", // Replace X.Y.Z with the version number you want to use.
    
    // You can also specify any custom values you want to override in the chart.
    // This would be the equivalent of setting a --set flag in the Helm CLI.
    values: {
        // Your custom value overrides would go here.
        // For example:
        // usePassword: false
    },
    
    // Specify the namespace where this chart will be deployed.
    // If this namespace doesn't exist, Pulumi will create it as part of the deployment.
    namespace: "your-namespace", // Replace this with the appropriate namespace.
    
    // If you need to fetch the chart from a specific Helm repository,
    // provide the relevant fetching options here.
    fetchOpts: {
        // For instance, set the repository URL:
        // repo: "https://charts.bitnami.com/bitnami"
    },
    
    // You might need to enable CRD creations if your chart includes CRDs
    skipAwait: false
});

// Optional: If you need to expose any of the outputs from your chart, such as URLs or external IP addresses:
export const redisEndpoint = redisPersistentChart.getResourceProperty("v1/Service", "redis-persistent", "status");

```

Remember to replace `"X.Y.Z"` with the actual chart version you intend to deploy, and `"your-namespace"` with the namespace targeted for the deployment. You may also need to provide the actual repository URL under `fetchOpts` if the `redis-persistent` chart is not part of the default Helm repository.

Make sure to include any custom values you want to override in the `values` object. This is equivalent to setting `--set` flags when using the Helm CLI.

Once you run this Pulumi program with the `pulumi up` command, it will provision the Redis instance in the specified OpenShift cluster.

**Note**: The `skipAwait` option is set to `false` to ensure that Pulumi waits for all resources to be available before considering the deployment a success. This might be important for charts that install CRDs (Custom Resource Definitions).

Ensure that your development environment has access to the OpenShift cluster and that you have the necessary permissions to deploy Helm charts. Pulumi will use the credentials from your kubeconfig file.