Deploy the stunnel helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `stunnel` Helm chart on a Digital Ocean Kubernetes Service, we need to complete two primary tasks:

1. **Provision a Kubernetes Cluster on DigitalOcean:** We'll create a new Kubernetes cluster using DigitalOcean's managed Kubernetes service (DOKS).
2. **Deploy the stunnel Helm chart to the Cluster:** After the cluster is up and running, we'll use Pulumi's Kubernetes provider to deploy the `stunnel` Helm chart.

Below is a Pulumi program written in TypeScript that accomplishes both of these tasks.

First, add the necessary Pulumi packages to your project by running these commands:

```sh
pulumi new kubernetes-typescript  # Start a new Pulumi Kubernetes project if you haven't already
npm install @pulumi/pulumi        # Pulumi's core library
npm install @pulumi/digitalocean  # Pulumi's DigitalOcean provider
npm install @pulumi/kubernetes    # Pulumi's Kubernetes provider
```

Then, create a new TypeScript file (`index.ts`) and use the following program:

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

// Step 1: Provision a DigitalOcean Kubernetes cluster.
const cluster = new digitalocean.KubernetesCluster("do-cluster", {
    region: digitalocean.Regions.NYC1,
    version: "latest",
    nodePool: {
        name: "worker-pool",
        size: digitalocean.DropletSlugs.DropletS2VCPU2GB,
        nodeCount: 2,  // Specify the number of worker nodes
    },
});

// Step 2: Deploy the stunnel Helm chart to the cluster.
// Once the cluster is up and running, configure Pulumi to use the newly created cluster as the Kubernetes provider.
const kubeConfig = cluster.kubeConfigs[0].rawConfig;

const provider = new kubernetes.Provider("do-k8s-provider", {
    kubeconfig: kubeConfig,
});

// Use the Helm Chart resource to deploy stunnel. You will need to provide a valid chart name, repository, and any custom configurations required for stunnel.
const stunnelChart = new kubernetes.helm.v3.Chart("stunnel-chart", {
    chart: "stunnel",
    version: "x.y.z",  // Specify the chart version you intend to deploy
    repo: "stunnel-charts-repo",  // Replace with the correct Helm repo containing stunnel, if it's not stable
    values: {
        // Provide configuration parameters specific to the stunnel Helm chart
        // This is heavily dependent on the requirements of the stunnel chart itself
        // and could involve setting up TLS secrets, configuring ports, etc.
    },
}, { provider: provider });

// Export the cluster's kubeconfig and the stunnel service endpoint if available.
export const kubeconfig = kubeConfig;
export const stunnelEndpoint = stunnelChart.getResourceProperty("v1/Service", "stunnel-service", "status").apply(status => status.loadBalancer.ingress[0]?.ip);
```

**Explanation:**
1. We import three modules from Pulumi: basic utilities, the DigitalOcean provider, and the Kubernetes provider.
2. We provision a DOKS cluster in the `NYC1` region with a node pool of 2 instances of the `s-2vcpu-2gb` size.
3. With the DigitalOcean cluster created, we then configure the Kubernetes provider to use the kubeconfig of the new cluster.
4. Then, we instantiate a Helm chart resource for `stunnel`, specifying the chart name, version, repository, and any custom values.
5. Lastly, we export two pieces of information: the kubeconfig of the provisioned Kubernetes cluster and the IP address of the `stunnel` service deployed by the Helm chart. The `export` keyword allows us to easily retrieve this information from the Pulumi stack outputs after deployment.

**Note:** You will need to replace `x.y.z` and `stunnel-charts-repo` with the actual version and Helm chart repository that hosts `stunnel`. Also, tweak the `values` field with the appropriate values for the `stunnel` chart installation.

Before running the Pulumi program, you should ensure your Pulumi CLI is installed and configured with the appropriate DigitalOcean access token. Then, you can execute `pulumi up` to deploy your infrastructure. Pulumi will print out the IP endpoint for `stunnel` after deploying the chart, which you can use to interact with your `stunnel` service.