Deploy the plausible-analytics helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

In order to deploy the Plausible Analytics Helm chart on Azure Kubernetes Service (AKS), you need to perform a few steps:

Provision an AKS cluster: This step involves creating the infrastructure necessary to host your Kubernetes services. This includes specifying the size and number of nodes, location, and other configuration details for your Kubernetes cluster.
Install and Configure Helm: Helm is a package manager for Kubernetes, which makes it easier for you to define, install, and upgrade even the most complex Kubernetes applications. Plausible Analytics can be deployed as a Helm chart, so you must have Helm installed in your cluster.
Deploy the Plausible Analytics Helm Chart: With your AKS cluster running and Helm installed, you can add the Plausible Analytics Helm chart repository and deploy the chart.

Below is a Pulumi program written in TypeScript that accomplishes the first and third steps mentioned above. Note that it assumes you have Pulumi and Azure CLI installed and configured.

import * as azure from "@pulumi/azure";
import * as k8s from "@pulumi/kubernetes";
import * as pulumi from "@pulumi/pulumi";

// Step 1: Provision an AKS Cluster
const resourceGroup = new azure.core.ResourceGroup("myResourceGroup", {
    location: "WestUS",
});

const aksCluster = new azure.containerservice.KubernetesCluster("myAksCluster", {
    // Replace with your own desired settings
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    agentPoolProfiles: [{
        name: "default",
        count: 3,
        vmSize: "Standard_D2_v2",
    }],
    dnsPrefix: "mykube",
    linuxProfile: {
        adminUsername: "adminuser",
        sshKey: {
            keyData: "<YOUR_SSH_PUBLIC_KEY>",
        },
    },
    servicePrincipal: {
        clientId: "<YOUR_SPN_CLIENT_ID>",
        clientSecret: "<YOUR_SPN_CLIENT_SECRET>",
    },
});

// Export the KubeConfig and Kubernetes provider is created using that KubeConfig
const creds = pulumi.all([aksCluster.name, resourceGroup.name]).apply(([clusterName, rgName]) => {
    return azure.containerservice.listKubernetesClusterUserCredentials({
        resourceGroupName: rgName,
        resourceName: clusterName,
    });
});

// This requires python and the 'requests' python package to fetch the kubeconfig
let encodedKubeConfig: pulumi.Output<string> = creds.kubeconfigs[0].value;
const kubeConfig = encodedKubeConfig.apply(enc => Buffer.from(enc, 'base64').toString());

// Create a Provider referencing the newly created cluster's kubeconfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeConfig,
});

// Step 2: Helm Installation is managed by Pulumi via the k8s.helm.v3.Chart resource
const plausibleAnalyticsChart = new k8s.helm.v3.Chart("plausible-analytics", {
    // Replace with the correct chart values
    chart: "plausible",
    version: "1.3.0", // Use the appropriate chart version
    fetchOpts: {
        repo: "https://helm.plausible.io/", // Use Plausible's Helm chart repository
    },
    // Specify necessary values that the chart requires
    values: {
        // Define your values here
    },
}, { provider: k8sProvider });

// Export the public IP address of the Plausible Analytics service
export const plausibleIp = plausibleAnalyticsChart
    .getResourceProperty("v1/Service", "plausible-analytics", "status")
    .apply(status => (status as any).loadBalancer.ingress[0].ip);

Explanation:

First, we define a resource group for our AKS cluster with the azure.core.ResourceGroup class. The location WestUS is specified; replace this with your preferred Azure region.
Next, an AKS cluster is defined with azure.containerservice.KubernetesCluster. You should replace placeholder values like <YOUR_SSH_PUBLIC_KEY>, <YOUR_SPN_CLIENT_ID>, and <YOUR_SPN_CLIENT_SECRET> with your actual SSH public key and Azure service principal credentials.
We then fetch the kubeconfig file for the AKS cluster using azure.containerservice.listKubernetesClusterUserCredentials, which will allow us to interact with the cluster using the Kubernetes API.
A Pulumi Kubernetes provider is created that uses the kubeconfig of the AKS cluster, enabling Pulumi to perform operations on the cluster.
For the Helm deployment (k8s.helm.v3.Chart), we specify the chart and version. Additionally, we point to the Helm repository where Plausible's charts are stored (https://helm.plausible.io/). Note that you need to replace the values with the appropriate configuration values for your Plausible Analytics setup.
Finally, we export the IP address that will be assigned to the Plausible Analytics service, allowing you to access it through the web browser once it's set up.

Please note that deploying third-party applications on Kubernetes can sometimes require the setup of additional services like databases or persistent storage, and may also need special configurations based on the application's requirements, so you should refer to the official documentation for Plausible Self Hosting for any such specifics.

Remember to check the exact version of the Plausible Analytics helm chart you wish to install, and update the version number in the script accordingly. You should also set the necessary values in the values field when you initialize the plausibleAnalyticsChart to configure Plausible Analytics according to your requirements.