Deploy the stateless helm chart on Linode Kubernetes Engine

Question

Pulumi · Accepted Answer

Deploying a Helm chart on the Linode Kubernetes Engine (LKE) using Pulumi requires you to setup a few things:

1. A Kubernetes cluster on the Linode platform.
2. Configuration to access the Kubernetes cluster.
3. The Helm chart to deploy, which in this case is stateless.

I will provide you with an example of how to do this using Pulumi with TypeScript.

Below is the Pulumi program that creates a new Kubernetes cluster on Linode and deploys a stateless Helm chart to it:

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

// Create a new LKE cluster with the desired configuration
const cluster = new linode.LkeCluster("my-lke-cluster", {
    k8sVersion: "1.20",
    region: "us-central",
    tags: ["pulumi-demo"],
    pools: [{
        count: 3,
        type: "g6-standard-2",
    }],
});

// Export the kubeconfig for the LKE cluster
export const kubeconfig = cluster.kubeconfig;

// Configure Pulumi to use the kubeconfig from the LKE cluster
const provider = new k8s.Provider("lke-k8s", {
    kubeconfig: cluster.kubeconfig,
});

// Deploy a stateless Helm chart using the k8s provider configured earlier
const nginx = new k8s.helm.v3.Chart("nginx", {
    chart: "nginx",
    version: "9.3.0",
    fetchOpts: { repo: "https://charts.bitnami.com/bitnami" },
}, { provider });

// Export the public IP of the nginx service
export const nginxIp = nginx.getResource("v1/Service", "nginx-nginx").status.apply(s => s.loadBalancer.ingress[0].ip);
```

### Explanation

- We use the Linode Pulumi provider to create a new Kubernetes cluster. The `region`, Kubernetes version (`k8sVersion`), and the node count and type (`pools`) are specified in the LKE cluster configuration.
- We export the kubeconfig from the created LKE cluster for Pulumi to communicate with the new cluster.
- The Kubernetes Pulumi provider is then instantiated, using the exported kubeconfig to gain access to the LKE cluster.
- A Helm chart is defined using the `Chart` resource from Pulumi's Kubernetes provider. This example uses the nginx chart from the Bitnami repository as a stateless Helm chart. The `fetchOpts` specify where to retrieve the Helm chart from.
- Lastly, the program exports the IP address of the nginx service, which will be the entry point for the nginx server once it's deployed on the Kubernetes cluster. This IP will be assigned after the load balancer is configured, which might take some time after the initial deployment.

This program will create the resources mentioned and should deploy the nginx Helm chart to your LKE cluster. After running this `pulumi up`, you can access the nginx service by visiting the IP address listed in the output of the `nginxIp`.

Make sure you have the Pulumi CLI installed and configured with your Linode access token before running this program. If you haven't already configured your Linode token, you can do so by running `pulumi config set linode:token YOUR_LINODE_API_TOKEN --secret`.

Furthermore, the Helm chart used in this code is just an example. You can replace the `nginx` in the `Chart` resource with the name of your stateless Helm chart and its respective repository inside `fetchOpts`.

Remember, running this Pulumi program will incur costs on Linode as it provisions actual resources. Make sure to shut down resources when they're not in use with `pulumi destroy` to avoid unnecessary charges.