Deploy the fluentd-cloudwatch helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `fluentd-cloudwatch` Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, we'll follow these steps:

1. Set up an AKS cluster: We will deploy a Kubernetes cluster on Azure.
2. Install the Helm chart: We will deploy the `fluentd-cloudwatch` chart into our AKS cluster.

The Pulumi program will use the `@pulumi/azure-native` package to create an AKS cluster and the `@pulumi/kubernetes` package to deploy the Helm chart to that cluster.

Below is a detailed explanation of the Pulumi program in TypeScript that accomplishes these tasks:

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

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

// Step 2: Deploy an AKS Cluster
// This is a basic AKS cluster with default settings.
// You can customize the properties according to your requirements.
const cluster = new azure_native.containerservice.ManagedCluster("myAksCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
        name: "agentpool",
    }],
    dnsPrefix: "myakscluster",
    enableRBAC: true,
    kubernetesVersion: "1.20.7",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{ keyData: /* Your SSH public key */ }],
        },
    },
    sku: {
        name: "Basic",
        tier: "Free",
    },
});

// Step 3: Export the AKS cluster's kubeconfig
export const kubeconfig = pulumi.
    all([cluster.name, resourceGroup.name]).
    apply(([clusterName, rgName]) =>
        azure_native.containerservice.listManagedClusterUserCredentials({
            resourceGroupName: rgName,
            resourceName: clusterName,
        })
    ).
    apply(creds => Buffer.from(creds.kubeconfigs[0].value, 'base64').toString());

// Step 4: Use the kubeconfig to create a Provider instance for the AKS cluster
const aksK8sProvider = new k8s.Provider("aksK8sProvider", {
    kubeconfig: kubeconfig,
});

// Step 5: Deploy the fluentd-cloudwatch Helm chart into the AKS cluster
const fluentdCloudwatchChart = new k8s.helm.v3.Chart("fluentd-cloudwatch", {
    chart: "fluentd-cloudwatch",
    version: "0.14.0", // specify the chart version you want to deploy
    namespace: "kube-system", // deploying the chart under 'kube-system' namespace
    fetchOpts: {
        repo: "https://charts.fluent.io", // Helm chart repository
    }
}, { provider: aksK8sProvider });

// Export the URL to access the dashboard
export const aksClusterName = cluster.name;
```

In the above program:

- We create an Azure Resource Group which acts as a lifecycle container for the AKS resources.
- We then deploy an AKS cluster with a single node pool using the `ManagedCluster` resource. Make sure to replace `/* Your SSH public key */` with your actual SSH public key to allow secure SSH access to the nodes.
- Once our AKS cluster is created, we export the kubeconfig which will allow us to interact with our Kubernetes cluster using Pulumi's `k8s` package.
- We define a `Provider` resource which represents the AKS cluster. This provider is then used by other `k8s` resources to tell them which cluster to interact with.
- Finally, we deploy the `fluentd-cloudwatch` Helm chart using Pulumi's `k8s.helm.v3.Chart` resource. We specify the chart name, the version, and the Helm repository it can be found in.

Please ensure you have the Pulumi CLI installed and configured to connect to Azure. Additionally, make sure you have Helm installed if you wish to customize helm charts locally.

To run this code, save it in a `index.ts` file and use the Pulumi CLI to create your Pulumi project and stack. After the code is deployed successfully, Pulumi will provide you with the kubeconfig of the AKS cluster and the name of the cluster as outputs.

The `kubeconfig` allows you to interact with your cluster using `kubectl` and the cluster name is a helpful reference that is exported.