Deploy the cassandra-web helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the `cassandra-web` Helm chart on Oracle Kubernetes Engine (OKE), you will require a running Kubernetes cluster on OKE and `helm`, the package manager for Kubernetes, to handle the deployment of Cassandra Web.

Pulumi provides a Kubernetes provider that can manage resources on any conformant Kubernetes cluster, and a Helm Release resource to handle Helm chart deployments.

The following Pulumi TypeScript program performs these steps:

1. Instantiate a Kubernetes cluster on Oracle Cloud Infrastructure (OCI), if you haven't one already.
2. Use the Helm chart resource within the Pulumi Kubernetes provider to deploy `cassandra-web`.

Ensure you have the following prerequisites satisfied before running the program:

- Pulumi CLI installed and set up to manage resources on OCI.
- Oracle Cloud Infrastructure (OCI) account with permissions to manage OKE.
- An existing OKE cluster or using the program to create a new one.

Here is the Pulumi TypeScript program to deploy `cassandra-web` on OKE:

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

// Replace these variables with appropriate values or retrieve them from the Pulumi config.
const compartmentId = "oci-compartment-id";
const vcnId = "oci-vcn-id";
const subnetId = "oci-subnet-id-for-oke";

// Create an OKE cluster if not exists.
const cluster = new oci.ContainerEngine.Cluster("my-cluster", {
    compartmentId,
    vcnId,
    options: {
        serviceLbSubnetIds: [subnetId],
        // Include any additional options you need for the OKE cluster.
    },
    // Specify the version of Kubernetes you want to install.
    kubernetesVersion: "v1.20.11",
    // Other required properties for creating your OKE cluster.
});

// Once the cluster is created, we need to get the cluster's kubeconfig for Pulumi to connect to.
// We use a dynamic provider to assist with this.
class OciKubeconfigProvider implements pulumi.dynamic.ResourceProvider {
    public async create(inputs: any): Promise<pulumi.dynamic.CreateResult> {
        const kubeconfigContent = await oci.ContainerEngine.getClusterKubeconfig({
            clusterId: inputs.clusterId,
        });
        return { id: inputs.clusterId, outs: { kubeconfig: kubeconfigContent.content }};
    }
}

// The dynamic resource that uses the OciKubeconfigProvider to get the kubeconfig.
const kubeconfigResource = new pulumi.dynamic.Resource(
    "kubeconfig",
    { clusterId: cluster.id },
    { provider: new OciKubeconfigProvider() },
);

// Provider to interact with our new OKE cluster.
const k8sProvider = new k8s.Provider("oke-k8s", {
    kubeconfig: kubeconfigResource.outputs.kubeconfig,
});

// Deploy cassandra-web Helm chart on the OKE cluster using the Pulumi Kubernetes provider.
const cassandraWebChart = new k8s.helm.v3.Chart("cassandra-web", {
    chart: "cassandra-web",
    // Helm repository where 'cassandra-web' is stored.
    fetchOpts: {
        repo: "https://helm-repository where cassandra-web is hosted/",
    },
    // Any custom values you want to provide to the helm chart.
    values: {
        // Add any chart values here.
    },
}, { provider: k8sProvider });

// Export the necessary attributes so you can interact with or manage your resources.
export const clusterName = cluster.name;
export const cassandraWebEndpoint = cassandraWebChart.getResourceProperty("v1/Service", "cassandra-web", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

This program does the following:
- Defines a cluster resource if you need to create a new Kubernetes cluster in OCI.
- Defines a dynamic resource to fetch the `kubeconfig` of the cluster, which is required for Pulumi to deploy resources to it.
- The `kubeconfig` is passed to a Pulumi Kubernetes provider which sets up the Kubernetes connection.
- Deploys the `cassandra-web` Helm chart to the Kubernetes cluster with the `k8s.helm.v3.Chart` resource.

To run this Pulumi program:

1. Save the code in a file named `index.ts`.
2. Run `pulumi up` to create the resources defined in the program.

Remember to replace placeholder variables (`oci-compartment-id`, `oci-vcn-id`, and `oci-subnet-id-for-oke`, and the repo URL for the Helm chart) with actual values from your OCI environment. The program assumes you have a VCN and subnet already created for this purpose.