Deploy the trino-loadbalancer helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `trino-loadbalancer` Helm chart on Azure Kubernetes Service (AKS), you'll need to follow a few steps. A Helm chart is a collection of pre-configured Kubernetes resources that can be deployed as a package. Here's a high-level overview of what we'll be doing:

1. Set up an AKS cluster where your applications will run.
2. Install and set up Helm, which is a package manager that simplifies the deployment of applications on Kubernetes.
3. Use Pulumi's Helm chart resource to deploy `trino-loadbalancer` onto the AKS cluster.

Below is a Pulumi program in TypeScript that demonstrates these steps. Let's go through each part of it:

### Install Dependencies

Before you begin, you need to have Pulumi CLI installed and be authenticated with Azure. You'll also need to install the following dependencies:

- `@pulumi/pulumi`: Core Pulumi SDK
- `@pulumi/azure-native`: Azure Native providers to manage resources in Azure
- `@pulumi/kubernetes`: Kubernetes provider to interact with the Kubernetes resources

You can install these dependencies using npm:

```bash
npm install @pulumi/pulumi @pulumi/azure-native @pulumi/kubernetes
```

### Configure Pulumi

In your Pulumi project directory, you should have your `Pulumi.yaml` and `index.ts` (or similarly named) files ready. Pulumi utilizes these to deploy and manage your infrastructure.

### Program Structure

The Pulumi program below is structured as follows:

- Imports: We import the necessary Pulumi packages and modules.
- Azure Resource Group: We create a new resource group in Azure to contain our AKS cluster.
- AKS Cluster: We set up a new AKS cluster within the resource group.
- Kubernetes Provider: We create a provider instance which will be used to interact with the AKS cluster.
- Helm Chart: We deploy the `trino-loadbalancer` helm chart into our AKS cluster utilizing the Helm Chart resource.

### The Pulumi Program

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

// Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("my-resource-group");

// Create an AKS cluster
const cluster = new azure.containerservice.ManagedCluster("my-aks-cluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 2,
        vmSize: azure.containerservice.VMSizeTypes.Standard_DS2_v2,
        mode: "System", // System nodes are required for the AKS cluster to function
        name: "agentpool" // Name of the node pool
    }],
    dnsPrefix: "myakscluster" // DNS prefix can be adjusted to your chosen DNS name
});

// Get the kubeconfig from the AKS cluster
const kubeconfig = pulumi.all([cluster.name, resourceGroup.name]).apply(([clusterName, rgName]) =>
    azure.containerservice.listManagedClusterUserCredentials({
        resourceName: clusterName,
        resourceGroupName: rgName,
    }).then(creds => {
        const encoded = creds.kubeconfigs[0].value;
        return Buffer.from(encoded, 'base64').toString();
    })
);

// Create a Kubernetes provider instance that uses our kubeconfig
const provider = new k8s.Provider("provider", {
    kubeconfig: kubeconfig
});

// Deploy the 'trino-loadbalancer' Helm chart onto the AKS cluster
const trinoChart = new k8s.helm.v3.Chart("trino-loadbalancer", {
    chart: "trino",
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    version: "0.1.0", // Use the desired chart version
    // You would configure your values here
    values: {
        service: {
            type: "LoadBalancer",
        },
    },
}, { provider });

// Export the public IP to access the Trino service
const frontendIp = trinoChart.getResourceProperty("v1/Service", "trino-loadbalancer", "status")
    .apply(status => status.loadBalancer.ingress[0].ip);
   
export const frontendIp;
```

### Understanding the Resources

- `ResourceGroup`: Logical container for Azure resources, providing a way to manage the lifecycle of resources in a grouped manner.
- `ManagedCluster`: The AKS cluster where your applications and services will run. We've configured it with an agent pool of 2 virtual machines.
- `Provider`: Bridges the AKS cluster with Pulumi Kubernetes service so we can deploy Kubernetes resources to it.
- `Chart`: Represents the Helm chart for `trino-loadbalancer`. The `values` snippet specifies chart values that customize its deployment.

### Helm Chart Configuration

The `trino-loadbalancer` Helm chart is referenced through its `chart` property. `fetchOpts` specify the repository where the chart is hosted. `values` is where you can specify any configuration values supported by the Helm chart, allowing you to customize the deployment, such as setting the service type to `LoadBalancer`.

After running this program using the `pulumi up` command, the output will provide you with the public IP address for the Trino service, which you can use to interact with your Trino deployment on AKS.

Remember to review the Helm chart's documentation for additional configurable values and adjust the `values` object accordingly to fit your needs.