Deploy the url-shortener-redis helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Digital Ocean Kubernetes Service (DOKS) using Pulumi, you'll start by provisioning a Kubernetes cluster on Digital Ocean. Then you'll install the Helm Chart for the URL shortener application that uses Redis.

Here's a step-by-step guide along with the Pulumi TypeScript program to achieve this:

1. **Provision a Digital Ocean Kubernetes cluster**: We'll create a DOKS cluster using the `digitalocean.KubernetesCluster` resource. You need to provide the cluster name, region, version, node pool configuration, and any other necessary settings for your cluster.

2. **Deploy the Helm chart**: Once the cluster is provisioned, we'll use the `kubernetes.helm.v3.Chart` resource to deploy the URL shortener application Helm chart. The `chart` parameter refers to the name of the chart (in this case, `url-shortener-redis`), and you also need to specify the values for the chart configuration.

Here is the TypeScript program that describes the deployment:

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

// Step 1: Provision a Digital Ocean Kubernetes Cluster
const cluster = new digitalocean.KubernetesCluster("urlShortenerCluster", {
    region: "nyc3",
    version: "latest", // Replace with a specific Kubernetes version if needed
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb", // This is the size of the node (VM) in DigitalOcean
        nodeCount: 2, // Determines how many nodes you want in your node pool
    },
});

// Step 2: Deploy the "url-shortener-redis" Helm Chart
// Use the `kubernetes` provider to connect to the Digital Ocean Kubernetes cluster
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

const urlShortenerChart = new kubernetes.helm.v3.Chart("urlShortenerChart", {
    chart: "url-shortener-redis", // This name should be replaced with the actual chart name
    values: {
        // Here you will specify any values that the Helm chart accepts.
        // For the URL shortener, you might need to specify Redis configurations or other parameters
        // For example:
        // redis: {
        //     password: "your_redis_password",
        // },
    },
}, { provider: k8sProvider });

// Optional: Export the cluster's kubeconfig and the app service endpoint
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
export const appServiceEndpoint = urlShortenerChart.getResourceProperty("v1/Service", "url-shortener-service", "status");
```

In the code above:

- `digitalocean.KubernetesCluster` resource is used to create a new Kubernetes cluster in the specified region. We're using the `nodePool` property to define the size and number of nodes in the node pool.
- `kubernetes.helm.v3.Chart` resource is used to deploy the Helm chart by referencing it by name and providing necessary values configuration. Since the chart needs to be installed on the DOKS cluster, we create a Kubernetes `Provider` instance that uses the `kubeconfig` output from the created cluster.
- We export `kubeconfig` to allow users to interact with the Kubernetes cluster using tools like `kubectl`.
- We also attempt to export the service endpoint (assuming the Helm chart creates a Kubernetes Service named `url-shortener-service`), which can be used to access the deployed application. Note that you might need to adjust this based on the actual resources your Helm chart creates.

Remember to replace placeholders like `your_redis_password` and `url-shortener-service` with the actual values provided by the Helm chart documentation or specific to your deployment needs.

After the program is complete, you would run it using the Pulumi CLI to provision your infrastructure:

```bash
pulumi up
```

Be sure to have Pulumi CLI and Digital Ocean access configured on your local machine where you run this command. This will kick off the deployment process orchestrated by Pulumi, and you will see all the infrastructure changes in your CLI or Pulumi Console.