Deploy the haproxytech-haproxy-ingress helm chart on Linode Kubernetes Engine

Question

Pulumi · Accepted Answer

To deploy the `haproxytech-haproxy-ingress` Helm chart on Linode Kubernetes Engine using Pulumi, we'll take the following steps, assuming you have already set up your Linode account and installed appropriate CLI tools:

1. **Setting up Linode Kubernetes Engine(LKE) Cluster**: We will create a Linode Kubernetes cluster in which we will deploy the HAProxy ingress controller.
2. **Installing the Helm Chart**: Once the cluster is ready, we will utilize the Pulumi Kubernetes provider to install the `haproxytech-haproxy-ingress` Helm chart.

Below, you'll find a detailed Pulumi TypeScript program that creates a Linode Kubernetes Engine cluster and then deploys the Helm chart. Please note that you must have Pulumi CLI installed and be logged in to use this code.

Firstly, we import the necessary Pulumi packages:

- `@pulumi/linode` to create and manage resources in Linode.
- `@pulumi/kubernetes` to interact with the Kubernetes cluster and deploy Helm charts.

### Detailed Pulumi TypeScript Program

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

// Create a Linode Kubernetes Engine (LKE) cluster
const cluster = new linode.LkeCluster("my-lke-cluster", {
    k8sVersion: "1.22", // Specify your desired Kubernetes version
    region: "us-central", // Choose the Linode region
    pools: [{
        type: "g6-standard-2", // Choose the Linode instance type for your LKE nodes
        count: 3, // Number of nodes in the node pool
    }]
});

// Get the kubeconfig for the new cluster once it's ready
const kubeconfig = cluster.kubeconfig.apply(kc => kc.rawConfig);

// Create a Kubernetes provider instance using the kubeconfig from LKE
const k8sProvider = new k8s.Provider("lkeProvider", {
    kubeconfig: kubeconfig,
});

// Deploy the HAProxy Ingress Controller using the Helm chart
const haproxyIngress = new k8s.helm.sh.v3.Chart("haproxy-ingress", {
    chart: "haproxy-ingress",
    version: "1.17.10", // Specify the version of the chart you want to deploy
    fetchOpts: {
        repo: "https://haproxytech.github.io/helm-charts", // The repository URL where the chart is located
    },
    // If needed, you can specify values to customize the deployment
    values: {
        controller: {
            kind: "DaemonSet",
            hostNetwork: true,
            service: {
                type: "LoadBalancer",
            },
        },
    },
}, { provider: k8sProvider });

// Export the external IP of the HAProxy Ingress LoadBalancer Service
export const ingressIp = haproxyIngress
    .getResourceProperty("v1/Service", "haproxy-ingress-controller", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
```

### Explanation

- `linode.LkeCluster`: Here, we are defining a new LKE cluster with the specified version and node pool settings. Adjust `region`, `k8sVersion`, and the linode type (`type`) as needed for your specific deployment.
- `cluster.kubeconfig.apply(...)`: We're extracting the raw kubeconfig for the newly created LKE cluster, which is needed to interact with the cluster.
- `new k8s.Provider("lkeProvider", ...)`: This creates a new Kubernetes provider that Pulumi will use to deploy resources to the LKE cluster using the kubeconfig we obtained earlier.
- `new k8s.helm.sh.v3.Chart("haproxy-ingress", ...)`: This code defines the deployment of the HAProxy ingress controller using its Helm chart. You can customize the `values` field as necessary based on the configurations available for the HAProxy Ingress Controller Helm chart. 
- `export const ingressIp`: This line is exporting the IP address of the LoadBalancer that fronts the HAProxy ingress. You can use this IP to access the ingress once it is deployed.

In the `haproxyIngress` definition, `.apply` is a method that allows you to extract and use properties of resources that aren't known until runtime, such as load balancer IPs.

Remember that before running the program, you should set up your Pulumi project and stack. This process will include installing the Pulumi CLI, setting up your Linode API token as an environment variable or a Pulumi secret, and running `pulumi up` to launch and manage your infrastructure.