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

Question

Pulumi · Accepted Answer

To deploy the Tyk Developer Portal using a Helm chart on Google Kubernetes Engine (GKE), we'll follow these steps:

1. Create a GKE cluster.
2. Install and initialize Helm on the local machine (if not already done).
3. Add the Tyk Helm repository.
4. Configure and deploy the Tyk Developer Portal Helm chart.

For a novice, it's important to understand that Google Kubernetes Engine (GKE) provides a managed environment for deploying, managing, and scaling containerized applications using Google infrastructure. Tyk is an open-source API Gateway and Management Platform, and Helm is a package manager for Kubernetes that allows you to define, install, and upgrade even the most complex Kubernetes applications.

Below is a Pulumi program in TypeScript that creates a GKE cluster and deploys the Tyk Developer Portal Helm chart to it. Please note that before running this program, you should have Pulumi installed, a Pulumi account set up, the Pulumi CLI configured with your Google Cloud credentials, and Helm installed on your local machine.

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

const name = "tyk-dev-portal";

// Create a GKE cluster
const cluster = new gcp.container.Cluster(name, {
    // Define required properties for your GKE cluster here
    initialNodeCount: 2,
    minMasterVersion: "latest", // Use an appropriate version
    nodeVersion: "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"
        ],
    },
});

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

// Export the Kubeconfig so we can access the cluster with kubectl
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
`;
    });

// Create a Kubernetes provider instance that uses our cluster from above.
const clusterProvider = new kubernetes.Provider(name, {
  kubeconfig: kubeconfig,
});

// Add the Tyk helm repository
const tykHelmRepo = new kubernetes.yaml.ConfigGroup("tyk-helm-repo", {
    yaml: [
        `apiVersion: v1
kind: Pod
metadata:
  name: helm-repoinit
  annotations:
    "helm.sh/hook": post-install
spec:
  containers:
  - name: helm
    image: "alpine/helm:3.2.4"
    command: ["/bin/sh", "-c"]
    args: ["helm repo add tyk https://helm.tyk.io/public/helm/charts/ && helm repo update"]
  restartPolicy: OnFailure`,
    ],
}, { provider: clusterProvider });

// Deploy the Tyk Developer Portal using the Helm Chart
const tykDevPortal = new kubernetes.helm.v3.Chart("tyk-dev-portal", {
    chart: "tyk-headless",
    version: "0.5.0", // Use the latest chart version
    fetchOpts:{
        repo: "https://helm.tyk.io/public/helm/charts/",
    },
    // Configure the Helm chart values here as needed
    values: {
        portal: true,
        dashboard: {
            enabled: true,
        },
        gateway: {
            enabled: false,
        },
    },
}, { provider: clusterProvider });

// Export the service endpoint of the Tyk Developer Portal
export const tykDevPortalService = tykDevPortal.getResourceProperty("v1/Service", name, "status");
```

This program defines resources and steps to do the following:

- Define a new GKE cluster with the required configuration.
- Generate the Kubeconfig needed to interact with the GKE cluster.
- Set up a Kubernetes provider which specifies the Kubernetes cluster that Pulumi will communicate with.
- Add the Tyk Helm repository using a Kubernetes `ConfigGroup` which ensures that Helm is configured with the Tyk repository after the cluster is created.
- Deploy the Tyk Developer Portal Helm chart to the GKE cluster using Pulumi's Helm support.

Remember to replace placeholders such as versions with appropriate values for your use case. Once the cluster is set up and the application is deployed, the `kubeconfig` and service endpoint are exported. These can be used to interact with the cluster and access the Tyk Developer Portal.

It's essential to ensure that all Helm chart values in the `values` field match your desired configuration for the Tyk Developer Portal. Please refer to the [official Tyk Helm chart documentation](https://github.com/TykTechnologies/tyk-helm-chart) for all configurable options.

To deploy this application, you would run the following commands in your terminal:

```sh
pulumi up
```

This command will start the deployment process managed by Pulumi. You'll be able to track the progress and see a summary of the resources being created. After confirming the deployment, Pulumi will provision the GKE cluster and deploy the Tyk Developer Portal via the Helm chart.