Deploy the burrow helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the Burrow Helm chart on Oracle Kubernetes Engine (OKE), you need to set up a few components. First, you will need a Kubernetes cluster running on OKE. Then, you will use the Helm package manager to deploy Burrow, which is a Kafka monitoring tool.

Pulumi's Kubernetes provider lets you create, configure, and manage Kubernetes resources using Pulumi's infrastructure-as-code approach. To deploy a Helm chart, you can use the `Chart` resource from the `@pulumi/kubernetes/helm/v3` package.

Here's a step-by-step guide and the Pulumi TypeScript program to deploy the Burrow Helm chart on OKE:

1. **Setting up Oracle Kubernetes Engine (OKE)**: This involves creating a Kubernetes cluster within your Oracle Cloud Infrastructure (OCI) environment. The `oci.ContainerEngine.Cluster` resource is used to provision the OKE cluster.

2. **Adding the Helm Chart**: This step will deploy the Burrow Helm chart using the `kubernetes.helm.v3.Chart` resource. This requires specifying the Helm chart name, repository, and any custom values you want to override the default Helm chart values.

Before running this Pulumi program, ensure you have:

- Installed Pulumi CLI and set up the Oracle Cloud Infrastructure (OCI) provider.
- Configured your OCI credentials.
- Installed Helm CLI as it is needed by Pulumi to manage Helm charts.

Now let's write the Pulumi program:

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

// Step 1: Configure OCI provider
const provider = new oci.Provider("oci", {/* Your OCI Configuration */});

// Step 2: Provision an OKE cluster
const okeCluster = new oci.ContainerEngine.Cluster("okeCluster", {
    /* Replace with your OKE cluster configuration */
}, { provider: provider });

// After the cluster is provisioned, you should configure kubectl
// to communicate with the Kubernetes cluster and set up a K8s provider instance.
// Usually, the kubeconfig file is obtained from Oracle Cloud dashboard or OCI CLI.

// The kubeconfig is then used to configure a Pulumi Kubernetes provider:
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: okeCluster.kubeConfigs[0].content.apply(c => Buffer.from(c, "base64").toString("utf-8")),
});

// Step 3: Deploy Burrow Helm chart
const burrowChart = new k8s.helm.v3.Chart("burrow", {
    chart: "burrow",
    fetchOpts: {
        repo: "https://raw.githubusercontent.com/helm/charts/master/incubator/",
    },
    // Override default values here if necessary
    values: {
        // Your custom chart values
    },
}, { provider: k8sProvider });

// Optional - Exporting some values that might be useful:
export const clusterName = okeCluster.name;
export const burrowChartVersion = burrowChart.getResourceProperty("v1/ConfigMap", "burrow-config", "data");

```

Explanation:
- We begin by importing the required Pulumi packages.
- The OCI provider instance is created and configured with Oracle Cloud credentials.
- An instance of `oci.ContainerEngine.Cluster` is declared to create a new OKE cluster.
- We then set up the Kubernetes provider using the kubeconfig with the OKE cluster details.
- A `Chart` resource instance is created to deploy the Burrow Helm chart from the specified repository.
- For the chart values, you can specify custom configurations if needed.
- Finally, we export some of the outputs from our Pulumi program that could be helpful, like the cluster name and chart version.

This Pulumi program will provide you with the infrastructure needed for deploying Burrow using Helm on OKE. You can run this program with `pulumi up`, assuming Pulumi, OCI CLI, and Helm are set up on your system. After deployment, you will be managing Kafka clusters performance and will be able to monitor consumer lag and topic offset.