Deploy the tyk-dashboard helm chart on AWS EKS

Question

Pulumi · Accepted Answer

To deploy the Tyk Dashboard using a Helm chart on an AWS EKS cluster with Pulumi, we'll need to accomplish the following steps:

1. Provision an Amazon EKS cluster.
2. Deploy the Tyk Dashboard Helm chart to the EKS cluster.

Let's walk through the process:

### Step 1: Provision an Amazon EKS Cluster
First, we'll use the `eks.Cluster` component from Pulumi's EKS package to easily provision a new EKS cluster. This high-level component creates and manages the necessary resources, such as the EKS cluster itself and the supporting compute infrastructure.

### Step 2: Deploy Tyk Dashboard
Once we have our EKS cluster ready, we can use the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes package to deploy the Tyk Dashboard Helm chart. The `Chart` resource allows us to deploy packaged applications to Kubernetes.

Here's the TypeScript program for deploying the Tyk Dashboard to an EKS cluster:

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

// Step 1: Create an EKS cluster
const cluster = new eks.Cluster('my-cluster', {
    // Define your cluster settings here...
    // For example, you can specify the number of nodes, node type, etc.
});

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

// Step 2: Deploy Tyk Dashboard Helm chart
const tykDashboardChart = new k8s.helm.v3.Chart('tyk-dashboard', {
    chart: 'tyk-dashboard',
    version: 'x.y.z', // specify the exact chart version
    fetchOpts: {
        repo: 'https://helm.tyk.io/public/helm/charts/', // depending on the actual Helm repository
    },
    // Define values for the chart as needed
    values: {
        // For example, set the service type to LoadBalancer for external access
        service: {
            type: 'LoadBalancer',
        },
        // Include any other necessary configurations here
    },
}, { provider: cluster.provider });

// Export the Tyk Dashboard URL (Ensure the LoadBalancer is fully provisioned before accessing)
export const tykDashboardUrl = tykDashboardChart.getResourceProperty(
    'v1/Service', 'tyk-dashboard-tyk-dashboard', 'status'
).apply(status => `http://${status.loadBalancer.ingress[0].hostname}`);

// Run `pulumi up` to deploy the stack.
// Access your Tyk Dashboard using the URL provided after deployment.
```

In this program:
- We create an EKS cluster using the `eks.Cluster` component, which is a high-level abstraction that encapsulates the details of provisioning an EKS cluster.
- We then deploy the Tyk Dashboard using the `kubernetes.helm.v3.Chart` resource, specifying the particular chart version and repository URL.
- The service type is set to `LoadBalancer` to expose the Tyk Dashboard externally. Modify the values based on the actual configuration you may need for your deployment.
- We `export` the cluster kubeconfig for use by `kubectl` and other tooling outside of Pulumi.
- We also `export` a URL which will be populated once the Tyk Dashboard is accessible. This is retrieved dynamically by querying the status of the deployed `Service`.

Remember to replace `x.y.z` with the actual chart version you want to deploy. You may also need to adjust the values to match your exact requirements, such as domain name, persistence settings, etc.

Please note that, due to DNS propagation and LoadBalancer provisioning times, the URL may not be immediately accessible after the deployment finishes.

Before running `pulumi up` with the above program, ensure you have Pulumi installed and configured to access your AWS account. Please refer to the [EKS documentation](https://www.pulumi.com/registry/packages/eks/api-docs/cluster/) and [Kubernetes Helm documentation](https://www.pulumi.com/registry/packages/kubernetes/api-docs/helm/v3/chart/) for detailed information on the resources utilized here.