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

Question

Pulumi · Accepted Answer

To deploy the `typo3scan` Helm chart on Google Kubernetes Engine (GKE), you will first need to set up a GKE cluster and then use Pulumi's Helm Release resource to deploy the chart to that cluster. Below is a step-by-step guide and a corresponding Pulumi program written in TypeScript to accomplish this.

### Step 1: Set up a GKE Cluster
First, you need to create a GKE cluster. The `google-native.container/v1.Cluster` resource will be used to create the cluster in GKE. This cluster will be the Kubernetes environment where your Helm chart will be deployed.

### Step 2: Deploy the Helm Chart
Once the GKE cluster is up and running, you can deploy the `typo3scan` Helm chart using the `harness.service.Helm` resource. The Helm release will require the name of the chart and, optionally, any overrides you wish to provide to the default chart values.

Now, let's put that into a Pulumi program:

```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("typo3scan-cluster", {
    // Define required properties for the GKE cluster here
    // For brevity, just specifying the minimal configuration, you can specify more options as necessary
    initialNodeCount: 2,
    minMasterVersion: "latest", // replace with an exact version if required
});

// Export the Cluster name and 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[0].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`;
    });

const kubeProvider = new k8s.Provider("kubeProvider", {
    kubeconfig: kubeconfig,
});

// Step 2: Deploy the typo3scan Helm chart to the GKE cluster
const chart = new k8s.helm.v3.Chart("typo3scan-chart", {
    chart: "typo3scan",
    fetchOpts:{
        repo: "http://helm-repository/url/", // Replace with typo3scan Helm chart repository URL
    },
    // Specify the values.yaml configuration by using the 'values' property if needed
}, { provider: kubeProvider });

// Export the Chart name
export const chartName = chart.id;
```

This program does the following:
- It creates a GKE cluster with 2 nodes and the latest available version of Kubernetes.
- It exports the `kubeconfig` that is needed to communicate with your GKE cluster.
- It sets up a Pulumi Kubernetes provider that uses the generated `kubeconfig`.
- It deploys the `typo3scan` Helm chart to the GKE cluster using the Pulumi Kubernetes provider.

Now let’s go through the code and understand how to use these resources:

1. **GKE Cluster**: This is created using the `gcp.container.Cluster` class, where you need to define the properties of the cluster such as the number of nodes, Kubernetes version, etc.

2. **Kubeconfig**: This is essential for Pulumi to interact with your Kubernetes cluster. The `kubeconfig` is generated using the details of the created GKE cluster and is later used to configure the Kubernetes provider for Pulumi.

3. **Helm Chart**: This is created using the `k8s.helm.v3.Chart` class. You need to provide the name of the chart and optionally you could include the repository if `typo3scan` is in a custom Helm repository. You may also specify the `values` property to override the default chart values.

Make sure you replace `http://helm-repository/url/` with the actual repository URL hosting the `typo3scan` chart.

Remember that to execute this Pulumi program you'll need to have Pulumi installed, along with the necessary GCP and Kubernetes Pulumi packages. You will also need to have `gcloud` installed and authorized to access your GCP account since the kubeconfig relies on `gcloud` to generate access tokens.

Once the program is executed successfully, your GKE cluster will be up and running with the `typo3scan` Helm chart deployed. You can verify the deployment using `kubectl` or by checking the resources in your GCP console.