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

Question

Pulumi · Accepted Answer

To deploy the Quickwit Helm chart on Google Kubernetes Engine (GKE), we will follow these steps:

1. Set up a GKE cluster using Pulumi's GCP provider.
2. Once the cluster is running, we will configure Pulumi to use the cluster's kubeconfig so that we can deploy Kubernetes resources into it.
3. Then, we'll use the Pulumi Kubernetes provider to deploy the Quickwit Helm chart into our GKE cluster.

For this, we need to use two Pulumi providers: `gcp` to create and manage the GKE cluster and `kubernetes` to deploy the Helm chart.

Below is the Pulumi program written in TypeScript that accomplishes the goal:

```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("quickwit-cluster", {
    initialNodeCount: 1,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // Change to the desired machine type
        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 Kubeconfig so that 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 using the GKE cluster defined above
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: kubeconfig,
});

// Deploy the Quickwit Helm chart into the GKE cluster
const quickwitRelease = new k8s.helm.v3.Chart("quickwit", {
    chart: "quickwit",
    // You need your specific repo here.
    // For instance, if the Quickwit Helm chart is available at https://helm.quickwit.io 
    // You will need to add `repo: "https://helm.quickwit.io"`.
    // If there are no specifications, you can omit the `repo` property.
    version: "0.1", // Replace with the specific chart version you want to deploy
    namespace: "default",
    // If the Quickwit Helm chart requires you to configure certain values, you can specify those values here.
    // For example: values: { "image": { "tag": "latest" }, "service": { "type": "ClusterIP" } }
}, { provider: k8sProvider });

// Export the Helm release status and other outputs you may want to access
export const quickwitStatus = quickwitRelease.status;

```

This program does the following:

- **GKE Cluster Setup**: We define a new GKE cluster with the desired node count and versions. We've chosen a small machine type (`n1-standard-1`) for demonstration purposes, but this should be adjusted for the actual deployment needs of Quickwit.

- **Kubeconfig Export**: We export the Kubeconfig from the newly created GKE cluster, which allows us to interact with the cluster using `kubectl` or Pulumi's Kubernetes provider.

- **Kubernetes Provider Configuration**: We set up the Pulumi Kubernetes provider to interact with our GKE cluster using the exported Kubeconfig.

- **Helm Chart Deployment**: We use the Pulumi Kubernetes provider to deploy the Quickwit Helm chart, specifying the chart name and version. Note that you might need specific values which depend on your Helm chart configurations.

- **Output**: We export the status of the Helm release so we can observe the deployment status. Additional outputs can include service URLs, IP addresses, or other relevant data.

To use this program:

1. Ensure you have the necessary Pulumi stack configuration for GCP set up.
2. Place this code in a `index.ts` file within your Pulumi project.
3. Run `pulumi up` to provision the resources and deploy the Helm chart to GKE.

Make sure you have the Helm chart repository and specific version number that you need for Quickwit. If the Quickwit Helm chart has specific configuration values required, they need to be provided in the `values` property of the `Chart` resource.