Deploy the whatweb helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the "whatweb" Helm chart on DigitalOcean's Kubernetes Service (DOKS), we'll follow these steps within our Pulumi TypeScript program:

1. Provision a DigitalOcean Kubernetes Cluster.
2. Deploy the "whatweb" Helm chart onto the DigitalOcean cluster.

### Prerequisites

- Ensure you have the [Pulumi CLI installed](https://www.pulumi.com/docs/get-started/install/).
- Ensure you have the necessary DigitalOcean API token set up and [configured](https://www.pulumi.com/docs/intro/cloud-providers/digitalocean/setup/) with Pulumi.
- You also need to have `kubectl` installed to interact with the cluster, and Helm `v3` if you need to customize Helm charts locally.

### Creating DigitalOcean Kubernetes Cluster

First, we need to set up the DigitalOcean Kubernetes cluster. We will use Pulumi's DigitalOcean provider to create a new cluster with a specified node size and count. Here we choose a small node size (`s-1vcpu-2gb`) for the example; you should choose the size appropriate for your expected workload.

### Deploying the Helm Chart

Once the cluster is provisioned, we'll use Pulumi's Kubernetes provider to deploy the "whatweb" Helm chart. Helm charts are packages for Kubernetes resources, and they allow for easy installation and management of applications on Kubernetes.

Here's a step-by-step explanation of the code:

- We import the necessary packages.
- We create a new DigitalOcean Kubernetes cluster.
- We configure Kubernetes provider to use the kubeconfig from the newly created DOKS cluster.
- We deploy the "whatweb" Helm chart into our DOKS cluster using the `Chart` resource.

Let's take a look at how the Pulumi program would look:

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

// Create a DigitalOcean Kubernetes cluster.
const cluster = new digitalocean.KubernetesCluster('do-cluster', {
    region: digitalocean.Regions.NYC1,
    version: '1.21.5-do.0',
    nodePool: {
        size: 's-1vcpu-2gb',
        nodeCount: 2,
    },
});

// Export the DigitalOcean Kubeconfig.
export const kubeconfig = cluster.kubeConfigs[0].rawConfig;

// Create a Kubernetes Provider instance that uses our cluster from above.
const k8sProvider = new k8s.Provider('k8s-provider', {
    kubeconfig: kubeconfig,
});

// Define the "whatweb" Helm chart resource.
const whatwebChart = new k8s.helm.v3.Chart('whatweb-chart', {
    chart: 'whatweb',
    // You should replace 'example-repo' with the actual repo of the chart.
    // If the chart is from Helm stable charts, no need to specify the repo.
    fetchOpts: {
        repo: 'https://charts.example.com/',
    },
    version: '1.2.3', // Specify the version of the chart you want to deploy.
    namespace: 'default',
}, { provider: k8sProvider });

// Export the whatweb endpoint once the chart is deployed and the service is available.
export const whatwebEndpoint = whatwebChart.getResourceProperty('v1/Service', 'whatweb', 'status').apply(status => {
    const ingress = status.loadBalancer.ingress[0];
    if (ingress.ip) {
        return `http://${ingress.ip}`;
    }
    return undefined;
});
```

In this Pulumi program:

- We export `kubeconfig`, so after provisioning the cluster, you can use this kubeconfig to manage the Kubernetes cluster with `kubectl`.
- We create a `k8s.Provider` that establishes the connection to the DigitalOcean Kubernetes cluster by utilizing the generated `kubeconfig`. This provider will be used for any Kubernetes resource we want to manage in this cluster.
- The Helm chart for "whatweb" is defined using the `k8s.helm.v3.Chart` resource. We specify the chart name, version, and the Helm repository URL if it's a custom one (Note: You would need to provide the actual repository URL where the "whatweb" chart is located).
- We export `whatwebEndpoint`, which will give us the public IP address of the LoadBalancer once it's deployed. You can then use this IP to access the "whatweb" application.

Please replace placeholder values like `https://charts.example.com/` with the actual Helm chart repository URL and ensure the `version` matches the desired version of the "whatweb" Helm Chart.

After creating your `index.ts` file containing the above Pulumi program, run the following commands to deploy the cluster and the helm chart:

```bash
pulumi up
```

This command will show you the proposed changes before applying them. After reviewing, confirm the prompt to proceed with the deployment. Once it's done, you will get the output of the `whatwebEndpoint`, which you can use to access your deployed "whatweb" application.