Deploy the simple-nginx helm chart on Linode Kubernetes Engine

Question

Pulumi · Accepted Answer

To deploy the `simple-nginx` Helm chart on the Linode Kubernetes Engine (LKE) using Pulumi, we'll perform a few steps:

1. Set up a new Pulumi project specifically for TypeScript.
2. Install necessary Pulumi packages for Kubernetes and Linode.
3. Write TypeScript code to provision an LKE cluster.
4. Deploy the `simple-nginx` Helm chart onto the LKE cluster.

Before the TypeScript code, let's initialize a new Pulumi project if you haven't done that already:

```shell
pulumi new typescript
```

This creates a new Pulumi project with a default `index.ts` file which we will edit to include our code.

You'll need to install the Pulumi Kubernetes package as a dependency to your project to utilize Kubernetes-related resources:

```shell
pulumi plugin install resource kubernetes v4.4.0
npm install @pulumi/kubernetes
```

Similarly, you need to manage Linode resources using the Pulumi Linode package:

```shell
pulumi plugin install resource linode v3.11.0
npm install @pulumi/linode
```

Now we can write the TypeScript code. We'll assume that you have already set up the Pulumi Linode provider for your environment. If not, you can do so by signing up for Linode, generating an API token, and configuring the Pulumi provider.

Below is the TypeScript program that creates an LKE cluster and deploys the `simple-nginx` Helm chart on it.

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

// This is the main Pulumi program entry point.

// Create a new Linode Kubernetes Engine cluster with the desired configurations.
const cluster = new linode.LkeCluster("my-lke-cluster", {
    // Specify the region where the cluster is to be provisioned.
    region: "us-central",
    // Choose the Kubernetes version to use.
    k8sVersion: "1.22",
    // Configure the node pool according to your requirements.
    nodePools: [{
        type: "g6-standard-2", // or choose any other available type
        count: 2, // the number of nodes to initialize
    }],
});

// Once the cluster is provisioned, we can output the kubeconfig generated by Linode.
export const kubeconfig = cluster.kubeconfig;

// Now we will proceed to deploy the Helm chart on the newly created cluster.
// To do this, we need to use the kubeconfig provided by Linode to interact with our cluster.
const provider = new k8s.Provider("lke-k8s-provider", {
    kubeconfig: cluster.kubeconfig,
});

// Deploy the `simple-nginx` Helm chart.
const nginxChart = new k8s.helm.v3.Chart(
    "simple-nginx",
    {
        // The repo and chart name where the Helm chart can be found.
        repo: "bitnami", // Or change to the correct Helm repository
        chart: "nginx",
        version: "9.3.0", // Specify the version of the chart to deploy
        // You can also customize values for chart configurations and customizations.
        values: {
            service: {
                type: "LoadBalancer",
            },
        },
    },
    { provider }
);

// Export the public IP of the nginx service.
// As services can take some time to get an external IP assigned,
// this value might appear as "pending" in Pulumi outputs until it's available.
export const nginxPublicIp = nginxChart.getResourceProperty(
    "v1/Service",
    "simple-nginx-nginx",
    "status"
).apply(status => status.loadBalancer.ingress[0].ip );
```

Let's walk through the code:

- We import the Pulumi packages for Kubernetes and Linode at the top of the file.
- We define a `cluster` as a Linode Kubernetes Engine cluster with specified settings. These include specifying the region, Kubernetes version, and details about the node pool such as type and node count.
- We export the generated `kubeconfig`, which allows us to interact with our Kubernetes cluster.
- We create a Pulumi Kubernetes provider, `provider`, which uses this `kubeconfig`. This provider will be used to deploy the `simple-nginx` Helm chart.
- We declare a new `Chart` resource, `nginxChart`, and specify the repository, chart name, version, and values that we want to customize for the Helm release. Here, we set the service type as `LoadBalancer`, which will provision an external IP for the Nginx service.
- We export the public IP assigned to the Nginx service, which you can use to access your Nginx server once it's deployed and the LoadBalancer has assigned an external IP.

Once you have this program complete, you can deploy your infrastructure with the following command:

```shell
pulumi up
```

After confirming, Pulumi will provision the LKE cluster, deploy the Helm chart, and output the public IP once assigned. The process usually takes some time, especially for the LoadBalancer service to receive an external IP address. You can use the exported `nginxPublicIp` value to access your Nginx server from the internet once it’s up and running.