Deploy the clickhouse-cluster helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the ClickHouse cluster using a Helm chart on Azure Kubernetes Service (AKS), we will proceed with the following steps:

1. Create an Azure Kubernetes Service (AKS) cluster.
2. Install and Configure Helm on your local machine.
3. Create a Kubernetes namespace for the ClickHouse cluster.
4. Use Helm to deploy the ClickHouse Helm chart into the AKS cluster.

The resources we'll use are:

- `azure-native.hybridcontainerservice.ProvisionedCluster`: This is to create an AKS cluster where our applications will run.
- `kubernetes.helm.v3.Chart`: This abstracts the Helm operations in Pulumi and allows us to deploy Helm charts. We will use this to deploy the ClickHouse Helm chart.

Below is a TypeScript program that demonstrates how to perform these steps using Pulumi:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azureNative from "@pulumi/azure-native";
import * as k8s from "@pulumi/kubernetes";

// Step 1: Provision an AKS cluster
const resourceGroupName = new azureNative.resources.ResourceGroup("rg", {
    location: "westus",
});
const aksCluster = new azureNative.hybridcontainerservice.ProvisionedCluster("aksCluster", {
    resourceGroupName: resourceGroupName.name,
    location: resourceGroupName.location,
    properties: {
        kubernetesVersion: "1.18.14", // Use an appropriate version
        enableRbac: true,
        agentPoolProfiles: [{
            name: "agentpool",
            count: 3, // Number of nodes
            vmSize: "Standard_D2_v2" // Size of nodes
        }],
        dnsPrefix: "clickhouse-cluster",
        // Other necessary properties...
    },
});

// Create a Kubernetes provider instance using the kubeconfig from the generated AKS cluster
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: aksCluster.kubeConfigRaw,
});

// Step 2: Install and configure Helm on your local machine.
// This is a manual step you would take outside of Pulumi.
// Ensure that Helm is installed and configured to interact with your Kubernetes cluster.

// Step 3: Create a Kubernetes namespace for the ClickHouse cluster
const namespace = new k8s.core.v1.Namespace("clickhouse-namespace", {
    metadata: { name: "clickhouse" },
}, { provider: k8sProvider });

// Step 4: Deploy ClickHouse using Helm chart
const clickhouseChart = new k8s.helm.v3.Chart("clickhouse-cluster", {
    chart: "clickhouse",
    version: "1.1.0", // Specify the version of the ClickHouse Helm chart
    fetchOpts: {
        repo: "https://clickhouse.github.io/charts", // Official ClickHouse Helm chart repo URL
    },
    namespace: namespace.metadata.name,
    // include values to configure ClickHouse
}, { provider: k8sProvider });

// Export the kubeconfig to access the cluster
export const kubeconfig = aksCluster.kubeConfigRaw;
```

Before running this program, you need to have Pulumi CLI installed and configured to access your Azure account. Additionally, make sure Helm is installed on your machine to interact with Kubernetes.

Here's what each part of the program does:

- The AKS cluster is set up with RBAC enabled, a DNS prefix for the API server, and a pool of 3 virtual machines as nodes.
- We create a Kubernetes provider that understands how to communicate with the AKS cluster using the generated kubeconfig.
- Next, we set up a Kubernetes namespace specifically for the ClickHouse services.
- Finally, we declare a Helm chart resource targeting that namespace which references the ClickHouse Helm chart. The `Chart` resource in Pulumi encapsulates Helm's behavior.

To run this Pulumi program:

1. Save the code to a file with a `.ts` extension, for example, `aksClickhouse.ts`.
2. Run `pulumi up` in the same directory as your file to create the resources.
3. You will be prompted to review the changes before they are applied. After you approve them, Pulumi will provision the resources.
4. Once provisioning is complete, you can use the exported `kubeconfig` to interact with your AKS cluster.

Remember, before deploying, to adjust the versions and settings to match your specific requirements and always review the default values in Helm charts to ensure that they fit your needs.