Deploy the tt-workflow helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

Deploying a Helm chart on AKS using Pulumi involves several steps. We'll begin by creating an AKS cluster, and then we'll deploy our Helm chart to the cluster.

### Create an Azure Kubernetes Service Cluster

To deploy the `tt-workflow` Helm chart on Azure Kubernetes Service (AKS), we'll start by provisioning an AKS cluster. We will use `azure-native.hybridcontainerservice.ProvisionedCluster` to create a cluster in a given location with specified properties.

### Deploy the Helm chart to AKS

Once we have our AKS cluster up and running, we can deploy the Helm chart to the cluster. We'll use the `kubernetes.helm.v3.Chart` resource from Pulumi's Kubernetes provider to deploy the `tt-workflow` Helm chart.

Below is a full Pulumi program written in TypeScript:

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

// Create an AKS cluster
const aksCluster = new azure_native.containerservice.ManagedCluster("aksCluster", {
    // Required parameters for creating AKS cluster
    resourceGroupName: "yourResourceGroupName",
    location: "West US",
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "yourDnsPrefix", // Replace with a DNS prefix of your choice
    kubernetesVersion: "1.18.14",
});

// Once the cluster is created, we can obtain its kubeconfig.
const creds = pulumi.all([aksCluster.name, aksCluster.resourceGroupName]).apply(([name, rg]) => {
    return azure_native.containerservice.listManagedClusterUserCredentials({
        resourceName: name,
        resourceGroupName: rg,
    });
});

// Export the kubeconfig.
const kubeconfig = creds.apply(creds => {
    const base64Kubeconfigs = creds.kubeconfigs[0].value;
    return Buffer.from(base64Kubeconfigs, 'base64').toString();
});
export const kubeconfigOutput = kubeconfig;

// Creating a new k8s provider using the kubeconfig.
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: kubeconfig,
});

// Deploying a Helm Chart onto the AKS cluster.
const helmChart = new k8s.helm.v3.Chart("tt-workflow-chart", {
    chart: "tt-workflow",
    // Replace with the correct repository or local path
    fetchOpts:{
        repo: "http://example.com/path/to/chart",
    },
}, { provider: k8sProvider });

// Export the public endpoint to access the tt-workflow application.
export const endpoint = aksCluster.fqdn.apply(fqdn => `http://${fqdn}:8080`);
```

### Explanation

Here's what the code is doing:

1. **AKS Cluster Creation**: We define an `azure_native.containerservice.ManagedCluster` resource named `aksCluster` to create a new AKS cluster. This configuration includes a single node in the agent pool and specifies the VM size and Kubernetes version to use.

2. **Kubeconfig Retrieval**: Once the cluster is created, the `kubeconfig` for the cluster is retrieved using `azure_native.containerservice.listManagedClusterUserCredentials`. This configuration allows us to interact with the cluster via kubectl or a Kubernetes client library.

3. **Kubernetes Provider Setup**: With the retrieved `kubeconfig`, we set up a Kubernetes provider instance. This provider is responsible for deploying resources onto the Kubernetes cluster managed by AKS.

4. **Helm Chart Deployment**: Finally, we use `k8s.helm.v3.Chart` to deploy the Helm chart. Make sure to replace the `fetchOpts.repo` with the actual URL or local path to your `tt-workflow` Helm chart. This resource is what actually deploys your application onto the AKS cluster.

5. **Exports**: The code exports two values:
    - The `kubeconfig` necessary to connect to and manage the Kubernetes cluster manually.
    - The endpoint URL where the `tt-workflow` service can be accessed after it is deployed.

Please ensure that the placeholder values such as `resourceGroupName`, `yourDnsPrefix`, and the Helm chart repository path are replaced with the actual values you intend to use for your deployment.

To run this Pulumi program, you would typically execute the following commands:

1. `pulumi stack init` to create a new stack.
2. `pulumi up` to create resources defined in the program.

The program output will provide you with the kubeconfig needed to connect to the AKS cluster and the endpoint to access the `tt-workflow` application.

Please note that Pulumi requires you to have appropriate Azure credentials configured on your system to authenticate with Azure services. These credentials can typically be set up using the Azure CLI with `az login`.