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

Question

Pulumi · Accepted Answer

To deploy the LibreTime Helm chart on Google Kubernetes Engine (GKE), we will go through several steps:

1. **Create a GKE Cluster**: We would need to set up a Kubernetes cluster on GKE where the Helm chart will be deployed. We will create the cluster with an appropriate configuration for your workload.

2. **Install the Helm CLI**: Helm is used to manage Kubernetes applications, and Helm Charts help define, install, and upgrade even the most complex Kubernetes application. You will need Helm installed in your environment to manage the deployment.

3. **Deploy the LibreTime Chart**: Once Helm is set up and the GKE cluster is ready, we can deploy the Helm chart to the cluster.

In the provided TypeScript program, we will address the first step, as the remaining steps are usually performed outside of Pulumi and on the machine where Helm is installed. These steps involve running command-line tools like `helm` to interact with the cluster.

Below is the TypeScript program which defines the necessary resources using the Pulumi Google Cloud (GCP) provider to create a GKE cluster. I will explain each part of the program with comments:

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

// Create a GKE cluster
const cluster = new gcp.container.Cluster("libretime-cluster", {
    initialNodeCount: 2,
    minMasterVersion: "latest",
    nodeVersion: "latest",
    nodeConfig: {
        preemptible: true, // Use preemptible VMs to save costs
        machineType: "e2-medium", // Adjust the machine type as necessary
        oauthScopes: [
            "https://www.googleapis.com/auth/devstorage.read_only",
            "https://www.googleapis.com/auth/logging.write",
            "https://www.googleapis.com/auth/monitoring",
            "https://www.googleapis.com/auth/service.management.readonly",
            "https://www.googleapis.com/auth/servicecontrol",
            "https://www.googleapis.com/auth/trace.append",
        ],
    },
    resourceLabels: {
        "project": "libretime-project",
    },
});

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

// Export the Cluster kubeconfig to connect to the cluster with kubectl
export const kubeconfig = cluster.name.apply(name => {
    const cluster = gcp.container.getCluster({
        name: name,
        // Replace with the appropriate zone/region if your cluster is provisioned elsewhere
        location: "us-central1",
    });

return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${cluster.masterAuth[0].clusterCaCertificate}
    server: https://${cluster.endpoint}
  name: ${cluster.name}
contexts:
- context:
    cluster: ${cluster.name}
    user: ${cluster.name}
  name: ${cluster.name}
current-context: ${cluster.name}
kind: Config
preferences: {}
users:
- name: ${cluster.name}
  user:
    auth-provider:
    config:
      access-token: ${cluster.masterAuth[0].token}
      cmd-args: config config-helper --format=json
      cmd-path: gcloud
      expiry-key: '{.credential.token_expiry}'
      token-key: '{.credential.access_token}'
    name: gcp`;
});

// Kubernetes provider to deploy Helm charts on the created GKE cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Output the kubeconfig to a file
// Replace 'my-kubeconfig.yaml' with the desired output file name
new k8s.yaml.ConfigFile("kubeconfig-file", {
    content: kubeconfig,
}, { provider: k8sProvider });

// Provide instructions on what to do next
console.log("Cluster created. To deploy the LibreTime Helm chart, ensure you have Helm installed.");
console.log("Then, use the output kubeconfig to configure your kubectl and Helm CLI.");
console.log("You can then use `helm install` to deploy LibreTime to your GKE cluster.");
```

This program sets up a new GKE cluster. We export the kubeconfig which you can use with `kubectl` to interact with your cluster. The kubeconfig is also necessary for Helm.

**After running this Pulumi program to create your cluster, you would:**

1. **Install `kubectl`**: This tool allows you to run commands against Kubernetes clusters. You can use it to deploy applications, inspect and manage cluster resources, and view logs.

2. **Set up Helm**: Follow the [Helm install instructions](https://helm.sh/docs/intro/install/) to set it up on your machine.

3. **Use the exported kubeconfig**: Configure kubectl and Helm using the kubeconfig (by setting the `KUBECONFIG` environment variable or by merging it with your existing kubeconfig).

4. **Deploy LibreTime**:
   - Add the Helm chart repository that contains LibreTime, if any, or provide the path to the chart.
   - Use `helm install` to deploy it, specifying the chart name and any relevant values.

Remember that while this Pulumi program automates the infrastructure setup on GCP, it does not automate the Helm chart deployment. The steps for using Helm and deploying your application should be done through the Helm CLI directly.