Deploy the livekit-recorder helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `livekit-recorder` helm chart on Digital Ocean Kubernetes Service (DOKS) using Pulumi, you will need to carry out several key steps:

1. **Provision a DigitalOcean Kubernetes Cluster**: Set up a DOKS cluster where the Helm chart will be deployed.
2. **Deploy the `livekit-recorder` Helm Chart**: Use Pulumi's built-in Helm chart resource to deploy `livekit-recorder` onto the DOKS cluster.

Here's how you can achieve this:

#### Prerequisites
- Make sure that you've installed Pulumi and configured it for use with your DigitalOcean account. The `pulumi` CLI tool needs to be logged in, which can be done via `pulumi login`.
- You'll need `kubectl` installed on your machine to interact with the Kubernetes cluster.
- The `livekit-recorder` Helm chart should be available in a Helm repository, or you must have the chart available locally.

#### Pulumi Program

The following TypeScript Pulumi program will accomplish these tasks:

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

// Step 1: Provision the DigitalOcean Kubernetes Cluster
const cluster = new digitalocean.KubernetesCluster("livekit-cluster", {
    region: "nyc3",
    version: "1.21.5-do.0",
    nodePool: {
        name: "default-pool",
        size: "s-1vcpu-2gb",
        nodeCount: 3,
    },
});

// Export the cluster's kubeconfig.
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Step 2: Deploy the `livekit-recorder` Helm Chart
// Ensure that the Helm chart repository is added and updated outside of Pulumi, if the chart is not locally available.
const recorderChart = new kubernetes.helm.v3.Chart("livekit-recorder", {
    chart: "livekit-recorder",
    // You may need to specify additional chart values by providing a values object.
    // For example, to customize image versions, replica counts, or expose specific settings.
    values: {
        // Provide the necessary values for your livekit-recorder configuration
    },
    // Use the kubeconfig from the cluster we created.
    fetchOpts: { kubeconfig: kubeconfig },
},
{
    provider: new kubernetes.Provider("k8s-provider", { kubeconfig: kubeconfig }),
});

// Export any relevant outputs.
export const livekitRecorderEndpoint = recorderChart.getResourceProperty(
    "v1/Service", "livekit-recorder", "status"
);

```

#### Explanation of the Program

- A new DigitalOcean Kubernetes cluster named `livekit-cluster` is created in the New York 3 region (`nyc3`) with a specific Kubernetes version `1.21.5-do.0`. The node pool is configured with the `s-1vcpu-2gb` droplet size and contains 3 nodes. You can adjust the region, Kubernetes version, droplet size, and the number of nodes according to your requirements.

- The `kubeconfig` of the newly created cluster is exported so it can be used to deploy the `livekit-recorder` helm chart in the next step.

- Next, a [`kubernetes.helm.v3.Chart`](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/) resource named `livekit-recorder` is created. This will pull the `livekit-recorder` Helm chart (replace `chart: "livekit-recorder"` with the correct chart name if different) and deploy it to the cluster that was previously set up. You'll need to specify the appropriate values for the chart's customizable settings in the `values` object.

- A [`kubernetes.Provider`](https://www.pulumi.com/registry/packages/kubernetes/api-docs/provider/) with the exported kubeconfig is used to indicate that these resources should be deployed in the DigitalOcean Kubernetes cluster created above.

- Lastly, the program exports a potential endpoint of the `livekit-recorder` service. This example assumes that `livekit-recorder` is exposed via a Kubernetes service and that you would want to retrieve its status; the exported information may need to be adjusted based on the specifics of your Helm chart and what you wish to export.

#### Next Steps

After you've written this program, save it as `index.ts` in a Pulumi project directory. Run the following commands to deploy your infrastructure:

```bash
# Install the required Pulumi packages
npm install @pulumi/digitalocean @pulumi/kubernetes

# Preview the deployment
pulumi preview

# Deploy the infrastructure
pulumi up

# Once done, you can see the outputs by running
pulumi stack output
```

Make sure you have the necessary permissions on your DigitalOcean account to create Kubernetes clusters and manage resources, and that your Pulumi setup has the required credentials configured. The documentation linked throughout will help you understand each part of the program and customize it to your needs.