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

Question

Pulumi · Accepted Answer

To deploy the OneUptime helm chart on Google Kubernetes Engine (GKE), you will need to first create a GKE cluster. Once the cluster is ready, you can deploy the OneUptime application using Pulumi's Helm support.

Here's the flow of steps we are going to take:

1. **Set up a GKE cluster**:
   - We'll first instantiate a GKE cluster where our application is going to be deployed. This involves specifying the details for the configuration like machine types and numbers of nodes.

2. **Deploy OneUptime using Helm**:
   - With the cluster in place, we'll then utilize the Pulumi's `helm.v3.Chart` component from the `@pulumi/kubernetes` package, which allows us to deploy a Helm chart to a Kubernetes cluster.
   - Helm charts are packages of pre-configured Kubernetes resources, and OneUptime should provide their Helm chart for deployment. You will need to provide the specific chart values according to the OneUptime documentation to configure it according to your needs.

Below is a Pulumi program written in TypeScript that creates a GKE cluster and deploys the OneUptime Helm chart to that cluster. Before running this program, ensure that you have authenticated to GCP and have selected the project where you wish to deploy the cluster:

```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("my-gke-cluster", {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        preemptible: false,
        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 so you can access the cluster using `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
`;
    });

// STEP 2: Deploy the OneUptime Helm chart.
const uptimeChart = new k8s.helm.v3.Chart("oneuptime-helm-chart", {
    chart: "oneuptime", // The name of the chart from OneUptime, ensure to replace with the correct chart name.
    // You should specify the values based on OneUptime’s chart documentation. Here, we are considering default values.
    values: {}, // Populate this object with necessary values as per OneUptime Helm chart specifications.
    fetchOpts: { // Optional: If you need to download the chart from a custom repository, specify repo details.
        repo: "http://helm-repo-url.com", // Replace with the URL of the chart repository.
    },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: kubeconfig }) });

// Export the chart name.
export const chartName = uptimeChart.releaseName;
```

This program will create a new GKE cluster and use `kubeconfig` as a Kubernetes provider to deploy OneUptime. Adjust the `values` within the `uptimeChart` according to the configuration settings required for OneUptime. Make sure to replace `"http://helm-repo-url.com"` with the actual URL of the OneUptime Helm chart repository.

Before running the code:

- Replace placeholders in the `uptimeChart` (such as `chart`, `values`, and if applicable, `repo`) with actual values provided by OneUptime for their Helm chart.
- Install the necessary Pulumi packages by running `npm install @pulumi/pulumi @pulumi/gcp @pulumi/kubernetes`.
- Configure your Google Cloud credentials using the Pulumi CLI.

To run the Pulumi program, execute `pulumi up` in the terminal in the directory containing your `index.ts` file. Pulumi CLI will display a preview of the resources about to be created and prompt for confirmation before proceeding. After confirmation, the GKE cluster and OneUptime application will be deployed.