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

Question

Pulumi · Accepted Answer

To deploy the trino-exporter Helm chart on Azure Kubernetes Service (AKS), we will go through the following steps:

1. Create an AKS cluster using the `azure-native` provider.
2. Deploy the trino-exporter Helm chart to the AKS cluster using the Pulumi `kubernetes` provider.

### Step 1: Create an AKS Cluster

First, we need to set up an AKS cluster. We'll use the `azure-native` provider for creating the cluster. The `azure-native` provider allows us to interact with Azure resources in a more direct way using the Azure Resource Manager (ARM) API. Here, we'll create a resource group and an AKS cluster within that group.

When creating the AKS cluster, we'll specify the size of the nodes via the `vmSize` property and enable RBAC on the cluster by setting `enableRbac` to `true`. We'll also define an SSH key for secure access and the Kubernetes version we want for our cluster.

### Step 2: Deploy the trino-exporter Helm Chart

After the cluster has been provisioned, we'll switch to the `kubernetes` provider, specifically the `helm.sh/v3` package, to deploy the trino-exporter Helm chart. With Pulumi's `kubernetes` provider, we can manage Kubernetes resources, including deploying Helm charts, in the same way that we manage cloud infrastructure resources.

We'll use the `Chart` resource to deploy the trino-exporter chart from the specified repository, and set any necessary values needed for its configuration.

### Prerequisites:

Before running the Pulumi program:

- Ensure that you have the Pulumi CLI installed and configured with Azure.
- Have `kubectl` command-line tool installed to interact with the Kubernetes cluster.
- Have the `helm` command-line tool if you need to make any manual adjustments or chart upgrades.

Now, let's create a TypeScript Pulumi program to deploy the trino-exporter Helm chart to an AKS cluster.

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

const config = new pulumi.Config();
const sshPublicKey = config.require('sshPublicKey'); // SSH public key for secure communication with the cluster

// Create a new Azure resource group
const resourceGroup = new azure_native.resources.ResourceGroup('aksResourceGroup');

// Create the AKS cluster
const cluster = new azure_native.containerservice.ManagedCluster('aksCluster', {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3, // Number of nodes (VMs) you want in your cluster
        vmSize: 'Standard_DS2_v2', // Size of the VMs
        mode: 'System',
        name: 'agentpool',
        osType: 'Linux',
    }],
    dnsPrefix: 'aksk8s', // DNS prefix for the AKS cluster
    enableRbac: true, // Enable RBAC
    kubernetesVersion: '1.22.5',
    linuxProfile: {
        adminUsername: 'azureuser',
        ssh: {
            publicKeys: [{
                keyData: sshPublicKey, // Your SSH Public Key
            }],
        },
    },
    nodeResourceGroup: `nodeResourceGroup-${pulumi.getStack()}` // Name of the resource group to hold the AKS cluster's nodes
}, { parent: resourceGroup });

// Expose the kubeconfig for the AKS cluster
export const kubeconfig = cluster.kubeConfig;

// Create a provider for the AKS cluster
const aksProvider = new k8s.Provider('aksProvider', {
    kubeconfig: kubeconfig.apply(JSON.stringify),
});

// Deploy trino-exporter Helm chart using Pulumi's Kubernetes provider
const trinoExporterChart = new k8s.helm.v3.Chart('trino-exporter', {
    chart: 'trino-exporter', // Name of the Helm chart
    version: '1.0.0', // Version of the Helm chart
    repositoryOpts: {
        repo: 'https://helm-repo-url', // URL of the Helm repository where trino-exporter is located
    },
    values: {
        // Specify values needed for trino-exporter configuration. This is an example and the actual values will depend on the chart.
        // Replace these with actual configuration relevant to trino-exporter.
    },
}, { provider: aksProvider }); // Ensure that this Helm chart is installed on the AKS cluster

// Export the public IP to access the trino-exporter once it is deployed
export const trinoExporterIP = trinoExporterChart.getResourceProperty('v1/Service', 'trino-exporter', 'status').apply(status => status.loadBalancer.ingress[0].ip);

```

### Directions for Use

To use this Pulumi program, perform the following steps:

1. Replace `'https://helm-repo-url'` with the actual URL of the Helm repository where the trino-exporter chart is located.
2. Update the `sshPublicKey` variable with your actual SSH public key.
3. Configure any specific values for the trino-exporter chart under the `values` key.
4. Run `pulumi up` to execute the Pulumi program. It will automatically provision the required Azure and Kubernetes resources, and deploy the trino-exporter Helm chart on the AKS cluster.

After running the Pulumi program, you'll have an AKS cluster running with the trino-exporter Helm chart deployed onto it. You can use `kubectl` with the `kubeconfig` to interact with your cluster and the deployed chart.