Deploy the ts-server helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the `ts-server` Helm chart on Oracle Kubernetes Engine (OKE), we'll go through the following steps:

1. Create an OKE cluster or use an existing one.
2. Write a Pulumi program to use the Helm chart within the Kubernetes cluster.

Oracle Kubernetes Engine (OKE) is Oracle's managed Kubernetes service, which simplifies the process of running and managing Kubernetes. To deploy a Helm chart, we'll need to interact with both the Oracle Cloud Infrastructure (OCI) and Kubernetes.

First, we will provision an OKE cluster or identify an existing OKE cluster where we want to deploy our Helm chart. Pulumi has a resource type called `oci.ContainerEngine.Cluster` from the `oci` package that can be used to create and manage an OKE cluster. The documentation for this OCI resource can be found [here](https://www.pulumi.com/docs/reference/pkg/oci/containerengine/cluster/).

Once the cluster is up and running, we will install the `ts-server` Helm chart on the cluster using Pulumi's Kubernetes provider. Specifically, we'll use the `kubernetes.helm.v3.Chart` resource, which represents a Helm chart in a Kubernetes cluster.

Here's the Pulumi TypeScript program to deploy your Helm chart:

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

// Step 1: Configure and provision an OKE cluster
// Note: Replace the following placeholder values with your own configurations.
const compartmentId = 'your-oci-compartment-id';
const vcnId = 'your-oci-vcn-id';
const kubernetesVersion = 'v1.21.1'; // Set the desired Kubernetes version

const okeCluster = new oci.ContainerEngine.Cluster('ts-server-cluster', {
    compartmentId: compartmentId,
    kubernetesVersion: kubernetesVersion,
    name: 'ts-server-cluster',
    options: {
        serviceLbSubnetIds: ['your-oci-lb-subnet-id-1', 'your-oci-lb-subnet-id-2'], // Replace with actual subnet IDs
        // You can specify additional cluster options as needed
    },
    vcnId: vcnId,
});

// Step 2: Configure Kubeconfig to interact with the OKE cluster
const kubeconfig = pulumi.all([okeCluster.id, compartmentId]).apply(([clusterId, compartmentId]) => {
    return oci.containerengine.getClusterKubeconfig({
        clusterId: clusterId,
        compartmentId: compartmentId,
    });
});

// Step 3: Set up the Kubernetes provider using the kubeconfig from the OKE cluster
const k8sProvider = new k8s.Provider('k8s-provider', {
    kubeconfig: kubeconfig.content,
});

// Step 4: Deploy the 'ts-server' Helm chart to the cluster
// Note: You should replace 'repoUrl' and 'chartVersion' with the actual values.
const tsServerChart = new k8s.helm.v3.Chart('ts-server-chart', {
    chart: 'ts-server',
    version: 'chartVersion', // specify the version of your chart
    fetchOpts: {
        repo: 'repoUrl', // specify the Helm repository URL
    },
}, { provider: k8sProvider });

// Export relevant URIs and IPs as stack outputs that might be useful
export const clusterName = okeCluster.name;
export const kubeconfigContent = kubeconfig.content;
export const tsServerServiceUrl = tsServerChart.getResourceProperty('v1/Service', 'ts-server', 'status').apply(status => status.loadBalancer.ingress[0].ip);
```

### What Does This Program Do?

1. **Configure and provision an OKE cluster**: We create an OKE cluster resource to which we will deploy the Helm chart. This step assumes that you have your OCI credentials set up for Pulumi to interact with Oracle Cloud.

2. **Configure Kubeconfig for K8s interaction**: After the cluster is provisioned, we need a kubeconfig file to interact with our Kubernetes cluster. This kubeconfig is dynamically generated using the properties of the OKE cluster we just created.

3. **Set up a Kubernetes provider**: We instantiate a Kubernetes provider that uses the generated kubeconfig. This provider is how Pulumi will communicate with the Kubernetes cluster to carry out the required Helm operations.

4. **Deploy the 'ts-server' Helm chart**: With the Kubernetes provider set up, we create a Helm chart resource specifying the chart name, version, and repository URL. Pulumi will then use Helm to deploy this chart to the cluster.

5. **Export outputs**: Lastly, we export some useful outputs such as the cluster name, kubeconfig's content for direct `kubectl` operations, and the service URL once the Helm chart is deployed. The service URL is dynamically retrieved from the Helm chart's service resource, assuming the `ts-server` chart has a Kubernetes service of type LoadBalancer.

### Additional Notes

- Make sure to replace placeholders (`your-oci-compartment-id`, `your-oci-vcn-id`, etc.) with actual values from your Oracle Cloud Infrastructure.

- Ensure that your Pulumi context is set to use the appropriate project and stack.

- For a real deployment, you might need more configuration for your cluster (e.g., node shapes, sizes, etc.).

- The `ts-server` chart name and other parameters such as `repoUrl` and `chartVersion` must be updated to match the Helm chart you want to deploy.

- The `kubeconfigContent` export will contain sensitive information; treat it accordingly.

To run the Pulumi program to deploy the `ts-server` Helm chart, execute `pulumi up` in the directory where you save this `[filename].ts`. Pulumi will show you a preview, and on confirmation, it will apply the changes to create the resources in Oracle Cloud.