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

Question

Pulumi · Accepted Answer

To deploy the Tyk Stack using Helm on Google Kubernetes Engine (GKE), you'll first need to set up a GKE cluster. Once the cluster is set up and configured, you can install the Tyk Stack using a Helm chart. Here is a step-by-step guide to accomplish this:

### Step 1: Define the GKE Cluster
The `gcp.container.Cluster` resource in Pulumi allows you to set up a GKE cluster. This resource includes various configuration options such as the cluster name, the network to use, the initial node count, and more.

### Step 2: Install Helm and the Tyk Stack
The `harness.service.Helm` resource is used to deploy applications using Helm on Kubernetes. You will use this resource to deploy the Tyk Stack Helm chart to your GKE cluster.

Below is the TypeScript program which performs these steps using Pulumi. This program assumes you have Pulumi installed and configured for use with GCP.

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster('gke-cluster', {
  // Define the initial node count for the GKE cluster
  initialNodeCount: 1,

// Define the node configuration
  nodeConfig: {
    machineType: 'n1-standard-1', // Define the machine type, e.g., 'n1-standard-1'
  },
});

// Export the Kubeconfig
export const kubeConfig = pulumi.all([cluster.name, cluster.endpoint, cluster.masterAuth]).apply(([name, endpoint, masterAuth]) => {
  const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
  return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${masterAuth.clusterCaCertificate}
    server: https://${endpoint}
  name: ${context}
contexts:
- context:
    cluster: ${context}
    user: ${context}
  name: ${context}
current-context: ${context}
kind: Config
preferences: {}
users:
- name: ${context}
  user:
    auth-provider:
      config:
        cmd-args: config config-helper --format=json
        cmd-path: gcloud
        expiry-key: '{.credential.token_expiry}'
        token-key: '{.credential.access_token}'
      name: gcp
`;
});

// Initialize the K8s provider using the generated Kubeconfig
const k8sProvider = new k8s.Provider('k8s', {
  kubeconfig: kubeConfig,
});

// Deploy the Tyk Stack using the Helm chart
const tykStack = new k8s.helm.v3.Chart('tyk-stack', {
  chart: 'tyk-headless',                    // Name of the Helm chart for Tyk Stack
  version: '0.6.0',                          // Specific version of the Helm chart
  fetchOpts:{
    repo: 'https://helm.tyk.io/public/helm/charts', // Tyk Helm repo URL
  },
}, { provider: k8sProvider });

// Export the Tyk Stack front-end service endpoint
export const tykStackServiceEndpoint = tykStack.getResourceProperty('v1/Service', 'tyk-headless-gateway', 'status').apply(status => status.loadBalancer.ingress[0].ip);
```

Let's break down what each part of this code does:

- We are setting up a new GKE cluster using the `gcp.container.Cluster` resource. Here we specify the number of nodes and the machine type for each node.
  
- We export the `kubeConfig`, which is used by the Pulumi Kubernetes provider to interact with your GKE cluster.
  
- We initialize the Kubernetes provider `k8s.Provider` with the `kubeConfig`.
  
- Finally, we use the `k8s.helm.v3.Chart` resource to deploy the Tyk Stack Helm chart. We specify the chart name, version and the repository where the chart is located.

- We export the Tyk Stack Gateway Service endpoint using `tykStack.getResourceProperty`, which can be used to interact with the Tyk API Gateway.
  
To run this program:

1. Save the code to a file with a `.ts` extension, for example, `deploy-tyk-stack-gke.ts`.

2. Set up GCP credentials locally, if you haven't done so already.

3. Run `pulumi up` to preview and deploy the changes.
   
After the deployment completes, you will see the endpoint output that you can use to access the Tyk API Gateway running on your GKE cluster.