Deploy the tyk-dashboard helm chart on Kubernetes

Question

Pulumi · Accepted Answer

Deploying a Helm chart using Pulumi is straightforward. We will utilize Pulumi's Kubernetes provider to deploy the `tyk-dashboard` Helm chart on a Kubernetes cluster. To do this, we need to have a cluster where we will deploy the Helm chart.

For the purposes of this exercise, we'll assume you have a Kubernetes cluster already running and configured to be accessed by `kubectl`. Pulumi by default uses the Kubernetes configuration from the default location (`~/.kube/config`) or based on the environment variables set to access the Kubernetes cluster.

The `kubernetes.helm.v3.Chart` resource is what we will use to deploy the Helm chart. This resource allows you to manage Helm charts in a declarative way using Pulumi. It takes various inputs such as:
- `chart`: The name of the chart
- `version`: The version of the chart (optional, will install the latest if not specified)
- `fetchOpts`: Options to specify the Helm repository details like the repo URL (optional)
- `values`: Overrides for values in the chart's `values.yaml` (optional)
- `namespace`: The Kubernetes namespace to deploy into (optional, defaults to 'default')

You need to ensure you have the Pulumi CLI installed and you're logged into a Pulumi account. If you don't have a Pulumi account, you can use the Pulumi service backend for free, which allows you to manage your Pulumi state online.

Here's how you could deploy the `tyk-dashboard` Helm chart using Pulumi with TypeScript:

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

// Create a new Pulumi Kubernetes Chart resource that deploys the tyk-dashboard Helm chart.
const tykDashboardChart = new k8s.helm.v3.Chart("tyk-dashboard", {
    // Specify the chart name or path.
    chart: "tyk-dashboard",
    
    // Specify the namespace where the chart should be installed (optional).
    namespace: "tyk",
    
    // Define chart values, typically sourced from `values.yml` of the Helm chart.
    // This is where you can override default values of the chart. For example:
    values: {
        "mongodb": {
            "enabled": true
        },
        "redis": {
            "enabled": true
        }
    },

// If the chart is not part of the stable repository, specify the repository opts.
    // Assuming 'tyk-dashboard' is hosted at a custom Helm repo.
    fetchOpts: {
        repo: "https://helm.tyk.io/public/helm/charts/",
    },
});

// Export the name of the Chart
export const chartName = tykDashboardChart.metadata.name;
```

Explanation:

- We import the Kubernetes package from Pulumi which provides the necessary classes.
- We then create a new Helm Chart resource named `tyk-dashboard`.
- The `chart` property specifies the name of the Helm chart we wish to deploy.
- The `namespace` indicates the deployment namespace. If not provided, it defaults to `default`.
- In the `values` property, you can override any of the default values provided in the chart's `values.yaml` file. Here, an example is provided to enable MongoDB and Redis which are typical dependencies of Tyk Dashboard.
- The `fetchOpts` specify where Pulumi can fetch the Helm chart from if it's not part of the default Helm repository. The `repo` option should point to the URL of the Tyk Helm charts repository.

This program will deploy the `tyk-dashboard` chart to the Kubernetes cluster configured in your kubeconfig file.

Make sure you've selected the right Pulumi project and stack. If you’re running the above code snippet, it will create resources based on the active Pulumi stack’s configuration.
To deploy the chart, just run `pulumi up` from your command line, in the directory where this code is saved.

After deployment, Pulumi will show a summary of the resources created in your cluster.

Please replace the repo URL, values, or chart version to match the specific details of the helm chart you're deploying. If the chart requires additional configuration, adjust the `values` block accordingly.

Remember that you should have appropriate permissions in the Kubernetes cluster to create resources. If you run into any permission issues, you may have to adjust your cluster's RBAC settings.