Deploy the magic-ip-address helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy a Helm chart to Azure Kubernetes Service (AKS), we need to perform the following steps:

1. **Provision an AKS Cluster**: Create an Azure Kubernetes Service (AKS) cluster where your applications will run.
2. **Install Helm and Tiller**: Helm is a package manager for Kubernetes. Tiller is the server-side component that Helm communicates with. Since Helm 3, Tiller is no longer required, but we'll use Helm commands to deploy our chart.
3. **Deploy the Helm Chart**: Deploy the `magic-ip-address` Helm chart on the provisioned AKS cluster.

Let's assume you've already set up Pulumi and have the necessary cloud provider configurations in place. If not, please follow Pulumi's [installation](https://www.pulumi.com/docs/get-started/azure/) and [configuration](https://www.pulumi.com/docs/intro/cloud-providers/azure/setup/) guides.

Below you'll find a Pulumi program written in TypeScript that performs these steps. The program uses `@pulumi/azure-native` to create the AKS cluster and `@pulumi/kubernetes` to deploy the Helm chart.

### Detailed Pulumi TypeScript Program

First, we import the necessary Pulumi libraries for both Azure and Kubernetes.

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

Next, we create the AKS cluster. This step involves creating an Azure resource group, a service principal (for AKS to interact with other Azure services), and the AKS cluster itself with default settings.

```typescript
// Create an Azure Resource Group
const resourceGroup = new azure.resources.ResourceGroup("resourceGroup");

// Create an AKS cluster
const cluster = new azure.containerservice.ManagedCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 2,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: `${pulumi.getStack()}-kube`,
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa ...", // replace with your SSH public key
            }],
        },
    },
    nodeResourceGroup: `MC_azure_${pulumi.getStack()}`,
    servicePrincipalProfile: {
        clientId: "your-service-principal-client-id",
        secret: "your-service-principal-client-secret",
    },
});
```

After the cluster is provisioned, we configure Pulumi to use the generated kubeconfig from the AKS cluster. This step is crucial because it allows Pulumi to interact with your cluster.

```typescript
// Export the Kubeconfig
export const kubeconfig = pulumi.
    all([cluster.name, resourceGroup.name]).
    apply(([clusterName, rgName]) => {
        return azure.containerservice.listManagedClusterUserCredentials({
            resourceGroupName: rgName,
            resourceName: clusterName,
        });
    }).
    apply(creds => Buffer.from(creds.kubeconfigs[0].value, "base64").toString());
```

Now we use Pulumi's Kubernetes provider to deploy the Helm chart. We configure the Kubernetes provider to use the kubeconfig from the AKS cluster we just created.

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

// Deploy the `magic-ip-address` Helm chart
const chart = new k8s.helm.v3.Chart("magic-ip-address", {
    chart: "magic-ip-address",
    version: "1.0.0", // Replace with the desired chart version
    fetchOpts:{
        repo: "http://your-helm-chart-repository/", // Replace with the Helm chart repository URL
    }
}, { provider: k8sProvider });
```

And finally, we would export any relevant endpoints or other important data that resulted from our deployment. For example, if your Helm chart creates a Kubernetes service of type LoadBalancer, you might want to export the IP address:

```typescript
// Assume our Helm chart creates a Service named 'magic-ip-address-service'
const service = k8s.core.v1.Service.get("magic-ip-address-service", pulumi.concat("magic-ip-address-magic-ip-address-service"));
export const magicIpAddress = service.status.apply(s => s.loadBalancer.ingress[0].ip);
```

Here's the entire program put together:

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

const resourceGroup = new azure.resources.ResourceGroup("resourceGroup");

const cluster = new azure.containerservice.ManagedCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    // other configurations ...
});

export const kubeconfig = pulumi.
    all([cluster.name, resourceGroup.name]).
    apply(([clusterName, rgName]) => {
        // code to return kubeconfig ...
    });

const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

const chart = new k8s.helm.v3.Chart("magic-ip-address", {
    // Helm chart configuration ...
}, { provider: k8sProvider });

const service = k8s.core.v1.Service.get("magic-ip-address-service", pulumi.concat("magic-ip-address-magic-ip-address-service"));
export const magicIpAddress = service.status.apply(s => s.loadBalancer.ingress[0].ip);
```

This program will create an Azure Kubernetes Service (AKS) cluster and deploy the specified Helm chart. Modify the placeholders with your information, such as the SSH public key, service principal credentials, Helm chart version, and repository URL as needed.

Make sure you understand the properties and objects used in this code, as they directly impact the resources that are created and managed in your cloud environment. Adjust the configuration parameters to fit your needs, such as choosing the proper VM size for your agent pool, setting the Kubernetes version, and scaling the number of nodes as needed.

After writing the above code into a `.ts` file, you can run `pulumi up` to deploy your AKS cluster and the Helm chart.