Deploy the jenkins-x-platform helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart to an Oracle Kubernetes Engine (OKE) cluster requires several steps, including the setup of the OKE cluster itself and the installation of Helm and the chart. The steps below and the accompanying Pulumi TypeScript program demonstrate how to accomplish this.

Before we dive into the code, here are the Pulumi resources we'll be using:
- `oci.ContainerEngine.Cluster`: This resource is used to create and manage an OKE cluster. The cluster provides the Kubernetes platform where Jenkins X will run.
- `kubernetes.helm.v3.Chart`: This resource allows us to deploy Helm charts onto a Kubernetes cluster. Helm is a package manager for Kubernetes, and Jenkins X can be packaged as a Helm chart.

Here's what the code does:
1. **Creating an OKE cluster**: The `oci.ContainerEngine.Cluster` resource creates a new Kubernetes cluster within Oracle's cloud infrastructure.
2. **Deploying the Jenkins X Helm chart**: We use the `kubernetes.helm.v3.Chart` resource to deploy the Jenkins X Helm chart to the OKE cluster we created.

Below is the TypeScript program that performs these actions. Since it's a guideline, you'll need to replace the placeholders with actual values that correspond to your OCI account and intended cluster configuration.

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

// Define the OKE cluster configuration
const okeCluster = new oci.ContainerEngine.Cluster("okeCluster", {
    // Replace these placeholder values with your actual configuration
    compartmentId: pulumi.interpolate`${YOUR_OCI_COMPARTMENT_ID}`,
    kubernetesVersion: "v1.20.8",
    options: {
        serviceLbSubnetIds: [pulumi.interpolate`${YOUR_OCI_SUBNET_ID}`],
        // Additional options can be specified if needed.
    },
    // ... other necessary cluster configurations ...
});

// Once the cluster is created, we need to setup the Kubernetes provider
const k8sProvider = new k8s.Provider("okeK8s", {
    kubeconfig: okeCluster.kubeconfigRaw, // The kubeconfig is available from the OKE cluster
});

// Now we deploy the jenkins-x-platform helm chart with the k8s provider
const jenkinsXChart = new k8s.helm.v3.Chart("jenkinsX", {
    chart: "jenkins-x-platform",
    version: "2.0.0", // Specify the version of the Jenkins X Helm chart you wish to deploy
    // If the chart requires additional configuration, specify it here
    values: {
        // ... any necessary Helm chart values ...
    },
}, { provider: k8sProvider });

// Export the cluster's name and endpoint
export const clusterName = okeCluster.name;
export const clusterEndpoint = okeCluster.endpoints.apply(e => e.public);

```

Let's break it down:
- We start by importing the necessary Pulumi packages.
- We create an OKE cluster by using `oci.ContainerEngine.Cluster`. You need to provide your specific OCI compartment ID, subnet IDs, and any other configuration necessary for your cluster.
- After the cluster is created, we set up the Kubernetes provider using the cluster's raw kubeconfig, which is provided by the OKE cluster.
- Finally, we deploy the `jenkins-x-platform` Helm chart to our cluster, specifying the chart and version. If the Jenkins X chart requires any specific configuration, like service type or resource limits, you can pass these using the `values` property.

Please replace `YOUR_OCI_COMPARTMENT_ID` and `YOUR_OCI_SUBNET_ID` with the actual IDs where you want to deploy your OKE Cluster. You'll also need to ensure you have the right permissions and OCI credentials configured for Pulumi to manage resources in your OCI account.

Keep in mind that creating cloud resources will incur costs according to your cloud provider's pricing. Always ensure to understand the costs associated with the resources you are provisioning and manage resources responsibly to avoid unnecessary charges.