Deploy the k8s-node-image-nginx9-1-21 helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy a Helm chart on Oracle Kubernetes Engine (OKE) using Pulumi, you will primarily work with two types of resources:

1. **Oracle Container Engine for Kubernetes (`oci.ContainerEngine.Cluster`)**: This resource is used to create and manage an OKE cluster. It is where your application running in the Helm chart will be deployed.

2. **Helm Chart (`kubernetes.helm.v3.Chart`)**: This represents a Helm chart in Pulumi, which packages all the necessary Kubernetes resources together. Helm charts make it easy to deploy and manage Kubernetes applications.

Assuming you have already set up and authenticated Pulumi with your OCI account, the following Pulumi program in TypeScript will guide you through creating an OKE cluster and deploying the `k8s-node-image-nginx9-1-21` Helm chart into it.

First, you would need to install the necessary Pulumi packages for OCI and Kubernetes, which you can do by running the following commands:

```bash
pulumi plugin install resource oci 1.12.0
pulumi plugin install resource kubernetes 4.4.0
```

Next, here is the detailed Pulumi program in TypeScript:

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

// Create an OCI cluster to deploy the Helm chart
const cluster = new oci.ContainerEngine.Cluster("my-cluster", {
    // You would replace the following properties with your actual compartment, VCN, and subnet configs
    compartmentId: "YOUR_COMPARTMENT_ID",
    vcnId: "YOUR_VCN_ID",
    options: {
        serviceLbSubnetIds: ["SUBNET_1", "SUBNET_2"],
        // ... include additional settings as needed
    },
    kubernetesVersion: "v1.21.0",
    // ... set other properties like name, tags, etc.
});

// You need to set up the Kubernetes provider to interact with the OKE cluster
const k8sProvider = new kubernetes.Provider("oke-k8s-provider", {
    kubeconfig: cluster.kubeconfig, // This gets the kubeconfig from the created cluster
});

// Deploy the Helm chart using the Kubernetes provider configured for the cluster
const nginxHelmChart = new kubernetes.helm.v3.Chart("nginx-chart", {
    chart: "k8s-node-image-nginx9-1-21",
    // Specify the chart version if necessary
    version: "1.21.0", // replace with the desired version of your Helm chart
    // You may also need to specify a repository if the chart is not in the default Helm repo
    // repo: "https://charts.helm.sh/stable",
    namespace: "default", // specify the namespace where you want to deploy the Helm chart
    // If required, you can provide custom values to the Helm chart using `values` or `valueYamlFiles`
    // values: { /* ... */ },
}, { provider: k8sProvider });

// Export the cluster's kubeconfig
export const kubeconfig = cluster.kubeconfig;

// Use the cluster name and Helm chart status as stack exports
export const clusterName = cluster.name;
export const nginxHelmChartStatus = nginxHelmChart.status;
```

Let me break down what's happening in this code:

1. We start by importing the necessary modules from the Pulumi SDK.

2. We then declare an OKE cluster resource, where you would replace placeholders such as `YOUR_COMPARTMENT_ID` with the actual OCI identifiers you have. The `options` object within the cluster definition also needs details about your setup, including the specific subnets for the load balancer used by the Kubernetes services.

3. With the OCI cluster in place, we establish a Pulumi Kubernetes provider, which will allow us to interact with the newly created OKE cluster through its kubeconfig.

4. Lastly, we define our Helm chart deployment. Pulumi's `kubernetes.helm.v3.Chart` class is used to deploy the specific `k8s-node-image-nginx9-1-21` Helm chart. As mentioned, if the chart requires a custom Helm repository or any particular configurations, those need to be specified in the `chart` or `values` fields.

5. We finally export `kubeconfig`, `clusterName`, and `nginxHelmChartStatus`. The `kubeconfig` allows you to interact with your cluster using `kubectl` from your local machine if necessary. The `clusterName` can provide a handy reference to your cluster's name in the Pulumi stack, and `nginxHelmChartStatus` can be useful to understand the deployment status of the Helm chart.

Please replace the placeholders with your actual values before running this program using the Pulumi CLI. Once your code is ready, you can run `pulumi up` to execute it and set up your OKE cluster with the Nginx Helm chart.