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

Question

Pulumi · Accepted Answer

Deploying a Helm chart to a Kubernetes cluster involves a few steps:
1. **Setting up a Kubernetes Cluster**: Since our target is the Oracle Kubernetes Engine (OKE), we'll need to create an OKE cluster or use an existing one.
2. **Adding Helm Support**: With Pulumi, we will use the Helm package to manage the deployment of the Helm charts on the Kubernetes cluster.
3. **Deploy Kyuubi Helm Chart**: The Apache Kyuubi project should provide a Helm chart repository which we can use to install the chart on the cluster.

Below is a Pulumi TypeScript program that:

- Defines an Oracle Kubernetes Engine (OKE) cluster.
- Uses the Helm chart to deploy Kyuubi to the cluster.

Note: Before you run this program, you must have Pulumi installed and configured with your OCI (Oracle Cloud Infrastructure) credentials. You also should have `kubectl` and `helm` set up to interact with your cluster and to manage Helm charts, respectively.

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

// Create an OKE cluster
const cluster = new oci.containerengine.Cluster("oke-cluster", {
    compartmentId: "your-compartment-id", // replace with your Compartment ID in OCI
    vcnId: "your-vcn-id", // replace with your VCN ID where you want the OKE cluster to reside
    kubernetesVersion: "v1.21.0", // specify the version of Kubernetes you want
    options: {
        // Add any specific options you require for the OKE cluster
        addOns: {
            isKubernetesDashboardEnabled: true,
            isTillerEnabled: false,
        },
        kubernetesNetworkConfig: {
            podsCidr: "10.244.0.0/16",
            servicesCidr: "10.96.0.0/16",
        },
        // ...other options
    },
    // Other necessary configurations like imagePolicyConfig, nodePoolConfigs, etc.
});

// Set up a Kubernetes provider to interact with the OKE cluster
const k8sProvider = new k8s.Provider("k8s-provider", {
    kubeconfig: cluster.kubeconfig,
});

// Deploy the Kyuubi Helm chart
const kyuubiChart = new k8s.helm.v3.Chart("kyuubi-helm-chart", {
    chart: "kyuubi",
    // Helm chart values to provide custom configuration for Kyuubi
    values: {
        // Specify custom values for the chart, for example:
        // podCount: 1,
        // image: {
        //     repository: "kyuubi/kyuubi",
        //     tag: "latest",
        // },
        // service: {
        //     type: "ClusterIP",
        //     port: 10009,
        // },
        // ...other values
    },
    // Ensure to add the repository if it's not a standard Helm repo
    fetchOpts: {
        repo: "https://kyuubi.apache.org/your-helm-repo", // replace with the actual Helm chart repo for Kyuubi
    },
}, { provider: k8sProvider });

// Export the cluster name and kubeconfig
export const clusterName = cluster.name;
export const kubeconfig = cluster.kubeconfig;
```

In this program, we initialize a new Oracle Kubernetes Engine (OKE) cluster with specified configurations. The configuration options include network settings, the version of Kubernetes, and additional options like enabling the Kubernetes Dashboard. We replace placeholders such as `'your-compartment-id'` and `'your-vcn-id'` with actual values from your Oracle Cloud Infrastructure.

After setting up the OKE cluster, we create a Pulumi Kubernetes provider. This provider uses the kubeconfig of our OKE cluster, which allows Pulumi to manage resources in the cluster.

Next, we deploy the Kyuubi Helm chart using Pulumi's Helm package. We specify the chart's name and any custom values we want to override. This is also where we specify the Helm chart repository URL for Kyuubi, which is necessary to locate the Helm chart.

Lastly, we output the cluster name and kubeconfig, which can be used to interact with the cluster through `kubectl`.

To run this program, you should navigate to the directory containing your Pulumi program and execute the following commands:

```shell
pulumi up
```

This command starts the Pulumi deployment process which will set up your OKE cluster and deploy the Kyuubi Helm chart to it. Make sure to review the output carefully to ensure everything is configured correctly.

Keep in mind that deploying cloud resources can incur costs, so it's important to understand the pricing details for the Oracle Kubernetes Engine and usage of related resources.