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

Question

Pulumi · Accepted Answer

To deploy the Infinispan Helm chart on an Azure Kubernetes Service (AKS) cluster using Pulumi, you will need to complete a few steps:

1. **Create an AKS Cluster:** The first step is to create an AKS cluster where your Helm chart will be deployed.
2. **Configure kubectl:** Once the AKS cluster is up and running, you need to configure kubectl to connect to your AKS cluster.
3. **Deploy Infinispan Helm Chart:** After setting up kubectl, you can deploy the Infinispan Helm chart to your AKS cluster.

Below is a complete program written in TypeScript that performs these steps using Pulumi. This program uses the `@pulumi/azure-native` package to create an AKS cluster and the `@pulumi/kubernetes` package to deploy the Helm chart.

Before you can run this Pulumi program, you need to have Pulumi installed and set up with appropriate access to your Azure account. Make sure to log in to Azure with the Azure CLI (`az login`) and set up your Pulumi account.

Here's how the code works:

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

const name = "infinispan";

// Step 1: Create the AKS cluster
const resourceGroup = new azure_native.resources.ResourceGroup(`${name}-rg`);

const cluster = new azure_native.containerservice.ManagedCluster(`${name}-aks`, {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 1,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: `${pulumi.getStack()}-k8s`,
    enableRBAC: true,
    kubernetesVersion: "1.20.7",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa AAAAB3NzaC1y... your public key ...",
            }],
        },
    },
    nodeResourceGroup: `rg-${name}`,
    servicePrincipalProfile: {
        clientId: "insert-your-service-principal-client-id",
        secret: "insert-your-service-principal-client-secret",
    },
});

// Step 2: Configure kubectl
const creds = pulumi.all([cluster.name, resourceGroup.name]).apply(([clusterName, rgName]) => 
    azure_native.containerservice.listManagedClusterUserCredentialsOutput({
        resourceName: clusterName,
        resourceGroupName: rgName
    })
);

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

// Export the kubeconfig
export const kubeconfigOut = pulumi.secret(kubeconfig);

// Step 3: Deploy Infinispan Helm Chart
const k8sProvider = new k8s.Provider(`${name}-k8s`, {
    kubeconfig: kubeconfig,
});

const infinispanChart = new k8s.helm.v3.Chart("infinispan", {
    chart: "infinispan",
    version: "x.y.z", // specify the chart version you want to deploy
    fetchOpts: {repo: "https://infinispan.github.io/helm-charts/"},
}, { provider: k8sProvider });

// Export the Infinispan chart status
export const infinispanStatus = infinispanChart.status;
```

Let's break down the code:

- First, we import the required Pulumi packages.
- We create a resource group where all our resources will be created.
- The `ManagedCluster` resource creates a new AKS cluster with a single node in the specified resource group. You may adjust the `agentPoolProfiles` according to your needs and provide the required `servicePrincipalProfile`.
  - **Note:** You should replace `'insert-your-service-principal-client-id'` and `'insert-your-service-principal-client-secret'` with your actual Azure service principal credentials.
- We retrieve the credentials needed to configure kubectl to communicate with the AKS cluster.
- We create a Kubernetes `Provider` which uses the generated kubeconfig from the AKS cluster.
- We then create a Helm chart resource using the `k8s.helm.v3.Chart` class.
- Replace `'x.y.z'` with the version of the Infinispan Helm chart that you wish to use. You can find the versions available in the [Infinispan Helm chart repository](https://infinispan.github.io/helm-charts/).
- Finally, we export the kubeconfig and the status of the Infinispan chart deployment. The `kubeconfigOut` is marked as a secret to prevent it from being displayed in plain text in the console.

To run this program, save the content to a file called `index.ts`, and then execute it using the Pulumi command line:

```sh
pulumi up
```

This command runs the Pulumi program, creates all cloud resources, and gives you output that includes the helm chart status and the kubeconfig as a secret.