Deploy the haproxytech-haproxy-ingress helm chart on Oracle Kubernetes Engine (OKE)

Question

Pulumi · Accepted Answer

To deploy the `haproxytech-haproxy-ingress` Helm chart on Oracle Kubernetes Engine (OKE), you need to perform a series of steps which include setting up the OKE cluster, configuring Kubernetes with Pulumi, and finally deploying the Helm chart.

Below I will guide you through the process.

Firstly, ensure you have the necessary prerequisites:
- An Oracle Cloud Infrastructure (OCI) account with proper IAM permissions.
- The OCI CLI installed and configured for your account.
- Pulumi CLI installed on your machine.
- Helm CLI installed for Helm chart management.

### Step 1: Set up OKE Cluster

Before deploying the Helm chart, you need an existing Kubernetes cluster on OKE. Pulumi doesn't directly provide an OKE cluster resource, but you can use the `oci` container engine resources to create and manage OKE clusters.

To set up the OKE cluster, you would typically use resources like `ContainerEngineCluster` to define your cluster and `NodePool` to define the characteristics of your worker nodes.

### Step 2: Configure Kubernetes Provider

Once your OKE cluster is up and ready, you will need to configure the Pulumi Kubernetes provider to interact with your cluster. This involves obtaining the kubeconfig file from your OKE cluster and setting the `kubeconfig` value for the Kubernetes provider.

### Step 3: Deploy Helm Chart

With Pulumi, you can deploy a Helm chart using the `Chart` resource in the `kubernetes` package, which manages the deployment of Helm charts in a Kubernetes cluster. You will specify the chart name `haproxytech-haproxy-ingress` alongside the necessary version and values you want to customize.

Here’s what the TypeScript Pulumi program may look like:

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

// OKE cluster is assumed to be created and kubeconfig obtained externally.
// The kubeconfig can be set as an environment variable or Pulumi config.

const chartName = "haproxy-ingress";
const chartVersion = "1.17.8"; // use the version you need
const chartRepo = "https://haproxytech.github.io/helm-charts";

// Initialize a Kubernetes provider with the kubeconfig obtained from your OKE cluster
const provider = new k8s.Provider("oke-k8s-provider", {
  kubeconfig: process.env.KUBECONFIG, // Replace with your kubeconfig or use Pulumi config
});

// Deploy the `haproxytech-haproxy-ingress` Helm chart
const haproxyIngressChart = new k8s.helm.v3.Chart(
  "haproxy-ingress",
  {
    chart: chartName,
    version: chartVersion,
    fetchOpts: {
      repo: chartRepo,
    },
    // Include necessary custom values
    values: {
      // Custom values to configure haproxy-ingress
    },
  },
  {
    provider: provider,
  }
);

// Export any necessary information, such as ingress endpoint
export const ingressHost = haproxyIngressChart.getResourceProperty(
  "v1/Service",
  "haproxy-ingress",
  "status"
).apply(status => status.loadBalancer.ingress[0].hostname);
```

In this program:
- We import the Kubernetes package from Pulumi.
- We assume you have already set up an OKE cluster and have its `kubeconfig`.
- We instantiate a `Provider` which tells Pulumi how to communicate with our Kubernetes cluster.
- We create a new `Chart` resource deployment for the `haproxy-ingress` chart from the haproxytech Helm repository.
- We export the ingress host, which can be used to access the HAProxy Ingress Controller once deployed.

Please replace `process.env.KUBECONFIG` with your kubeconfig content or with Pulumi configuration. This is how Pulumi will authenticate to your Kubernetes cluster.

After the program is ready:
1. Run `pulumi up` to preview and deploy the changes.
2. Confirm the deployment and wait for the resources to be created.
3. Check the output of the `pulumi up` command for the `ingressHost` which is your HAProxy Ingress Controller's external endpoint.

Once the deployment is successful, you should have the `haproxytech-haproxy-ingress` Helm chart deployed and running on your Oracle Kubernetes Engine cluster. You can then proceed to configure your ingress resources to route traffic to your applications.