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

Question

Pulumi · Accepted Answer

Deploying the Amundsen Helm chart on Oracle Kubernetes Engine (OKE) involves a few steps. First, we need to set up the OKE cluster itself if you haven't done this already. Once the cluster is up and running, we can then proceed to deploy the Helm chart onto the cluster.

Below is a Pulumi program written in TypeScript that demonstrates how to set up the Oracle Kubernetes Engine cluster and deploy the Amundsen Helm chart. In this example, we'll be using the OCI (Oracle Cloud Infrastructure) and Kubernetes Pulumi providers.

1. **Setting up the OKE Cluster**: We are using the `oci.ContainerEngine.Cluster` resource which represents an OKE cluster in Oracle Cloud Infrastructure.

2. **Deploying the Helm Chart**: After setting up the OKE cluster, we use the `kubernetes.helm.v3.Chart` resource from the Kubernetes Pulumi provider to deploy the Helm chart for Amundsen. In this example, you should have the Helm chart's repository URL and any configurations needed for the deployment.

Before running the program, be sure to set up your Pulumi environment for OCI and Kubernetes as described in the Pulumi documentation.

Now, let's look at the program:

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

// Configure OCI provider with the appropriate compartment ID
const provider = new oci.Provider("oci", {
    // Compartment ID should be specified in your configuration
    compartmentId: pulumi.config.require("compartmentId"),
});

// Create an OKE Cluster
const cluster = new oci.containerengine.Cluster("okeCluster", {
    // Use the name you desire for your OKE cluster
    name: "amundsen-cluster",
    
    // Specify the VCN and subnet IDs according to your network setup
    vcnId: pulumi.config.require("vcnId"),
    kubernetesVersion: "v1.21.4", // The Kubernetes version to use (change this according to available versions)
    options: {
        // You can configure additional OKE options here
        // Like enabling a Kubernetes dashboard, setting up network options, etc.
        // In this example, it's left as defaults
    },
}, { provider });

// Set up the Kubernetes provider using the kubeconfig generated from OKE
const kubeProvider = new k8s.Provider("kubeProvider", {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the Amundsen Helm chart onto the OKE cluster
const amundsenChart = new k8s.helm.v3.Chart("amundsen", {
    chart: "amundsen", // The name of the chart, ensure this is correct
    version: "0.1.0", // Specify the exact chart version
    fetchOpts: {
        repo: "https://helm-repo-url", // Specify the Helm repository URL containing the Amundsen chart
    },
    // If there are any specific configurations for Amundsen, replace below
    values: {
        // Custom values for the Amundsen Helm chart
    },
}, { providers: { kubernetes: kubeProvider } });

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

Let's break down the main parts of this program:

- We initialize an OCI provider with the compartment ID from the configuration.
- We create an OKE cluster using the `oci.ContainerEngine.Cluster` resource, passing in the desired name, VCN ID, and Kubernetes version.
- Once the cluster is created, we get the kubeconfig from the cluster's output, which is necessary to interact with the cluster using kubectl.
- We set up the Kubernetes provider using the kubeconfig from the created OKE cluster.
- We define a Helm chart with `k8s.helm.v3.Chart`, specifying the chart's name, version, and the repository.
- We export the cluster name and kubeconfig so you can use them outside of Pulumi, for example, to connect to your cluster using kubectl.

When you run `pulumi up`, this program will provision an OKE cluster and deploy the Amundsen Helm chart to it. Make sure you replace placeholder values (`helm-repo-url`, `0.1.0`) with actual values before running the program.