Deploy the tyk-oss helm chart on Linode Kubernetes Engine

Question

Pulumi · Accepted Answer

To deploy the Tyk Open Source Software (OSS) Helm chart on the Linode Kubernetes Engine (LKE), you'll need to follow these steps:

1. Set up a Kubernetes cluster on Linode.
2. Install and initialize Helm on your local machine.
3. Add the Tyk Helm repository to your Helm configuration.
4. Deploy the Tyk OSS Helm chart onto your LKE cluster.

In the following Pulumi program, we'll define the necessary resources to accomplish these tasks using Pulumi's TypeScript SDK. The program assumes you have already [configured Pulumi for Linode](https://www.pulumi.com/registry/packages/linode/installation-configuration/) and have the necessary credentials set up.

First, you will need to install the necessary Pulumi packages for Linode and Kubernetes:

```bash
pulumi plugin install resource linode v${VERSION}
pulumi plugin install resource kubernetes v${VERSION}
```

Replace `${VERSION}` with the appropriate version numbers.

Now, here's the TypeScript Pulumi program that will perform the deployment:

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

// Create a Linode Kubernetes cluster.
const cluster = new linode.LkeCluster('tyk-cluster', {
    k8sVersion: '1.20', // Specify your desired Kubernetes version
    region: 'us-central', // Specify your desired Linode region
    tags: ['tyk-lke'],
    pools: [{
        count: 3, // Specify the number of nodes (Linode VMs)
        type: 'g6-standard-2', // Specify the type of node
    }],
});

// Export the kubeconfig of the cluster.
export const kubeconfig = cluster.kubeconfig;

// Create a Kubernetes provider instance using the kubeconfig from the Linode Kubernetes cluster.
const k8sProvider = new kubernetes.Provider('lke-k8s-provider', {
    kubeconfig: cluster.kubeconfig,
});

// Add the Tyk Helm chart repository.
const tykHelmRepo = new kubernetes.helm.v3.Repository('tyk-helm-repo', {
    name: 'tyk-helm-repo',
    url: 'https://helm.tyk.io/public/helm/charts/', // Official Tyk Helm repository
}, { provider: k8sProvider });

// Install the Tyk OSS Helm chart.
const tykChart = new kubernetes.helm.v3.Chart('tyk-oss', {
    chart: 'tyk-headless',
    version: '0.9.1', // Specify the version of the Tyk OSS Helm chart
    fetchOpts: {
        repo: tykHelmRepo.url,
    },
    values: {
        redis: {
            // You might need to set up Redis or use an existing one, please adjust accordingly.
            // If you want to use an in-cluster installation, you can set up Redis by setting
            // 'redis.install: true' or deploy a separate Helm chart for Redis.
            install: true,
        },
        gateway: {
            // Configuration options for Tyk gateway
        },
        dashboard: {
            // Configuration options for Tyk dashboard
        },
    },
}, { provider: k8sProvider });

// Export the Tyk Gateway service endpoint.
export const tykGatewayEndpoint = tykChart.getResourceProperty('v1/Service', 'tyk-oss-tyk-gateway', 'status').apply(status => status.loadBalancer.ingress[0].ip);
```

Let's break this down:

- We're importing Pulumi's libraries for Linode, Kubernetes, and the core Pulumi functionalities.
- Using `linode.LkeCluster`, we're creating a cluster with 3 nodes. Adjust the version, region, and node specifications according to your needs.
- The `lkeKubeconfig` exports the kubeconfig of the newly created LKE cluster. This is essential for managing the cluster with kubectl or a Kubernetes Pulumi provider.
- The `kubernetes.Provider` resource is used to communicate with the Linode Kubernetes cluster. You pass the kubeconfig of the LKE cluster to this provider.
- The `kubernetes.helm.v3.Repository` resource adds the Tyk Helm repo. This enables Helm to locate the Tyk chart.
- The `kubernetes.helm.v3.Chart` resource is the heart of the deployment. It defines the release of the Tyk OSS on the LKE cluster. You can customize the `values` based on Tyk's configuration options.
- Lastly, we export `tykGatewayEndpoint`, which would give you the IP address of the Tyk API Gateway once deployed and accessible publicly.

Please adjust the deployments details such as Kubernetes version, region, node count, and types to match your requirements and the resources available on your Linode account. You will also need to customize the Redis setup for Tyk Gateway as per your use case. If you wish to deploy Redis within the cluster, set `redis.install` to `true` in the chart values, or you can deploy Redis separately.

After the Pulumi program completes, you'll get the endpoint to access Tyk Gateway. Keep in mind that exposing services to the public might require additional configuration like setting up an Ingress controller or configuring load balancer services.

Remember to enter the appropriate Helm chart version for Tyk OSS in place of `0.9.1` if using a different version.

To run this program, simply execute:
```bash
pulumi up
```
This will provision the resources defined in your program in your Linode account.