Deploy the redis-persistent helm chart on Kubernetes

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Kubernetes cluster using Pulumi, you would typically use the `Chart` resource from the Pulumi Kubernetes provider. This allows you to specify the Helm chart you want to deploy, along with any custom values or configurations required by that chart.

Below you'll find a Pulumi program written in TypeScript that deploys the "redis-persistent" Helm chart. The `Chart` resource allows us to specify the chart we want to deploy by name, and optionally, we can also specify the version, repository, and any additional configuration values that the chart may require.

In the case of a Redis chart, you'd often want to customize the `values` to change the default settings, such as resource requests and limits, persistence settings, or Redis-specific configurations like passwords and clustering options.

First, let's set up the Pulumi program:

- We start by importing the necessary Pulumi and Kubernetes packages.
- Next, we create a new `Chart` resource, providing a name for our deployment ("redis-persistent").
- In the `ChartArgs`, we specify the chart name. Depending on the Helm repository, the chart name might be different. We'll assume "redis" for this example.
- We can also specify the `version` if we want a specific version of the Redis chart. If we don't specify a version, the latest one will be installed.
- If the chart is hosted on a custom Helm repo, we must provide the `repo` URL. Otherwise, Pulumi will attempt to fetch it from the default Helm chart repositories.
- The `values` field allows us to set configuration parameters that are supported by the Redis chart. A common use case is enabling persistence and setting a specific size for the persistent volume. We can also specify other custom values as needed.

After running this program with Pulumi, it will reach out to the Kubernetes cluster configured in your environment and deploy the Redis Helm chart along with the settings you provided.

Here is the TypeScript program that accomplishes this:

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

const redisPersistentChart = new kubernetes.helm.v3.Chart("redis-persistent", {
    // Specify the chart to deploy. In some cases, the name may differ based
    // on the repository, so make sure to use the correct name.
    chart: "redis",
    
    // If you have a specific version of the Redis chart in mind, specify it here.
    // If omitted, the latest version is used.
    version: "x.y.z", // Replace 'x.y.z' with the desired chart version.
    
    // If the Redis chart is from a custom repository, specify its URL here.
    // repo: "https://charts.example.com/",
    
    // Set custom values for the chart. For a Redis chart, you might want to enable
    // persistence, set password, replica count, etc. Refer to the chart's 'values.yaml'
    // file for a complete list of configurable options.
    values: {
        // The specific values to set will depend on the Redis chart's values.yml.
        // Here's an example where we enable persistence and set a specific size for
        // the persistent volume. Adjust these according to your needs.
        usePassword: false,
        cluster: {
            enabled: false,
        },
        master: {
            persistence: {
                size: "10Gi",
                enabled: true,
            },
        },
        // Add any additional customization you require.
    },
    
    // Uncomment and specify the namespace if you want to deploy the chart within a specific namespace.
    // namespace: "my-namespace",
});

// Export the Redis service's cluster IP to access the Redis instance within the Kubernetes cluster,
// or if Redis has an External LoadBalancer IP, you can export that to access Redis outside the cluster.
export const redisClusterIP = redisPersistentChart.getResourceProperty("v1/Service", "redis-master", "spec").apply(spec => spec.clusterIP);
```

Note:
- Replace `"x.y.z"` with the precise version of the Redis chart you want to deploy.
- Adjust the `values` map to include any chart-specific custom values you want to override.
- If you want to deploy the Redis chart in a specific namespace, uncomment the `namespace` argument and specify the namespace name.
- After deploying, we're exporting the Redis cluster IP to be used for in-cluster access to the deployed Redis service.

When you run this Pulumi program, it will interact with your configured Kubernetes cluster and apply the defined Helm chart. Make sure to have `kubectl` configured with the correct context to access the desired Kubernetes cluster and that Pulumi has been set up to work with your account credentials.