Deploy the pi-hole helm chart on Digital Ocean Kubernetes Service

Question

Pulumi · Accepted Answer

To deploy the Pi-hole Helm chart on Digital Ocean Kubernetes Service, we'll perform the following steps:

1. Provision a Kubernetes cluster using the DigitalOcean provider in Pulumi.
2. Deploy Pi-hole using the Helm chart resource provided by the Kubernetes provider in Pulumi.

### Provisioning a DigitalOcean Kubernetes Cluster

First, we'll create a DigitalOcean Kubernetes cluster. We'll need to specify the region, the version of Kubernetes, and details about the node pool, which includes the node size, name, and how many nodes we want in the pool.

### Deploying Pi-hole via Helm Chart

Once we have our Kubernetes cluster ready, we'll use the `helm.sh/v3.Chart` resource to deploy Pi-hole. Helm allows us to easily deploy applications on a Kubernetes cluster. The Pi-hole Helm chart will be obtained from its repository and deployed into our newly-created DigitalOcean Kubernetes cluster.

You'll need to have `@pulumi/digitalocean` and `@pulumi/kubernetes` Node.js packages installed for this program to work. You can install them using:

```sh
npm install @pulumi/digitalocean @pulumi/kubernetes
```

Now here's the complete Pulumi program in TypeScript:

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

const name = "pihole-k8s"; // Use a unique name for the cluster

// Create a DigitalOcean Kubernetes cluster
const cluster = new digitalocean.KubernetesCluster(name, {
    region: digitalocean.Regions.NYC1,
    version: "1.21.5-do.0", // Use the latest version supported by DigitalOcean
    nodePool: {
        name: "default",
        size: "s-2vcpu-2gb", // Node size specification according to your needs
        nodeCount: 2, // Number of nodes in the node pool
    },
});

// Create a Kubernetes Provider pointing to the created cluster
const k8sProvider = new kubernetes.Provider(name, {
    kubeconfig: cluster.kubeConfigs[0].rawConfig,
});

// Deploy Pi-hole using the Helm chart
const piholeChart = new kubernetes.helm.v3.Chart("pihole", {
    chart: "pihole",
    version: "1.8.19", // Use the version of the Helm chart you wish to deploy
    fetchOpts: {
        repo: "https://mojo2600.github.io/pihole-kubernetes/", // The repository URL where the Helm chart is located
    },
}, { provider: k8sProvider });

// Export the public IP or domain name of the Pi-hole instance for easy access
export const piholeAccessUrl = cluster.services.apply(services =>
    `${services[0].status.loadBalancer.ingress[0].ip}/admin/` // Adjust the path according to Pi-hole Helm chart values and access method
);

```

### What the Program Does

- **Kubernetes Cluster Provisioning**: We define a DigitalOcean Kubernetes cluster by specifying the desired region, Kubernetes version, and node pool configuration. Here we use `s-2vcpu-2gb` as the node size and request 2 nodes in our default node pool.

- **Kubernetes Provider Setup**: We create a Kubernetes Provider that knows how to communicate with the Kubernetes cluster we provisioned. It uses `kubeconfig` from the cluster's output to get the necessary connection information.

- **Helm Chart Deployment**: Using the Pi-hole Helm chart, we deploy Pi-hole to our Kubernetes cluster. The `chart` and `version` fields specify the Helm chart we desire, and the `fetchOpts.repo` is the URL of the Helm repository that hosts the Pi-hole chart.

- **Access URL Export**: Finally, we export an access URL which can be used to access the Pi-hole's web admin interface once it's deployed and running.

### How to Use This Program

Save this code in a file with a `.ts` extension, for example, `deployPiHole.ts`. Assure that Pulumi CLI is installed and configured for use with DigitalOcean.

You can then run the following commands:

1. Navigate to the directory containing your Pulumi program.
2. Run `pulumi up` to preview and deploy the changes. If prompted, choose to create a new stack, which is an isolated environment for your project.
3. Once deployed, Pulumi will give you the access URL as an output.

Please note that the above example assumes that you are familiar with Pulumi, how to set it up, and how to manage its stacks and other configurations. It also assumes you have a DigitalOcean token set up in your environment or Pulumi configuration. If not, you'll need to set it up before running this program.