Deploy the parsoid helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy a Helm chart on a Digital Ocean Kubernetes (DOKS) cluster using Pulumi, you need to take the following steps:

1. **Set up a new Pulumi project**: Set up a Pulumi project with the necessary configurations if you haven't already. Ensure that your Digital Ocean Access Token is set so that Pulumi can authenticate with Digital Ocean.

2. **Provision the DOKS cluster**: Use the `digitalocean.KubernetesCluster` resource to create a new managed Kubernetes cluster on Digital Ocean.

3. **Deploy the Helm chart**: Use the `kubernetes.helm.v3.Chart` resource to deploy the Parsoid Helm chart onto your DOKS cluster. You’ll need to provide the necessary chart information such as the chart name, repository, and any custom values you wish to apply.

Let's construct a Pulumi program in TypeScript that will perform these steps. Below is an explanation and annotated code for each step in the process:

### Step 1: Provision a Digital Ocean Kubernetes cluster

The following code will create a Digital Ocean Kubernetes Cluster. We're specifying some basic configuration like region, version, and node pool details. The node pool is a collection of droplets that constitute your Kubernetes cluster.

### Step 2: Deploy the Parsoid Helm chart

After creating the Kubernetes cluster, we use a Helm chart to deploy Parsoid. The Helm chart allows you to define, install, and upgrade complex Kubernetes applications. Parsoid is a service that translates between Wikitext (used by MediaWiki) and HTML used by VisualEditor. Note that you'll need the correct Helm chart name and repository URL for Parsoid which should be available from the chart's maintainers or the community where the chart is hosted.

Below is a Pulumi TypeScript program combining both steps:

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

// Set up Digital Ocean Provider configuration
const doConfig = new pulumi.Config("digitalocean");
const token = doConfig.requireSecret("token");

const provider = new digitalocean.Provider("do-provider", {
    token: token,
});

// Step 1: Provision a Digital Ocean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("doks-cluster", {
    region: digitalocean.Regions.NYC3,
    version: "latest", // You may specify a version like "1.21.5-do.0"
    nodePool: {
        name: "doks-cluster-nodepool",
        size: digitalocean.DropletSlugs.DropletS2VCPU2GB,
        nodeCount: 2, // Specify the number of nodes you want
    },
}, { provider: provider });

// Step 1.1: Export the Kubeconfig
export const kubeconfig = cluster.kubeConfigs.apply(kc => kc[0].rawConfig);

// Assign a Kubernetes provider to the cluster kubeconfig
const k8sProvider = new kubernetes.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Step 2: Deploy the Parsoid Helm chart
const parsoidChart = new kubernetes.helm.v3.Chart("parsoid", {
    chart: "parsoid",
    version: "x.y.z", // replace x.y.z with the chart version
    fetchOpts: {
        repo: "https://helm-repo/parsoid", // replace with the actual repo URL
    },
}, { provider: k8sProvider });

// Export the parsoid deployment endpoint
export const parsoidEndpoint = parsoidChart.getResourceProperty("v1/Service", "parsoid", "status");

```

### Usage of this Pulumi Program

1. Ensure you have Pulumi and the required dependencies installed on your development machine.
2. Set up your Digital Ocean Access Token by running `pulumi config set digitalocean:token <Your-Access-Token> --secret`.
3. Save the program in a `index.ts` file at the root of your Pulumi project directory.
4. Deploy the stack with `pulumi up`. This will create your DOKS cluster and deploy the Parsoid application.
5. The program exports the Kubeconfig and the endpoint for Parsoid, which can be retrieved after the deployment succeeds using `pulumi stack output`.

The Pulumi CLI will provide you with detailed information about what resources are being created, updated, or deleted. If the `pulumi up` command is successful, your Digital Ocean Kubernetes cluster will be up and running with the Parsoid application deployed on it.