Deploy the benthos helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart like Benthos on the DigitalOcean Kubernetes Service (DOKS) using Pulumi, you'll follow these general steps:

1. Create a DigitalOcean Kubernetes cluster.
2. Deploy the Benthos Helm chart onto this Kubernetes cluster.

We'll be using the `digitalocean` package to provision the cluster, and the `kubernetes` package to interact with the Kubernetes cluster and deploy Helm charts.

Here's a detailed program that demonstrates how to accomplish this with Pulumi and TypeScript:

First, we will set up the necessary imports:
- `@pulumi/pulumi`: The core Pulumi SDK.
- `@pulumi/digitalocean`: The DigitalOcean package for Pulumi.
- `@pulumi/kubernetes`: The Kubernetes package for Pulumi, which enables us to deploy Helm charts.

Then, we'll create a new DigitalOcean Kubernetes cluster using `digitalocean.KubernetesCluster`. The properties for this resource will define our cluster’s size, region, and Kubernetes version.

With the Kubernetes cluster set up, we'll use `@pulumi/kubernetes` to define a Helm chart resource, representing the Benthos chart. We'll need to specify the chart name, version, and repository URL if it's not a chart from the default Helm repository.

Lastly, we'll export the kubeconfig of our cluster, which would allow you to interact with your Kubernetes cluster from your local machine using `kubectl`.

Below is the TypeScript program that achieves the deployment:

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

// Create a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: "nyc3",
    version: "1.21.5-do.0",
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb", // Choose the size that is appropriate for your workload
        nodeCount: 2,
    },
});

// Create a Kubernetes provider instance that uses our cluster from DigitalOcean
const k8sProvider = new k8s.Provider("do-k8s-provider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Deploy the Benthos Helm chart on the DigitalOcean Kubernetes cluster
const benthosRelease = new k8s.helm.v3.Release("benthos-helm-chart", {
    chart: "benthos",
    version: "1.0", // Replace with the actual chart version you intend to deploy
    repositoryOpts: {
        repo: "https://helm.your-company.com" // Replace with the Helm chart's repository URL or remove if using a chart from Helm stable
    },
}, { provider: k8sProvider });

// Export the kubeconfig to access the cluster with kubectl
export const kubeConfig = cluster.kubeConfigs[0].rawConfig;
```

In this program:
- We specified `"nyc3"` as the region and `"s-2vcpu-2gb"` as the node size — you can adjust these values to meet your preferences and requirements.
- We created a new `k8s.Provider` which is necessary for Pulumi to communicate with our new Kubernetes cluster.
- We are deploying the Benthos chart to our cluster. Make sure to fill in `version` with the correct version of your Helm chart, and `repo` with the URL to the Helm repository where Benthos is hosted.

You can use the exported kubeconfig to connect to your Kubernetes cluster using the `kubectl` command-line tool. Keep the kubeconfig secure since it allows access to your cluster.

To get started with this Pulumi code, you would save it to a file (e.g., `index.ts`), then run `pulumi up` within the same directory to create the resources in DigitalOcean. Ensure you have the Pulumi CLI installed and configured with access to your DigitalOcean account.