Deploy the sdncontroller helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Oracle Kubernetes Engine (OKE) using Pulumi involves several steps. We'll start by setting up an OKE cluster and then we'll proceed with installing the `sdncontroller` Helm chart on it.

First, you need an OCI Container Repository to store your Docker images and Helm charts. Using Pulumi, we can define a repository in the OCI registry. However, note that in this example, we won't perform actual image or Helm chart uploads - we're focusing on infrastructure setup required before you manually push or configure your CI/CD system for pushes.

Here is an example Pulumi program that will set up an OKE cluster and deploy the `sdncontroller` Helm chart on it. Please ensure that the `sdncontroller` Helm chart is available in a repository that is accessible from your OKE cluster.

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

// Initialize OCI provider configuration
const config = new pulumi.Config();
const compartmentId = config.require("compartmentId"); // Your OCI Compartment ID where resources will be created

// Create a new OKE cluster
const okeCluster = new oci.containerengine.Cluster("okeCluster", {
    // Required properties here. For the purpose of this program, these will be dummy values.
    // In a real-world scenario, you would replace them with actual valid configurations.
    name: "my-oke-cluster",
    compartmentId: compartmentId,
    kubernetesVersion: "v1.20.8",
    vcnId: "ocid1.vcn.oc1..example", // Replace with actual VCN ID
    options: {
        serviceLbConfig: {
            subnetIds: ["ocid1.subnet.oc1..example"] // Replace with actual subnet OCIDs
        },
    },
});

// Once the OKE cluster is provisioned, we can configure the Kubernetes provider to connect to it
const k8sProvider = new k8s.Provider("okeK8sProvider", {
    kubeconfig: okeCluster.kubeconfig,
});

// Now let's deploy the `sdncontroller` Helm chart
const sdnControllerChart = new k8s.helm.v3.Chart("sdnController", {
    chart: "sdncontroller",
    // Assuming `sdncontroller` chart is hosted in a Helm repository, you would specify its URL here.
    // repo: "http://helm-repository-example.com/")
    // If the chart requires any values overrides, you specify them here.
    // values: {
    //     someKey: "someValue",
    // },
}, { provider: k8sProvider });

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

Before you run this Pulumi program, you need to ensure all prerequisites are met:

1. Pulumi CLI installed and set up.
2. Oracle Cloud Infrastructure (OCI) CLI installed and configured with the appropriate credentials.
3. Necessary OCI resources like Compartment, Virtual Cloud Network (VCN), and subnets should exist, or you can create them using Pulumi as part of the infrastructure setup.

The program above does the following:

- Imports Pulumi's SDKs for both OCI and Kubernetes.
- Reads configuration from the pulumi config, specifically the compartment ID which is required to create resources in OCI.
- Establishes an Oracle Kubernetes Engine (OKE) cluster with the required properties such as the name, compartment ID, Kubernetes version, and networking details.
- Configures the Kubernetes provider to interact with the OKE cluster using the kubeconfig property, which allows us to interact with the cluster as soon as it's available.
- Deploys the `sdncontroller` Helm chart using the Helm Chart resource within the Kubernetes provider context. It assumes that the chart is available in a Helm repository (you would replace placeholders with actual values for the `repo` and any `values` needed by the Helm chart).
- Exports the kubeconfig of the created cluster so that you can interact with your OKE cluster using `kubectl`.

To apply this Pulumi program, save the code to a `index.ts` file in a new Pulumi project directory. Run `pulumi up` within the same directory from your command line to create the resources. After your infrastructure has been provisioned, you can access your Kubernetes cluster using the kubeconfig that was exported by the program.