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

Question

Pulumi · Accepted Answer

Deploying the Pocketbase Helm chart on Google Kubernetes Engine (GKE) involves several steps that include setting up a GKE cluster as the Kubernetes environment, and then installing the Pocketbase application using Helm.

Here is what you'll need to do:

1. Create a GKE cluster using the `@pulumi/gcp` package.
2. Use the `@pulumi/kubernetes` package to deploy the Pocketbase Helm chart on the cluster you created.

In the program below, we will first use Pulumi to spin up a new GKE cluster. Then, we will configure Kubernetes to connect to this new cluster. Finally, we will deploy Pocketbase using the 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("pocketbase-cluster", {
    initialNodeCount: 2,        // The initial number of nodes in the cluster
    minMasterVersion: "latest", // Use the latest GKE version available
    nodeVersion: "latest",
    nodeConfig: {
        // Configure the node machine types and the Google cloud services scopes
        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
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 using the Kubeconfig from the GKE cluster
const k8sProvider = new k8s.Provider("pocketbase-k8s-provider", {
    kubeconfig: kubeconfig
});

// Deploy Pocketbase using the Helm chart
const pocketbaseChart = new k8s.helm.v3.Chart("pocketbase-helm-chart", {
    chart: "pocketbase",
    version: "0.1.0", // Replace with the actual chart version
    fetchOpts:{
        repo: "http://helm-repo-url", // Replace with the actual Helm repo URL
    },
}, { provider: k8sProvider });

// Export the Pocketbase Service endpoint
export const pocketbaseService = pocketbaseChart.getResource("v1/Service", "pocketbase");

```

Let me explain the code:

1. **GKE Cluster Creation**: We define a new GKE cluster using the `@pulumi/gcp` package. We specify the initial number of nodes, machine type, and required permissions.

2. **Cluster Credentials (Kubeconfig)**: We then export the kubeconfig, which is needed by kubectl and the Pulumi Kubernetes provider to interact with your cluster.

3. **Kubernetes Provider Setup**: We create a new Kubernetes provider, configuring it to use the kubeconfig we generated in the previous step.

4. **Deploying Pocketbase using Helm**: Finally, we use the `@pulumi/kubernetes` package to define a Helm chart resource pointing to the Pocketbase chart alongside its version and repository URL. We associate this deployment with the provider we set up in the previous step, which will inform Pulumi where to deploy the chart (i.e., on our GKE cluster).

Replace `"http://helm-repo-url"` with the actual repository URL where the Pocketbase Helm chart is hosted, and `"0.1.0"` with the Pocketbase chart version that you want to deploy.

After setting up this code in a TypeScript file (`index.ts`) in a Pulumi project, you would run it with the following commands:

```bash
pulumi up
```

This will prompt you to preview the deployment and, upon approval, will create the resources in GCP and deploy Pocketbase there. The outputs of the script will provide you with the necessary information to access your GKE cluster and the Pocketbase service.