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

Question

Pulumi · Accepted Answer

To deploy a database using a Helm chart on the Oracle Kubernetes Engine (OKE), you'll need to perform a series of steps. Here's an overview of the process and how Pulumi helps you achieve it:

1. **Set Up an Oracle Kubernetes Engine (OKE) Cluster**: First, you'll need a running OKE cluster where you can deploy your Helm chart. Pulumi can provision a new cluster if you don't already have one.

2. **Provision the Necessary Infrastructure**: Along with the OKE cluster, you may need other cloud resources such as a network or storage, depending on your specific database needs and the Helm chart requirements.

3. **Install the Helm Chart**: Once the infrastructure is ready, you can use Pulumi to install the Helm chart onto the OKE cluster.

For the purpose of this guide, I'll focus on the third step, assuming that you already have an OKE cluster running and configured. If this is not the case, you would first need to create and configure the cluster, which involves additional steps not covered here.

### Helm Charts
Helm charts are packages of pre-configured Kubernetes resources. To deploy applications on a Kubernetes cluster, Helm charts are a convenient way to package all required resources together. The Helm chart for a database would typically contain the Kubernetes manifests needed to set up the database service, including Deployments, Services, PersistentVolumeClaims, ConfigMaps, and others, as needed.

Below is a Pulumi program written in TypeScript that demonstrates how to deploy a database Helm chart onto an existing OKE cluster.

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

// The following config values need to be set via `pulumi config set`.
// We assume these configs are already set and do not use hard-coded values for sensitive data.
const config = new pulumi.Config();
const kubeconfig = config.requireSecret("kubeconfig");
const chartVersion = config.get("chartVersion") || "latest";
const databaseChartName = config.require("databaseChartName"); // e.g., "mysql" or "postgresql"

// Create a Pulumi Kubernetes Provider by using the existing kubeconfig for OKE
const clusterProvider = new k8s.Provider("oke-k8s", {
    kubeconfig: kubeconfig,
});

// Deploy the database Helm chart
const databaseRelease = new k8s.helm.v3.Chart("database-chart", {
    chart: databaseChartName,
    version: chartVersion,
    // You can specify the values for the Helm chart in the `values` property.
    // The following is just for illustration; refer to your Helm chart's documentation for actual values.
    values: {
        persistence: {
            enabled: true,
            size: "10Gi",
        },
    },
}, { provider: clusterProvider });

// Export the Database URL (you would want to grab this from the actual deployed resources such as a Service or Ingress)
export const databaseUrl = pulumi.interpolate`http://${databaseRelease.getResourceProperty("v1/Service", "database-service", "status").apply(status => status.loadBalancer.ingress[0].ip)}`;
```

### Explanation

- `@pulumi/pulumi`, `@pulumi/oci`, and `@pulumi/kubernetes` are Pulumi packages used to work with Pulumi, Oracle Cloud Infrastructure, and Kubernetes resources, respectively.

- `kubeconfig`: This is a configuration file used by Kubernetes to access the cluster. We assume this secret is set using Pulumi's configuration system for security reasons.

- `chartVersion` and `databaseChartName` are the Helm chart's version and the name you want to deploy, respectively. These are set through configuration to make the deployment more flexible.

- `clusterProvider`: A Kubernetes provider which is used to deploy resources into the cluster. It requires access to the cluster through the `kubeconfig`.

- `k8s.helm.v3.Chart`: This is a Pulumi resource that represents a Helm chart installation. We're installing a Helm chart that provisions a database. The `values` property contains the configuration values for the chart.

- `databaseRelease`: This is the name we give to our Helm chart release.

- The `pulumi.interpolate` syntax is used to export a value that includes outputs from other resources. We are creating a database URL by dynamically extracting the service's load balancer IP after the database service is provisioned. Note that the actual retrieval of the service IP depends on the specifics of the Helm chart used.

Remember to replace the placeholder values such as `"databaseChartName"`, and any other configuration values with actual data according to your use case. Validate the `values` property against your Helm chart's documentation for the correct configuration expected.

After writing this Pulumi program, deploy it by running `pulumi up` in the directory containing your `index.ts` file. This command compiles the TypeScript program, prompts for confirmation of the resources to be created, and applies the changes if confirmed. Make sure you have the required OCI provider configuration and credentials set in your environment.