Deploy the hadoop-deployment helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on Azure Kubernetes Service (AKS) involves several steps using Pulumi. We'll walk through the process, breaking down each step with explanations and the corresponding TypeScript code.

### Pre-requisites
Before you begin, ensure you have the following prerequisites in place:
1. A configured Azure account and credentials on your machine.
2. Pulumi CLI installed and set up with your desired account.
3. Helm CLI installed on your machine if you need to customize chart values or inspect charts locally.

### Steps to Deploy the Helm Chart on AKS
1. **Create an AKS Cluster**: First, you will need to deploy an AKS cluster where your Helm chart will be installed. The `azure-native.hybridcontainerservice.ProvisionedCluster` resource is used to create a new Kubernetes cluster on Azure.

2. **Install the Helm Chart**: Use the `kubernetes.helm.v3.Chart` resource, which represents a Helm chart in Pulumi. You can customize it by specifying the `chart` name, the `version`, the `values` to override default settings, and the `namespace` to deploy to.

Here's the Pulumi TypeScript program that accomplishes these tasks:

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

// Step 1: Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

// Step 2: Create an AKS Cluster
const cluster = new azure.containerservice.KubernetesCluster("myAKSCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 1,
        vmSize: azure.containerservice.VMSizeTypes.Standard_D2_v2,
        mode: "System",
    }],
    dnsPrefix: "myakscluster",
});

// Export the Kubeconfig
export const kubeconfig = cluster.kubeConfigRaw;

// Step 3: Deploy a Helm chart for Hadoop deployment
const hadoopChart = new k8s.helm.v3.Chart("hadoop-deployment", {
    chart: "hadoop",
    version: "3.0.0",  // specify the version of the chart
    namespace: "default",  // specify the namespace, change if needed
    // You can pass the custom values to the Helm chart through 'values' field.
    // For now, we're using default values, you might want to customize these.
    values: { },
}, { 
    provider: new k8s.Provider("k8s", {
        kubeconfig: cluster.kubeConfigRaw,
    }),
});

// Export the Helm chart deployment name
export const hadoopDeploymentName = hadoopChart.getResourceProperty("v1/Service", "hadoop-deployment-hadoop", "metadata").apply(m => m.name);

```

### Explanation

- **Resource Group**: Before creating an AKS cluster, a resource group is declared. A resource group is a container that holds related resources for an Azure solution.

- **AKS Cluster**: The `azure.containerservice.KubernetesCluster` resource creates an AKS cluster within the previously declared resource group. Here, we're specifying a single node pool with a count of 1 and a VM size appropriate for our needs.

- **Export Kubeconfig**: The `kubeconfig` needed to interact with the cluster is exported. This enables you to use `kubectl` to communicate with your AKS cluster.

- **Helm Chart**: The `k8s.helm.v3.Chart` resource allows us to deploy applications defined by Helm charts. Here, 'hadoop-deployment' refers to the name you want to give for this chart deployment within Pulumi. Make sure to replace "hadoop" with the actual chart name from the Helm repository and adjust the `version` to the one you need.

- **Custom Values**: You can customize the Helm deployment by providing a `values` object to the chart. This example uses the default values provided by the chart.

- **Kubernetes Provider**: A Kubernetes provider resource is instantiated, which is required by Pulumi to deploy the Helm chart into the AKS cluster.

- **Hadoop Deployment Name**: The deployment name of Hadoop is exported so that you can easily reference it using `kubectl` or within other Pulumi programs.

### Conclusion
Running this Pulumi program will result in:
1. An AKS cluster being provisioned.
2. A Helm chart for Hadoop being deployed to the cluster.

After deployment, you can manage the Helm release using Pulumi's deployment outputs or use `kubectl` with the exported kubeconfig to interact with your AKS cluster.