Deploy the krakend helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the KrakenD API Gateway using a Helm chart on Digital Ocean Kubernetes Service with Pulumi, you'll need to perform two main steps:

1. Provision a Digital Ocean Kubernetes (DOKS) cluster.
2. Deploy the KrakenD Helm chart to this cluster.

### Provisioning a Digital Ocean Kubernetes Cluster

To provision a DOKS cluster, we use the `digitalocean.KubernetesCluster` resource. This resource allows you to create, update, and manage a Kubernetes cluster on Digital Ocean. We need to specify the region, version, name, and node pool configuration, among other potential settings.

### Deploying the Helm Chart

For the deployment of the Helm chart, we use the resource `kubernetes.helm.v3.Chart`. Pulumi's Kubernetes provider has support for Helm, Kubernetes' package manager, which allows us to deploy pre-packaged applications as Helm charts. `Chart` is a resource type that can deploy a Helm chart from a repository, where we specify the chart name and version, as well as any custom values we might want to inject into the chart.

Let's begin by writing the Pulumi TypeScript program that executes these steps:

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

// Create a new DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster("my-do-cluster", {
    // Specify the region for your cluster
    region: "nyc3",
    
    // Specify the Kubernetes version, using a supported version from DigitalOcean's offerings
    version: "1.21.5-do.0",
    
    // Define a node pool with desired configuration
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb",
        nodeCount: 2,
    },
});

// Obtain the Kubeconfig from the cluster, which we'll use to create a provider
const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Create a Kubernetes provider instance using the above kubeconfig
const k8sProvider = new k8s.Provider("do-k8s-provider", {
    kubeconfig,
});

// Define the Helm chart for KrakenD
const krakendChart = new k8s.helm.v3.Chart("krakend", {
    // Replace with the correct repo and chart names, if different
    chart: "krakend",
    version: "1.0.0", // Replace with the version you wish to deploy
    fetchOpts: {
        repo: "https://charts.example.com/", // Replace with KrakenD's Helm chart repository URL
    },
}, { provider: k8sProvider });

// Export the cluster's kubeconfig and endpoint
export const kubeconfigOutput = kubeconfig;
export const clusterEndpoint = cluster.endpoint;
```

Here's what each section of the program does:

- We start by importing the necessary packages from Pulumi for handling the DigitalOcean service and Kubernetes.
- We create a Kubernetes cluster on DigitalOcean with a specified region, version, and node pool size.
- We get the kubeconfig of the cluster which is needed to communicate with the cluster using the Kubernetes API.
- We instantiate the Kubernetes provider with the kubeconfig.
- We declare a `Chart` resource, which deploys the KrakenD Helm chart to our Kubernetes cluster. You need to replace the `repo` and `version` to match the Helm repository holding the KrakenD chart.

Remember to replace the placeholder values in `repo` and `version` with the actual values for the KrakenD Helm chart. You can typically find these in the documentation of the chart or its repository.

Lastly, we export the kubeconfig and the endpoint of the cluster, which can be helpful for accessing the cluster from your local machine for debugging or management purposes.

Once you run this program with Pulumi, it will provision a new DigitalOcean Kubernetes cluster and deploy the KrakenD Helm chart to it. You'll be able to use the KrakenD API Gateway to manage your services' APIs immediately after deploying.