Deploy the pinot helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the Pinot Helm chart on the Digital Ocean Kubernetes service, you'll need to do the following steps:

1. Create a Kubernetes cluster on Digital Ocean.
2. Deploy the Pinot Helm chart to the Kubernetes cluster.

We'll use two main Pulumi resources for this: `digitalocean.KubernetesCluster` to create the cluster and `kubernetes.helm.sh/v3.Chart` to deploy the Helm chart.

Here's a step-by-step guide on how to write a Pulumi program in TypeScript to accomplish this:

### Step 1: Set up the Pulumi project and stack
To begin, you must have Pulumi installed and set up on your machine along with Node.js. Create a new directory for your Pulumi project and initialize a new project:

```shell
mkdir pulumi-pinot-deployment
cd pulumi-pinot-deployment
pulumi new typescript
```

### Step 2: Define the Digital Ocean Kubernetes cluster
In your Pulumi project, you need to define the infrastructure which includes the Digital Ocean Kubernetes cluster. The Pulumi resource `digitalocean.KubernetesCluster` is used to create a new cluster.

### Step 3: Deploy the Helm chart
After the cluster is created, you can then deploy the Pinot Helm chart using the `kubernetes.helm.sh/v3.Chart` resource. You'll first need to set up the Pulumi Kubernetes provider to point to the newly created Digital Ocean cluster.

Below is the complete Pulumi program in TypeScript that accomplishes both steps:

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

// Step 1: Create a Kubernetes cluster on Digital Ocean.
const cluster = new digitalocean.KubernetesCluster("pinot-cluster", {
    // Define the region where you want your cluster to be created.
    region: "nyc3",
    // Define the version of Kubernetes to use.
    version: "1.21.5-do.0",
    // Specify the node pool configuration of your cluster.
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb", // Adjust the size according to your needs.
        nodeCount: 2,        // The number of nodes in the pool.
    },
});

// Step 2: Use the kubeconfig from the generated cluster to create a new Pulumi Kubernetes provider.
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Step 3: Deploy the Pinot Helm chart.
const pinotChart = new k8s.helm.v3.Chart("pinot", {
    chart: "pinot",
    version: "0.1.0", // Specify the version of the Pinot chart you want to deploy.
    fetchOpts:{
        repo: "https://helm.pinot.apache.org/", // URL to the Helm repository containing the Pinot chart.
    },
}, { provider: k8sProvider });

// Export the cluster's kubeconfig and Pinot service endpoint.
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
export const pinotEndpoint = pinotChart.getResourceProperty("v1/Service", "pinot-controller", "status");
```

### Using the Program
Replace the placeholders and configurations like `region`, `version`, `size`, and `nodeCount` as per your requirement. The designated `repo` should be the official Pinot Helm chart repository or wherever the Pinot chart is hosted.

Save the file, run `pulumi up`, and the program will provision the resources. You can monitor the output for any errors, and if the deployment is successful, you'll see the endpoints exported at the end of the Pulumi run. This is the HTTP endpoint that you can use to access your Pinot installation.