Deploy the geoip-api helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

Deploying a Helm chart to an Azure Kubernetes Service (AKS) cluster involves several steps: provisioning the AKS cluster, installing and configuring the Helm CLI tool for the deployment, and finally deploying your Helm chart to the AKS cluster. In the example Pulumi program below, you'll see how to declare the necessary resources using TypeScript.

### Prerequisites
Before you begin, ensure the following prerequisites are met:
- You have the `azure-native` provider configured with your Azure credentials.
- You have Helm CLI installed locally or in your CI/CD environment.
- You have the `kubernetes` provider installed and configured to manage resources in the AKS cluster.
- The `geoip-api` helm chart you intend to deploy is available in a Helm repository accessible from your Kubernetes cluster.

### Explanation of Resources
- `ProvisionedCluster`: An AKS cluster resource which will be created in Azure.
- `Chart`: A Pulumi resource representing a Helm chart which can be deployed on a Kubernetes cluster.

### Detailed Steps
1. **Provisioning the AKS Cluster**: We define an AKS cluster using the `ProvisionedCluster` resource from the `azure-native` provider. This resource encapsulates the properties and configuration needed to initialize a managed Kubernetes cluster in Azure.
   
2. **Deploying Helm Chart**: Once the AKS cluster is provisioned, we install and configure the Helm client by setting the appropriate binaries and permissions. Then, we use Pulumi's `Chart` resource from the `kubernetes` provider to deploy the desired Helm chart to the AKS cluster.

Here's the TypeScript program that accomplishes the above steps:

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

const resourceGroupName = "my-aks-rg";
const clusterName = "geoip-cluster";
const helmChartName = "geoip-api";
const helmChartVersion = "1.2.3"; // Replace with your Helm chart version
const helmRepositoryUrl = "https://my-helm-repo.example.com"; // Replace with your Helm repository URL

// Create an Azure Resource Group if it doesn't exist
const resourceGroup = new azureNative.resources.ResourceGroup(resourceGroupName, {
    resourceGroupName: resourceGroupName,
});

// Deploy an AKS cluster
const cluster = new azureNative.hybridcontainerservice.ProvisionedCluster(clusterName, {
    // Assign the cluster to the created resource group
    resourceGroupName: resourceGroup.name,
    // Define the cluster properties such as location, nodes, and Kubernetes version
    location: resourceGroup.location,
    properties: {
        // Specific properties like agent pool profiles, network profiles
        // and others are omitted for simplicity
    },
    // Other necessary properties and specific configurations
});

// Define a K8s provider instance using the newly created AKS cluster kubeconfig
const k8sProvider = new k8s.Provider(clusterName, {
    kubeconfig: cluster.kubeconfig.apply(JSON.stringify),
});

// Deploy the geoip-api helm chart to the AKS cluster
const geoipApiChart = new k8s.helm.v3.Chart(helmChartName, {
    chart: helmChartName,
    version: helmChartVersion,
    fetchOpts: {
        repo: helmRepositoryUrl,
    },
}, { provider: k8sProvider }); // We use the AKS cluster as the provider for this Helm chart

// Export the AKS cluster's kubeconfig
export const kubeconfig = cluster.kubeconfig;
```

### Explanation of Code
- We start by creating an Azure Resource Group if it doesn't already exist, within which our AKS cluster will reside.
- We then declare the `ProvisionedCluster` resource, providing a name and associating it with our resource group. We also set the cluster location and other properties like VM size, node count, and optionally, network settings.
- Once the AKS cluster is created, we extract its kubeconfig, which is needed by `kubectl` and the Helm CLI tool to interact with your Kubernetes cluster.
- We define a Pulumi Kubernetes Provider which specifies how Pulumi will authenticate to our AKS cluster (using the kubeconfig).
- Finally, we create a `Chart` which represents our `geoip-api` Helm chart and associates it with our Kubernetes provider. We define the chart name, version, and the Helm repository URL.

When you run this program using Pulumi, it will create the cluster and deploy the `geoip-api` Helm chart to it. You can then manage and observe the deployment directly from Pulumi.