Deploy the cron helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy a cron Helm chart on Azure Kubernetes Service (AKS) using Pulumi, we will use the following resources:

1. **Azure Kubernetes Service (AKS)**: This managed Kubernetes service by Azure simplifies your Kubernetes cluster deployment and management. We'll first create an AKS cluster for us to work with.

2. **Helm Chart**: Helm is a package manager for Kubernetes that allows you to package, configure, and deploy applications onto Kubernetes clusters. We will use a Helm chart to deploy a cron job onto our AKS cluster.

Below is a Pulumi TypeScript program that creates an AKS cluster and deploys a cron job to it. The cron job configuration will be defined using a Helm chart.

### Detailed Program Explanation

- **Import Statements**: We'll first import the necessary Pulumi packages to create our AKS cluster and deploy a Helm chart.
  
- **Resource Creation (AKS)**: We will then create an AKS cluster using the `azure-native` package which provides native Azure resources. We create an AKS cluster by specifying parameters such as node size, number of nodes, etc.

- **Helm Chart Deployment**: Once we have our AKS cluster set up, we use the `kubernetes.helm.v3.Chart` class to deploy a Helm chart to our AKS cluster. We specify the name of the chart (for example, "cron"), along with any values that configure the cron job.

- **Cluster Configuration**: To connect with our AKS cluster using Pulumi, we need to specify the kubeconfig. Pulumi does this automatically for us when it creates the AKS cluster—this configuration enables us to deploy Kubernetes resources without manually configuring `kubectl`.

Now, let's look at the code.

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

// Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("aksResourceGroup", {
    location: "East US", // You can choose the location that is closest to you.
});

// Create an Azure AD Application for the AKS cluster
const adApp = new azuread.Application("aks");

// Create a Service Principal for the AD Application
const adSp = new azuread.ServicePrincipal("aksSp", {
    applicationId: adApp.applicationId,
});

// Create the AD Service Principal Password
const adSpPassword = new azuread.ServicePrincipalPassword("aksSpPassword", {
    servicePrincipalId: adSp.id,
    endDate: "2099-01-01T00:00:00Z", // You can set it as per your requirement
});

// Create an AKS cluster
const aksCluster = new azure.containerservice.KubernetesCluster("aksCluster", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    agentPoolProfiles: [{
        name: "aksagentpool",
        count: 2, // Number of Nodes in your Cluster
        vmSize: "Standard_B2s", // Size for the VMs
    }],
    dnsPrefix: `${pulumi.getStack()}-kube`, // A unique DNS prefix for the AKS cluster
    linuxProfile: {
        adminUsername: "aksuser",
        sshKey: {
            keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD3b... your SSH public key ...",
        },
    },
    servicePrincipal: {
        clientId: adApp.applicationId,
        clientSecret: adSpPassword.value,
    },
    kubernetesVersion: "1.21.2", // Specify the version of Kubernetes
});

// Output the kubeconfig for the AKS cluster
export const kubeconfig = pulumi.
    all([aksCluster.name, resourceGroup.name])
    .apply(([clusterName, rgName]) => {
        return azure.containerservice.getKubeConfig({
            name: clusterName,
            resourceGroupName: rgName,
        });
    });

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

// Deploy a Helm Chart: Here we will use the stable/cronjob Helm chart as an example.
// Make sure to replace the `chart` and `version` with the correct chart name and version you are trying to deploy.
const cronHelmChart = new k8s.helm.v3.Chart("cronHelmChart", {
    chart: "stable/cronjob",
    version: "0.1.0", // Replace with your desired chart version
    values: {
        // Your values to configure the cron job go here
    },
}, { provider: k8sProvider });

// Export the public endpoint to connect to the cluster
export const clusterEndpoint = aksCluster.fqdn;
```

To use this program, you need to replace certain values with the ones specific to your needs, like `location`, `vmSize`, `kubernetesVersion`, `dnsPrefix`, the SSH public key data, and Helm chart configuration.

The `kubeconfig` output can be used to connect to the Kubernetes cluster with `kubectl` on your local machine.

In the `cronHelmChart`, specify the `chart`, `version`, and `values` accordingly to deploy the cron job. You can usually find the available chart versions and configurable values by searching for the chart on a Helm Chart repository or chart's documentation.

This program sets up the infrastructure and the cron job. Run the program using the Pulumi CLI commands `pulumi up` to provision the resources, and later `pulumi destroy` when you no longer need those resources.