Deploy the tyk-data-plane helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `tyk-data-plane` Helm chart on the Digital Ocean Kubernetes Service (DOKS) using Pulumi, you will first need to create a Kubernetes cluster in Digital Ocean. Once the cluster is set up, you will use the Pulumi Kubernetes provider to deploy the `tyk-data-plane` chart from Helm.

Pulumi manages infrastructure through code, which makes it possible to define, deploy, and manage cloud services through familiar programming languages. In this case, we’ll use TypeScript.

Here’s a step-by-step guide through the process:

1. **Set up a Kubernetes Cluster on Digital Ocean**: We'll create a Kubernetes cluster using the `digitalocean.KubernetesCluster` resource. Make sure to replace the placeholder values, like `name`, `region`, `version`, and `nodePool` configuration with appropriate values for your use case.

2. **Install the Tyk Data Plane Helm Chart**: We'll deploy the `tyk-data-plane` Helm chart onto the DOKS using the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider. Helm will manage the complexity of deploying the different Kubernetes resources needed by Tyk.

To begin, let's assume you have the Pulumi CLI installed and configured for use with DigitalOcean. If you don’t have a Pulumi account yet, you’ll need to sign up and [install Pulumi](https://www.pulumi.com/docs/get-started/) first. You also need to have the [Digital Ocean CLI (doctl)](https://docs.digitalocean.com/reference/doctl/how-to/install/) installed and configured.

Now, let me walk you through the Pulumi program that accomplishes this:

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

// Step 1: Create a new Digital Ocean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster('tyk-cluster', {
    region: 'nyc1',
    version: 'latest', // Replace with the desired version
    nodePool: {
        name: 'default',
        size: 's-2vcpu-2gb',
        nodeCount: 2, // Specify the number of nodes
    },
});

// Step 2: Deploy tyk-data-plane Helm chart on Digital Ocean Kubernetes Service
const tykDataPlaneChart = new kubernetes.helm.v3.Chart('tyk-data-plane', {
    chart: 'tyk-headless',
    version: '0.9.0', // Replace with the desired chart version
    fetchOpts: { repo: 'https://helm.tyk.io/public/helm/charts' },
    namespace: "tyk",
    // Values from: https://github.com/TykTechnologies/tyk-helm-chart/tree/master/tyk-headless
    // Set custom values for the Helm chart as needed.
    values: {
        mongodb: {
            enabled: false,
        },
        // Set additional custom values for your Tyk deployment.
    },
}, { provider: new kubernetes.Provider('k8s', { kubeconfig: cluster.kubeConfigs[0].rawConfig }) });

// Export the public IP to access the Tyk dashboard
export const clusterEndpoint = cluster.endpoint;
export const clusterKubeconfig = cluster.kubeConfigs[0].rawConfig;

// Wait for the chart to be deployed before finishing.
export const chartDeployment = tykDataPlaneChart.status;
```

This is what happens in the above TypeScript code:

- We import the necessary Pulumi libraries for DigitalOcean and Kubernetes.
- We create a Kubernetes cluster in DigitalOcean with the desired specifications.
- We use the `Chart` resource to deploy the `tyk-data-plane` chart from the specified Helm repo on the previously created cluster. We also specify the chart version.
- We export the cluster's endpoint and raw kubeconfig so that you can connect to it using `kubectl` or other Kubernetes tools.
- We wait for the Helm chart deployment to complete by exporting its status.

Make sure to save this code in a file named `index.ts` and run `pulumi up` to deploy the infrastructure. After the command completes successfully, Pulumi will output the endpoints and other details that you can use to interact with the running instances.