Deploy the tyk-oss helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the `tyk-oss` Helm chart on Google Kubernetes Engine (GKE) using Pulumi, you will go through the following steps:

1. **Set up a GKE cluster:** Configure a GKE cluster where you will deploy your Helm chart. This involves specifying the cluster properties such as node count, machine types, geographical zone, etc.

2. **Install the Helm chart:** Once you have the cluster set up, use Pulumi's Helm release resource to deploy the `tyk-oss` chart to your cluster.

Here is a complete Pulumi program in TypeScript that accomplishes these steps.

### Program Explanation

First, you'll need to set up a GKE cluster. We will use the `@pulumi/gcp` package to create a new GKE cluster. When initializing the `Cluster` resource, you can specify various properties, including the number of nodes in the default node pool, the machine type, and the zone where the cluster is deployed.

After setting up the cluster, you use Pulumi's Helm support provided by the Pulumi Kubernetes package (`@pulumi/kubernetes`) to install the Helm chart. The `Chart` resource points to the Helm chart of your choice and binds it to the created GKE cluster.

Make sure to have Pulumi and the necessary cloud provider CLI tools installed and configured properly on your local machine before running this code.

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

// Step 1: Create a GKE cluster.
const cluster = new gcp.container.Cluster("tyk-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1",
        oauthScopes: [
            "https://www.googleapis.com/auth/compute",
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring"
        ],
    },
    // Specify the geographical zone, e.g., us-central1-a. Change this according to your preference.
    location: "us-central1-a",
});

// Export the Cluster name
export const clusterName = cluster.name;

// Step 2: Create a Kubernetes provider instance that uses our GKE cluster.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Step 3: Deploy the tyk-oss Helm chart.
const tykOssChart = new k8s.helm.v3.Chart("tyk-oss", {
    chart: "tyk-headless",
    version: "0.9.1", // Specify the version of the chart you want to deploy
    fetchOpts: { 
        repo: "https://helm.tyk.io/public/helm/charts/", // The Helm repository where the tyk-oss chart is located
    },
}, { provider: k8sProvider });

// Export the status of the Helm deployment
export const helmStatus = tykOssChart.status;
```

### Understanding the Pulumi Resources

- `gcp.container.Cluster`: This resource is used to create and configure the Google Kubernetes Engine cluster where your application will be deployed.

- `k8s.Provider`: It creates a Pulumi Kubernetes provider that encapsulates the kubeconfig from the GKE cluster, which is necessary for deploying applications on the cluster.

- `k8s.helm.v3.Chart`: This resource manages a Helm chart's deployment using Pulumi. It includes your chart reference (`tyk-headless`), chart version, and the Helm repository where the chart is hosted.

### Running the Program

To run this Pulumi program, you need to have Node.js and Pulumi installed. Save the above code to a file called `index.ts` in a new Pulumi project directory. You can initialize a new project by running `pulumi new`.

After saving the file, run these commands:

```sh
pulumi up
```

The `pulumi up` command will prompt you to review and confirm the actions Pulumi will take on your behalf to stand up the Google Kubernetes Engine resources and deploy the `tyk-oss` helm chart.

### Next Steps

After successfully deploying, you can use `kubectl` to interact with your GKE cluster and the deployed services. For example, you may want to retrieve the `Service` endpoint to access the Tyk API Gateway.

Remember that Kubernetes and Helm documentation will be useful resources to understand the ways you can interact with and customize your deployments on GKE.