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

Question

Pulumi · Accepted Answer

To deploy the LOGIQ Helm chart on Oracle Kubernetes Engine (OKE), you'll need to perform several steps using Pulumi in TypeScript:

1. Set up an OKE Cluster where you'll deploy the Helm chart.
2. Configure the Kubernetes provider to connect to your OKE cluster.
3. Use the Helm Chart resource to deploy LOGIQ to your cluster.

Below is a Pulumi program that carries out these steps. Please make sure that you have the necessary permissions and prerequisites ready, such as an Oracle Cloud Infrastructure account and the `oci` CLI configured.

Firstly, let's write a Pulumi program that provisions an OKE cluster:

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

// Create an Oracle Cloud Infrastructure provider.
const provider = new oci.Provider('oci', { /* ... */ });

// Create a new Virtual Cloud Network (VCN) for our Kubernetes cluster.
const vcn = new oci.core.Vcn('my-vcn', {
    compartmentId: oci.getCompartment().then(comp => comp.id),
    cidrBlock: '10.0.0.0/16',
}, { provider });

// Create a subnet for the OKE cluster nodes.
const subnet = new oci.core.Subnet('my-subnet', {
    compartmentId: oci.getCompartment().then(comp => comp.id),
    vcnId: vcn.id,
    cidrBlock: '10.0.1.0/24',
}, { provider });

// Create a Kubernetes cluster in OKE.
const cluster = new oci.containerengine.Cluster('my-cluster', {
    compartmentId: oci.getCompartment().then(comp => comp.id),
    vcnId: vcn.id,
    kubernetesVersion: 'v1.21.0', // Choose your desired Kubernetes version
    options: {
        serviceLbSubnetIds: [subnet.id],
    },
}, { provider });

// Export the kubeconfig of the cluster.
const kubeconfig = pulumi.all([cluster.id, cluster.endpoints]).apply(([clusterId, endpoints]) => {
    // Here you would generate your `kubeconfig` file content which you can use to communicate with your Kubernetes cluster.
});

// We need to export `kubeconfig` so we can easily access it.
export const kubeConfigOutput = kubeconfig;
```

Now that we've set up an OKE cluster, let's deploy the LOGIQ Helm chart to it:

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

// Use the kubeconfig to create a Kubernetes provider instance.
const kubeProvider = new k8s.Provider('okeK8s', {
    kubeconfig: kubeConfigOutput, // This comes from the cluster's exported kubeconfig
});

// Deploy the LOGIQ helm chart using the Helm Chart resource.
const logiqChart = new k8s.helm.v3.Chart('logiq', {
    chart: 'logiq',
    version: '1.2.3', // Use the specific version you want to deploy
    fetchOpts: {
        repo: 'https://helm.logiq.ai/', // Make sure this is the correct Helm repository URL for LOGIQ
    },
}, { provider: kubeProvider });

// We can export the status of the deployed Helm chart. For instance, if there's a LoadBalancer service in your chart, you may want to export the IP.
export const logiqChartStatus = logiqChart.status;
```

In this program:

- We first set up an OKE cluster, complete with a VCN and a Subnet.
- We then configure the Kubernetes provider in Pulumi to use the generated `kubeconfig` from the created OKE cluster.
- Next, we define a Helm chart resource, which points to the LOGIQ chart in its Helm repository.
- The `version` field specifies the version of the chart you want to deploy; this should be set to the desired version number.
- We then export the status of the Helm chart, which might contain vital information such as LoadBalancer IP if your chart exposes a service.

After you've written and reviewed the code, you can deploy it using the Pulumi CLI:

1. Run `pulumi up` from your command line in the directory with this code to create the resources.
2. Use `kubectl` with the exported `kubeconfig` to interact with your cluster, ensuring LOGIQ is deployed.

Remember to replace placeholder values like `compartmentId`, `version`, and repository URL with actual values from your Oracle Cloud Infrastructure environment and the LOGIQ Helm chart specifics.