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

Question

Pulumi · Accepted Answer

Deploying Helm charts on a Kubernetes cluster involves several steps. First, we need to have a Kubernetes cluster running and available. For Oracle Kubernetes Engine (OKE), we would establish the cluster using the OCI (Oracle Cloud Infrastructure) provider, but the details of creating the cluster are not included in the Pulumi Registry Results provided. Assuming you already have an OKE cluster, the following process involves setting up the Helm chart.

To deploy a Helm chart to an OKE cluster using Pulumi, we will use the `kubernetes.helm.sh/v3.Chart` Pulumi resource. This resource is a representation of a Helm chart in the Pulumi infrastructure-as-code framework. Helm is a package manager for Kubernetes that allows us to define, install, and upgrade applications using a Helm chart, which is essentially a collection of pre-configured Kubernetes resources.

Here's what the steps generally look like:

1. Ensure you have configured Pulumi to work with your OCI account and that the Kubernetes context is correctly set to interact with your OKE cluster.
2. Use the `kubernetes.helm.sh/v3.Chart` resource to deploy the DevLake Helm chart to your Kubernetes cluster.

Here's a TypeScript program that outlines these steps:

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

// Define the namespace where you want to deploy the devlake chart.
const namespaceName = 'devlake';

// Create a Kubernetes Namespace where the Helm chart will be deployed.
const ns = new k8s.core.v1.Namespace(namespaceName, {
    metadata: {
        // Name of the namespace
        name: namespaceName,
    },
});

// Deploy the DevLake Helm chart into the created namespace.
const devlakeChart = new k8s.helm.v3.Chart('devlake-chart', {
    chart: 'devlake', // This is the name of the chart. Replace it with the actual chart name if different.
    version: '0.1.0', // Specify the version of the chart you wish to deploy.
    namespace: namespaceName, // The namespace where the chart will be deployed.
    // If your chart requires custom values, specify them here, for example:
    values: {
        // Replace these with actual values required by the DevLake Helm chart.
        serviceType: 'LoadBalancer',
        externalPort: 80,
        internalPort: 8080,
        replicas: 3,
        // ... other values as needed
    },
}, { provider: myK8sProvider }); // Ensure you pass the proper K8s provider for your OKE cluster.

// Export the address of the DevLake service to access it externally.
export const devLakeServiceAddress = devlakeChart.getResourceProperty(
    'v1/Service', `${namespaceName}/devlake-service`, 'status').apply(status => status.loadBalancer.ingress[0].ip);

```

In the above code:

- We import the required Pulumi Kubernetes package.
- We create a Kubernetes namespace specifically for the `devlake` deployment, separating it from other services.
- We create a new Helm chart resource, indicating the chart name (`devlake`) and version. You must replace these values with the correct name and version of the DevLake Helm chart you wish to deploy.
- We specify the custom values required for the chart via the `values` field. Here you will define any configuration options that are specific to the DevLake Helm chart. These options vary from one Helm chart to another, so you'll need to refer to the documentation of the DevLake Helm chart for the appropriate values.
- The Kubernetes provider (`myK8sProvider`) is a placeholder to indicate that you should configure a provider that points to your OKE cluster. The actual instantiation of this provider would depend on your specific setup and how your Kubernetes context is configured.
- Lastly, we export the external IP address of the DevLake service, which is necessary to access the service once it's deployed.

Before running this program with Pulumi, make sure you've installed the Pulumi CLI, logged in, and set the correct Kubernetes context to point to your OKE cluster. This program assumes that your Pulumi setup and Kubernetes configuration are already appropriately set to interact with your OCI account and OKE cluster.

To execute this Pulumi program, you would typically run `pulumi up` in your shell, and Pulumi will handle the deployment process, providing you with a summary of the resources it will create, modify, or delete. Once you confirm the summary, Pulumi proceeds with the deployment. After the deployment is complete, it will output any exported values, such as the address of the DevLake service in this case.