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

Question

Pulumi · Accepted Answer

Deploying a Helm chart on a Google Kubernetes Engine (GKE) cluster using Pulumi involves several steps. First, you'll create a GKE cluster, and then install the `sentry-kubernetes` helm chart onto that cluster.

Here's how to accomplish this:

1. **Set up a new Pulumi project**: Initialize a new Pulumi project in the language of your choice (TypeScript is used in this example).

2. **Install Pulumi GCP package**: Install the necessary Pulumi GCP package to work with GCP resources.

3. **Create a GKE cluster**: Write the TypeScript code to define a GKE cluster resource.

4. **Install the Sentry Helm chart**: Use Pulumi's Kubernetes provider to install the `sentry-kubernetes` helm chart on the GKE cluster.

Let's get started with the detailed TypeScript program.

### Detailed Program Explanation

#### Step 1: Install Pulumi GCP Package
Before running the program, ensure you install the Pulumi GCP package using npm or yarn:

```shell
npm install @pulumi/gcp
```
or
```shell
yarn add @pulumi/gcp
```

#### Step 2: Create the GKE Cluster
We need to create a GKE cluster by instantiating `gcp.container.Cluster`. This will be the Kubernetes cluster where Sentry will be deployed.

#### Step 3: Install the Sentry Helm Chart
Once the cluster is created, we can install the `sentry-kubernetes` Helm chart onto this cluster using the `kubernetes.helm.v3.Chart` class. You must have the Helm CLI installed and have added the Sentry chart's repository beforehand.

#### Step 4: Export the Kubeconfig
At the end of the program, we'll export the kubeconfig file. This is necessary for `kubectl` and other tools to interact with the newly created cluster.

Now, let's write the Pulumi program in TypeScript:

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

// Step 1: Create a GKE cluster
// We are using a small default node count and machine type for example purposes
const cluster = new gcp.container.Cluster("sentry-cluster", {
    initialNodeCount: 2,
    nodeConfig: {
        machineType: "n1-standard-1",
    },
});

// A Kubernetes provider instance is necessary to point to the created cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeConfigRaw,
});

// Step 2: Deploy the sentry-kubernetes Helm chart on the GKE cluster
const sentryChart = new k8s.helm.v3.Chart("sentry-kubernetes", {
    chart: "sentry", // This assumes you have added the Sentry Helm chart repository
    version: "11.0.0", // Specify the version of the chart
    fetchOpts: {
        repo: "https://sentry-kubernetes.github.io/charts", // The repository URL of the sentry chart
    },
}, { provider: k8sProvider });

// Step 3: Export the kubeconfig to enable interacting with the cluster via kubectl
export const kubeConfig = cluster.kubeConfigRaw;

```

### Explanation of the Program

1. We import the necessary modules from Pulumi for GCP and Kubernetes.
2. We create a new GKE cluster resource with 2 nodes using the `gcp.container.Cluster` class.
3. We create a Pulumi Kubernetes provider that will use the kubeconfig of the created GKE cluster, which allows Pulumi to interact with our GKE cluster.
4. We then install the `sentry-kubernetes` Helm chart using Pulumi’s Kubernetes provider with the `Chart` class from the `@pulumi/kubernetes` module.
5. We export the kubeconfig of the GKE cluster, which can be used by `kubectl` or other Kubernetes tooling.

After running your Pulumi program with the command `pulumi up`, Pulumi will perform the deployment according to the steps defined in the program. Make sure you have the necessary credentials configured for Pulumi to interact with GCP and the Kubernetes cluster.