Deploy the gradle-cache helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the `gradle-cache` Helm chart on Oracle Kubernetes Engine (OKE), we will use Pulumi's `oci` and `kubernetes` packages. The process involves two main steps:

1. **Provision an OKE Cluster**: We first need to set up the Kubernetes cluster in Oracle Cloud Infrastructure (OCI) using the `oci.ContainerEngine.Cluster` resource.
2. **Install the Helm Chart**: Following the cluster setup, we utilize Pulumi's Helm support through the `kubernetes.helm.v3.Chart` resource to deploy the `gradle-cache` Helm chart on the OKE cluster we provisioned.

Before you run the following Pulumi program, make sure you have Pulumi CLI and the OCI provider configured with the appropriate credentials and permissions.

Here's a step-by-step Pulumi program in TypeScript that carries out the deployment:

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

// Step 1: Provision an Oracle Kubernetes Engine (OKE) Cluster
const cluster = new oci.ContainerEngine.Cluster("gradleCacheCluster", {
    // Example parameters for the OKE cluster:
    // NOTE: Replace these with the correct values for your OCI environment.
    compartmentId: "oci-compartment-id", // Specify your compartment ID here
    vcnId: "oci-vcn-id", // Specify the VCN ID where the cluster should be created
    kubernetesVersion: "v1.21.5", // Specify the Kubernetes version for the cluster
    name: "gradleCacheCluster", // The name of the Kubernetes cluster
    options: {
        // Configuration options for the cluster
        // Adjust these options as needed for your environment
        serviceLbSubnetIds: ["subnet-id-1", "subnet-id-2"],
        // Other options can be included based on requirements
    },
    // Additional settings like tags and other configurations may be added here
});

// Output the kubeconfig to connect to the OKE cluster.
const kubeconfig = pulumi.all([cluster.id]).apply(([id]) => {
    return oci.containerengine.getClusterKubeconfig({
        clusterId: id,
    });
});

// Create a provider to interact with the created cluster.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig.content,
});

// Step 2: Install the `gradle-cache` Helm Chart
const helmChart = new k8s.helm.v3.Chart("gradle-cache", {
    chart: "gradle-cache",
    version: "chart-version", // Specify the Helm chart version you want to use
    // Fetch the Helm chart from a remote repository
    fetchOpts: {
        repo: "https://charts.example.com/", // Replace with the actual Helm chart repository URL
    },
    // Values to pass to the Helm chart, which can configure the application
    values: {
        // Place your configuration values as needed for the `gradle-cache` chart
    },
}, { provider: k8sProvider });

// Export the Cluster's Kubernetes API endpoint so it can be accessed externally.
export const kubeApiEndpoint = cluster.endpoints.apply(e => e.publicEndpoint);

// Export the Helm Chart status
export const helmChartStatus = helmChart.status;
```

This program begins by creating an OKE cluster within a specified compartment and VCN using the `oci.ContainerEngine.Cluster` resource. You will need to replace the placeholder values with your compartment ID, VCN ID, and other cluster-configuration details specific to your OCI environment.

Following the cluster creation, we retrieve the kubeconfig, which enables us to interact with the cluster programmatically using the Kubernetes API. We use `oci.containerengine.getClusterKubeconfig` to fetch the kubeconfig for the newly created cluster, providing the cluster's ID.

Next, we set up a Pulumi Kubernetes provider with the obtained kubeconfig to manage Kubernetes resources on that cluster. With this provider, we deploy the `gradle-cache` Helm chart using `k8s.helm.v3.Chart`. You would need to replace the `chart-version` with the version number of the Helm chart you wish to install and provide the repository URL where your Helm chart is located.

Finally, we export the Kubernetes API endpoint and the status of the Helm chart deployment. The API endpoint can be used to interact with the Kubernetes cluster from external tools, and the status provides information about the deployment state of the Helm chart.

Run this program by executing `pulumi up` in your terminal. Pulumi will show you a preview of the actions it will take to reach your desired state. If everything looks correct, confirm the deployment, and Pulumi will create the resources for you.