Deploy the ngrok-ingress-controller helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the `ngrok-ingress-controller` Helm chart on the Digital Ocean Kubernetes Service using Pulumi, you'll need to perform these high-level tasks:

1. Provision a DigitalOcean Kubernetes cluster.
2. Install the ngrok-ingress-controller Helm chart within the Kubernetes cluster.

Here is a brief explanation of each step:

1. **Provision a DigitalOcean Kubernetes Cluster**: You'll start by creating a Kubernetes cluster on Digital Ocean using the `@pulumi/digitalocean` provider.

2. **Install Helm Chart**: With the cluster provisioned, you will then utilize the `@pulumi/kubernetes` provider to deploy the `ngrok-ingress-controller` using the `Chart` resource from the Helm package. This is akin to running `helm install` command on a kubeconfig-configured terminal but declaratively within Pulumi. Do note that we assume `ngrok-ingress-controller` is available in a Helm repository; you would need to specify the repository or local chart path accordingly.

Let's implement this step-by-step in Pulumi TypeScript. Please ensure that you have installed the Pulumi CLI and configured your Pulumi account.

Here's the complete Pulumi program that you can use to deploy the `ngrok-ingress-controller` Helm chart on the Digital Ocean Kubernetes Service:

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

// Step 1: Provision a DigitalOcean Kubernetes Cluster
const cluster = new digitalocean.KubernetesCluster('do-cluster', {
    region: 'nyc3', // Use a region that is more convenient for you
    version: '1.22.4-do.0', // Specify the version of Kubernetes
    nodePool: {
        name: 'default-pool',
        size: 's-2vcpu-2gb', // Specify the size of the Droplet
        nodeCount: 2, // Specify the desired number of nodes in the node pool
    },
});

// Step 2: Deploy the ngrok-ingress-controller Helm chart
// We need to use a kubeconfig that Pulumi can use to communicate with our new Kubernetes cluster
const kubeconfig = cluster.kubeConfigs[0].rawConfig.apply(JSON.stringify);

// Create a provider to manage resources in the new cluster using the kubeconfig
const k8sProvider = new k8s.Provider('do-k8sProvider', {
    kubeconfig: kubeconfig,
});

// Now we'll install the ngrok-ingress-controller Helm chart into the DigitalOcean cluster
// Ensure you have the correct repo and chart name
const ngrokIngressControllerChart = new k8s.helm.v3.Chart('ngrok-ingress-controller', {
    chart: 'ngrok-ingress-controller', // The name of the chart
    // You must specify the repository where the chart is located if it's not in the default Helm repo
    // For example: repo: "http://example.com/helm-charts",
    version: '1.0.0', // Replace with the specific chart version you want to deploy
    // If needed, you can pass custom values to the Helm chart
    // values: {
    //    key: "value",
    // },
}, { provider: k8sProvider });

// Exports
export const kubernetesClusterName = cluster.name;
export const kubernetesClusterNodeCount = cluster.nodePool.nodeCount;
export const ngrokIngressControllerChartName = ngrokIngressControllerChart.metadata.apply(m => m.name);
```

This Pulumi program creates a Kubernetes cluster on DigitalOcean and deploys the `ngrok-ingress-controller` Helm chart. Remember to replace placeholders such as version numbers, chart repository, and custom values with relevant information pertaining to your use case.

You can place this code in a file named `index.ts` and run `pulumi up` to execute it. Pulumi will communicate your desired state to DigitalOcean and Kubernetes, managing the resources as specified.

The export statements at the end of the script will print out the names of the created Kubernetes cluster and Helm chart release, which can be accessed outside the script, once successfully deployed.