Deploy the promtail-mixin helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the promtail-mixin Helm chart on an Azure Kubernetes Service (AKS) cluster, you would first need to have an AKS cluster up and running. Since the Pulumi Registry Results indicate resources and modules related to AKS, we'll use the azure-native provider, which is the native Pulumi provider for Azure resources.

I will walk you through the steps:

Set up AKS Cluster: This involves creating an AKS cluster using the azure-native.containerservice.ManagedCluster resource.
Install the promtail-mixin Helm chart: With the AKS cluster in place, you can proceed to deploy the promtail-mixin Helm chart using the kubernetes.helm.v3.Chart resource from the Kubernetes provider.

Before diving into the Pulumi code, ensure you have done the following:

Installed Pulumi CLI and set up Pulumi to use your Azure account for authentication.
Installed kubectl, the Kubernetes command-line tool, to interact with your AKS cluster.
Configure Azure credentials in your environment so that Pulumi can authenticate with Azure.

Here's the Pulumi TypeScript program that creates an AKS cluster and deploys promtail-mixin using Helm:

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

// Set up configuration values for the AKS cluster
const config = new pulumi.Config();
const location = config.get("location") || "eastus";
const resourceGroupName = config.get("resourceGroupName") || "promtail_mixin_resource_group";
const aksClusterName = "promtailMixinAksCluster";

// Create an Azure Resource Group
const resourceGroup = new azure_native.resources.ResourceGroup("resourceGroup", {
    resourceGroupName: resourceGroupName,
    location: location,
});

// Create an AKS cluster
const managedCluster = new azure_native.containerservice.ManagedCluster("managedCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    clusterName: aksClusterName,
    identity: {
        type: "SystemAssigned",
    },
    agentPoolProfiles: [{
        count: 1,
        mode: "System",
        name: "agentpool",
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: resourceGroupName,
});

// Obtain the kubeconfig from the created AKS cluster
const creds = pulumi.all([resourceGroup.name, managedCluster.name]).apply(([rgName, clusterName]) =>
    azure_native.containerservice.listManagedClusterUserCredentials({
        resourceGroupName: rgName,
        resourceName: clusterName,
    })
);

const kubeconfig = creds.kubeconfigs[0].value.apply(enc => Buffer.from(enc, "base64").toString());

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

// Deploy promtail-mixin Helm chart into the AKS cluster
const promtailMixinChart = new k8s.helm.v3.Chart("promtail-mixin", {
    chart: "promtail-mixin",
    version: "<chart version>", // Specify the chart version you want to deploy
    fetchOpts: {
        repo: "https://grafana.github.io/helm-charts", // This is the Helm repository for promtail-mixin
    },
}, { provider: k8sProvider });

// Export the AKS cluster name and Kubernetes config
export const aksClusterNameOut = aksClusterName;
export const kubeconfigOut = pulumi.secret(kubeconfig);

How to Use This Code

To use this code, follow these steps:

Ensure you have the Pulumi CLI and kubectl installed on your machine.
Save this code to a file with a .ts extension, for example, index.ts.
Open a terminal in the directory where your index.ts file is located.
Run pulumi stack init <stack_name> to create a new stack, where <stack_name> is a name you choose for your stack.
Run pulumi up to preview and deploy the resources.

If the preview run looks good, confirm the deployment. Once the deployment is complete, Pulumi will output the AKS cluster name and the kubeconfig needed to interact with the cluster.

Remember to replace <chart version> with the version of the promtail-mixin chart that you want to deploy. You can find the available chart versions in the Helm repository for promtail-mixin.

The pulumi.secret() function is used when exporting the kubeconfig to ensure that sensitive information is encrypted in the Pulumi state.

After the deployment is successful, you can use the exported kubeconfig to interact with your AKS cluster using kubectl. This allows you to manage workloads, including checking the status of the promtail-mixin deployment within your cluster.