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

Question

Pulumi · Accepted Answer

To deploy the `redpanda-operator` Helm chart on Google Kubernetes Engine (GKE), we'll go through the following steps:

1. Set up a Google Kubernetes Engine cluster where your `redpanda-operator` will be deployed. We'll use Pulumi's `@pulumi/gcp` package to provision the GKE cluster.
   
2. Once the cluster is up and running, we will use Pulumi's `@pulumi/kubernetes` provider to deploy the `redpanda-operator` Helm chart. This provider interacts with the Kubernetes API to manage resources.

Here's a detailed Pulumi TypeScript program that accomplishes the above:

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

// This is the name you want to give your GKE cluster
const clusterName = "redpanda-cluster";

// Create a GKE cluster
const cluster = new gcp.container.Cluster(clusterName, {
    initialNodeCount: 2,
    nodeVersion: "latest",
    minMasterVersion: "latest",
    nodeConfig: {
        machineType: "n1-standard-1", // or any other 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
export const kubeconfig = cluster.name.apply(name => {
    const context = `${gcp.config.project}_${gcp.config.zone}_${name}`;
    return `apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ${cluster.masterAuth.clusterCaCertificate}
    server: https://${cluster.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 that uses our cluster from above
const k8sProvider = new k8s.Provider(clusterName, {
    kubeconfig: kubeconfig
});

// Deploy the redpanda-operator Helm chart
const redpandaOperatorChart = new k8s.helm.v3.Chart("redpanda-operator", {
    chart: "redpanda-operator",
    version: "0.1.0", // Specify the chart version you want to deploy
    fetchOpts:{
        repo: "https://charts.vectorized.io/", // The repository where the chart can be found
    },
}, { provider: k8sProvider });

// Export the Chart name
export const chartName = redpandaOperatorChart.name;
```

In this program, we:

1. Import the necessary Pulumi libraries for working with GCP and Kubernetes.
   
2. Define the name of the GKE cluster we're going to create.

3. Create a GKE cluster with an appropriate machine type and necessary OAuth scopes using the `gcp.container.Cluster` resource.

4. Output the generated `kubeconfig` which will be used by the Kubernetes provider to interact with the GKE cluster.

5. Instantiate the Kubernetes provider with the `kubeconfig`.

6. Deploy the `redpanda-operator` Helm chart using the `kubernetes.helm.v3.Chart` resource, specifying the chart name, version, and repository URL.

7. Output the name of the deployed chart for reference.

After executing this program with Pulumi, the `redpanda-operator` Helm chart will be deployed onto your GKE cluster, and you should be able to interact with your Redpanda clusters via Kubernetes APIs or kubectl command-line tool.

Make sure you have Pulumi installed, along with the GCP CLI, and configured with the appropriate credentials before running this program. To execute, run `pulumi up` in the same directory as the code above, and Pulumi will handle the creation of resources as specified.