Deploy the workadventure helm chart on Google Kubernetes Engine (GKE)

Question

Pulumi · Accepted Answer

To deploy the WorkAdventure Helm chart on Google Kubernetes Engine (GKE), we are going to take the following steps:

1. **Set up a GKE Cluster**: This involves creating a GKE cluster where our Kubernetes workloads will run. We'll define the necessary configurations for the cluster, such as the machine type and the number of nodes.

2. **Install the Helm Chart**: Helm is a package manager for Kubernetes, which allows us to easily deploy applications using pre-packaged sets of resources. We'll use the `kubernetes.helm.v3.Release` resource which represents a Helm chart that can be deployed into a Kubernetes cluster.

Here's a high-level overview of what the Pulumi TypeScript code will look like:

- Import the necessary modules from `@pulumi/gcp`, `@pulumi/kubernetes`, and `@pulumi/pulumi`.
- Define a GKE cluster by using the `google-native.container/v1beta1.Cluster` resource.
- Use the `kubernetes.Provider` resource to configure Pulumi's Kubernetes provider to point to the created GKE cluster.
- Deploy the WorkAdventure Helm chart by creating an instance of the `kubernetes.helm.v3.Release` resource.

Let's dive into the code, which will set up your GKE cluster and deploy WorkAdventure as a Helm chart.

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("workadventure-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // This is a reasonable default, but can be changed based on needs
        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;

// Create a Kubernetes Provider pointing to the created GKE cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.endpoint.apply(endpoint => {
        return pulumi
            .all([cluster.name, cluster.endpoint, cluster.masterAuth])
            .apply(([name, endpoint, auth]) => {
                const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
                return `
apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${auth.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}'
`;
            });
    }),
});

// Deploy the WorkAdventure Helm chart into the GKE cluster
const workadventureChart = new k8s.helm.v3.Chart("workadventure-chart", {
    chart: "workadventure",
    fetchOpts:{
        repo: "https://helm.workadventu.re/"
    },
}, { provider: k8sProvider });

// Export the Helm chart name 
export const workadventureChartName = workadventureChart.name;
```

This code does the following:

- Creates a GKE cluster with a specific machine type and oauthScopes. The scopes allow the cluster's nodes access to necessary GCP services like compute, storage, logging, and monitoring.
- It exports the name of the cluster, which can be useful for reference in other parts of your infrastructure or CI/CD pipelines.
- It sets up a Pulumi Kubernetes Provider and configures it with the kubeconfig generated from the GKE cluster's attributes.
- It declares the WorkAdventure Helm chart, defining the chart to be pulled from WorkAdventure's Helm repository and deployed to our GKE cluster through the configured Kubernetes Provider.
- Finally, it exports the deployed Helm chart's name for reference.

Make sure you have Pulumi installed, are authenticated with both Pulumi and GCP, and have the GCP project and zone configured in your Pulumi stack settings before running this code. Once you meet these requirements, you can proceed with running the `pulumi up` command to deploy your GKE cluster and WorkAdventure Helm chart.

This setup can be fine-tuned as per your requirements, for example, by adjusting the machine type for the nodes, or by specifying additional Helm chart values in the `values` property for the `workadventureChart`.