Deploy the k8s-ingress helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To achieve the deployment of a Kubernetes Ingress Helm chart on DigitalOcean, we'll break down the process into the following steps:

1. **Provision a DigitalOcean Kubernetes Cluster**: We need a Kubernetes cluster where our Helm chart will be deployed. We'll use the `digitalocean.KubernetesCluster` resource to create this cluster.

2. **Install the Helm Chart with an Ingress Controller**: Helm is a package manager for Kubernetes that allows us to define, install, and upgrade Kubernetes applications. An Ingress controller is a specialized load balancer for Kubernetes environments and is provided through the Helm chart. We'll be using the `kubernetes.helm.v3.Chart` resource to deploy the Ingress controller into our cluster.

Let's go through the detailed Pulumi program written in TypeScript that accomplishes these steps:

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

// Step 1: Create a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("my-do-cluster", {
    region: "nyc3",
    version: "latest",
    nodePool: {
        name: "mypool",
        size: "s-2vcpu-2gb",
        nodeCount: 2,
    },
});

// Step 2: Deploy an Ingress-controller Helm chart
const helmChart = new k8s.helm.v3.Chart("nginx-ingress", {
    chart: "nginx-ingress",
    version: "1.41.3", // Use the appropriate version for the chart
    namespace: "default", // Kubernetes namespace to deploy the chart, 'default' or you can create or use a different one.
    fetchOpts: {
        repo: "https://helm.nginx.com/stable", // NGINX Ingress Helm repository URL
    },
    // Optional: you can provide additional configuration for your Helm chart
    // values: {
    //     controller: {
    //         service: {
    //             type: "LoadBalancer", // Service type LoadBalancer will expose your service externally.
    //         },
    //     },
    // },
}, { provider: new k8s.Provider("k8s-provider", { kubeconfig: cluster.kubeConfigs[0].rawConfig }) });

// Export the DigitalOcean Kubernetes cluster's kubeconfig and the Ingress service URL
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;
export const ingressUrl = helmChart.getResourceProperty("v1/Service", "default/nginx-ingress-controller", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

Let's break down what each section of this code is doing:

- We start by importing our required modules; `pulumi`, `digitalocean`, and `kubernetes` which is used for DigitalOcean and Kubernetes resources respectively.

- We create a new Kubernetes cluster on DigitalOcean with the desired region, version, node size, and node count using `digitalocean.KubernetesCluster`.

- We define a new Helm chart resource named `nginx-ingress` using `k8s.helm.v3.Chart`. The chart is the NGINX Ingress controller, which creates an Ingress resource for routing external traffic to services running inside our Kubernetes cluster. We specify the version of the Helm chart, the Kubernetes namespace to install our chart, and the location of the Helm repository from where we will fetch the chart.

- We define a Kubernetes provider named `k8s-provider` which requires the kubeconfig to communicate with our Kubernetes cluster. We retrieve the kubeconfig from the DigitalOcean Kubernetes cluster object we created.

- Finally, we export the `kubeconfig` and the `ingressUrl`, which will be the external IP through which we can contact the Ingress.

Running the above Pulumi program will give you a fully functional Kubernetes cluster on DigitalOcean, with an NGINX Ingress controller ready to handle traffic to your inside-cluster services.