Deploy the redis-persistent helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

Deploying a Redis instance with persistent storage using the `redis-persistent` Helm chart on a Digital Ocean Kubernetes cluster involves several steps. I will break down these steps and provide a program written in TypeScript that deploys a Kubernetes cluster on Digital Ocean and then installs the Redis Helm chart into that cluster.

### Steps to Deploy Redis on DOKS:

1. **Create a Kubernetes Cluster on Digital Ocean**: We'll use the `digitalocean.KubernetesCluster` resource to provision a new Kubernetes cluster on Digital Ocean.
2. **Initialize the Helm Provider**: We need to set up the Helm provider so Pulumi can work with Helm charts. For this, we set up a Kubernetes provider instance that uses the outputted kubeconfig from our Digital Ocean Kubernetes cluster created in step 1.
3. **Install the Redis Helm Chart**: Using the Helm Release resource from Pulumi's Kubernetes provider, we'll install the `redis-persistent` Helm chart on our Digital Ocean cluster.

### Prerequisites:

Before running the Pulumi program, you'll need the following:
- Pulumi CLI installed and authenticated with Digital Ocean.
- Access to your Digital Ocean token.
- Helm and kubectl installed on your machine.

Now, let's write the program:

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

// Step 1: Create a Digital Ocean Kubernetes Cluster.
const cluster = new digitalocean.KubernetesCluster('do-cluster', {
    region: 'nyc1',  // Choose the region that is geographically close or preferred
    version: 'latest',  // Specify the version, or use 'latest' for the latest version supported by DOKS
    nodePool: {
        name: 'default',
        size: 's-2vcpu-2gb',  // The slug identifier for the type of Droplet to use as workers
        nodeCount: 2,  // The number of Droplet instances in the node pool
    },
});

// Kubernetes provider to use the kubeconfig from the generated cluster
const k8sProvider = new k8s.Provider('do-k8s', {
    kubeconfig: cluster.kubeConfigs.apply(kc => kc[0].rawConfig),
});

// Step 2: Install the Redis Helm chart using the Helm Release resource.
const redisChart = new k8s.helm.v3.Chart('redis', {
    chart: 'redis',  // The name of the chart
    version: '14.8.12',  // Replace this with the specific chart version you want to deploy
    fetchOpts: {
        repo: 'https://charts.bitnami.com/bitnami',
    },
    // Use values to configure the Redis chart.
    // The following are just examples, replace them with your desired Redis configurations.
    values: {
        usePassword: false,
        cluster: {
            enabled: false,
        },
        master: {
            persistence: {
                // Set persistence storage values according to your needs
                storageClass: 'do-block-storage',
                size: '8Gi',
            },
        },
    },
}, { provider: k8sProvider });

// Export the cluster's kubeconfig and Redis service endpoint
export const kubeconfig = cluster.kubeConfigs.apply(kc => kc[0].rawConfig);
export const redisService = redisChart.getResource('v1/Service', 'redis-master').status.apply(s => s.loadBalancer.ingress[0].ip); // Make sure the service name is correct.
```

### Explanation:

- We create a new Digital Ocean Kubernetes cluster with the `digitalocean.KubernetesCluster` resource. We set the name, region, Kubernetes version, and node pool details here.
- We configure the `k8s.Provider` to use the generated kubeconfig from the Digital Ocean Kubernetes cluster.
- We install the Redis Helm chart by creating a new `k8s.helm.v3.Chart` instance. We specify the chart name, version, and Helm repository. We also set custom values to configure Redis persistence with Digital Ocean's block storage, disable password usage, and disable clustering, as it's a more advanced topic.
- Finally, we export the kubeconfig and the external IP address of the Redis service so you can connect to your Redis instance.

### Running the Program:

To run this program, save it to a file, for example `index.ts`. In the same directory, run the following commands:

```bash
pulumi stack init dev                   # Initializes a new Pulumi stack for deployment
pulumi up                               # Preview and deploy the changes
```

After executing `pulumi up`, you will see an output of the resources being created. Once complete, you'll receive the Redis service endpoint, which you can use to connect to your Redis instance.