Deploy the databend-query helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `databend-query` Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, we’ll go through several steps:

1. Provision an AKS cluster.
2. Install the Helm Chart into the AKS cluster.

Before running the code, ensure you have the Azure provider configured with the necessary credentials. This setup assumes you have installed Pulumi and have an Azure subscription.

### Provisioning the AKS Cluster

First, we’ll provision an AKS cluster. We'll be using the `azure-native.hybridcontainerservice.ProvisionedCluster` resource for this purpose. This resource allows you to create a fully configured AKS cluster. The cluster configuration includes setting up node pools, Kubernetes version, and enabling features such as RBAC. You would begin by defining the node pool, including details such as the VM size for the nodes and the number of nodes.

### Installing the Helm Chart

After the AKS cluster is provisioned, we'll deploy the `databend-query` Helm chart. To accomplish this, we leverage the `kubernetes.helm.sh/v3.Chart` resource from Pulumi’s Kubernetes provider. This resource is a high-level component that can deploy a Helm chart into a Kubernetes cluster. It allows you to specify the chart to be installed, along with configuration parameters such as chart values, version, and namespace.

Below is a Pulumi program in TypeScript that demonstrates these steps:

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

// Step 1: Provision an Azure Kubernetes Service (AKS) cluster

// Define the AKS cluster
const aksCluster = new azure_native.hybridcontainerservice.ProvisionedCluster("myAksCluster", {
    location: "East US", // Specify the desired Azure region
    resourceGroupName: "myResourceGroup", // Ensure this resource group is already created
    properties: {
        kubernetesVersion: "1.21.2", // Specify the desired Kubernetes version
        agentPoolProfiles: [{
            count: 2, // Specify the number of nodes in the node pool
            vmSize: "Standard_D2_v2", // Specify the VM size for the nodes
            osType: "Linux", // Specify the OS type for the nodes
            mode: "User",
        }],
        identity: {
            type: "SystemAssigned",
        },
        // More properties might be configured depending on your needs
    },
});

// Export the AKS cluster's kubeconfig
export const kubeconfig = aksCluster.properties.kubeconfig.apply(kc => kc.value);

// Step 2: Install the Helm Chart into the AKS cluster

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

// Deploy the databend-query helm chart
const chart = new k8s.helm.v3.Chart("databend-query-chart", {
    chart: "databend-query",
    version: "0.1.0", // Replace with the correct chart version 
    fetchOpts: {
        repo: "http://helm.databend.rs/", // Replace with the correct Helm repo
    },
}, { provider: k8sProvider });

// Export the public IP to access the databend-query
export const databendQueryEndpoint = chart.getResourceProperty("v1/Service", "databend-query", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

Let's break down the key parts of the program:

- We start by importing the required Pulumi libraries.
- We define the AKS cluster using the `azure_native.hybridcontainerservice.ProvisionedCluster` resource.
- We apply the desired configuration for the cluster, such as the location, resource group name, Kubernetes version, and node size.
- We then create a `kubeconfig` which we will use for the Pulumi Kubernetes provider to interact with our AKS cluster.
- We define a Kubernetes provider instance which Pulumi will use to communicate with the AKS cluster.
- Using the `k8s.helm.v3.Chart` resource, we install the `databend-query` Helm chart from its repository.
- Finally, we export the public IP endpoint of the `databend-query` service, assuming it exposes a LoadBalancer to access the application.

Ensure you replace `"Standard_D2_v2"`, `"East US"`, `"myResourceGroup"`, `"0.1.0"`, and `http://helm.databend.rs/` with the actual values that match your requirements and the details from the `databend-query` Helm chart.

After writing this code, run it with the Pulumi CLI. Pulumi applies the desired state declared in your program to your cloud provider. Once the deployment finishes, it will output the endpoints to access the deployed `databend-query` application.