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

Question

Pulumi · Accepted Answer

To deploy the Ark Helm chart on Azure Kubernetes Service (AKS), you will first need to set up an AKS cluster. After that, you can use Pulumi's Kubernetes provider to deploy the Helm chart to the AKS cluster. Below, I provide an outline of the steps involved, followed by the TypeScript code that demonstrates the setup of an AKS cluster and deployment of the Ark Helm chart.

### Steps involved in deploying the Ark Helm chart on AKS:

1. **Set up the AKS cluster**: The AKS cluster is the environment where your Kubernetes workloads will run. You will define and configure an AKS cluster using Pulumi’s `azure-native` package. It will provide the needed Kubernetes resources such as worker nodes.

2. **Install Pulumi's Kubernetes provider**: The Kubernetes provider in Pulumi allows you to deploy Kubernetes resources, including Helm charts. You will need to configure the provider with the context from the AKS cluster created in step 1.

3. **Deploy the Ark Helm chart**: You will deploy the Ark Helm chart to the AKS cluster using Pulumi's `kubernetes.helm.v3.Chart` resource. This resource is used to deploy Helm charts to a Kubernetes cluster, manage versions, values, and namespaces.

Now let's look at the TypeScript code which accomplishes these steps:

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

// Step 1: Create Azure Kubernetes Service (AKS) cluster
const resourceGroup = new azure.resources.ResourceGroup("myResourceGroup");

const cluster = new azure.containerservice.ManagedCluster("myCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 3,
        maxPods: 110,
        mode: "System",
        name: "agentpool",
        osDiskSizeGB: 30,
        osType: "Linux",
        vmSize: "Standard_DS2_v2",
    }],
    dnsPrefix: "mykube",
    enableRBAC: true,
    kubernetesVersion: "1.18.14",
    linuxProfile: {
        adminUsername: "testuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa ...", // replace `...` with your SSH public key
            }],
        },
    },
    // If needed, you can enable network configuration, by default it's a basic setup.
    // networkProfile: {
    //    networkPlugin: "azure",
    //    dockerBridgeCidr: "172.17.0.1/16",
    //    dnsServiceIP: "10.2.2.254",
    //    serviceCidr: "10.2.2.0/24",
    // },
    nodeResourceGroup: "myNodeResourceGroup",
    servicePrincipal: {
        // You need to provide a valid service principal.
        clientId: "REPLACE_WITH_CLIENT_ID",
        secret: "REPLACE_WITH_SECRET",
    },
});

// Export the kubeconfig to access the AKS cluster
export const kubeConfig = cluster.kubeConfig;

// Step 2: Configure Pulumi to use the generated kubeconfig from AKS
const aksKubeConfig = pulumi.output(cluster.kubeConfigRaw).apply(JSON.parse);
const provider = new k8s.Provider("k8s-provider", {
    kubeconfig: aksKubeConfig,
});

// Step 3: Deploy the Helm chart for Ark (now called Velero) on the AKS cluster
const arkChart = new k8s.helm.v3.Chart("ark", {
    chart: "velero",
    version: "2.12.13", // Specify the chart version you want to deploy
    fetchOpts: {
        repo: "https://vmware-tanzu.github.io/helm-charts",
    },
    values: {
        // You can set Helm values here, for example
        configuration: {
            provider: "azure",
            // ... other necessary Ark configuration
        },
        // ... other Helm chart values
    },
}, { provider });

// Export the Ark Helm release status
export const arkHelmStatus = arkChart.status;
```

### Detailed Explanation:

- **ResourceGroup**: This resource defines an Azure Resource Group that will hold the AKS-related resources.
  
- **ManagedCluster**: Represents an AKS cluster. This resource includes configuration such as the size of the nodes (`vmSize`), the count of nodes in the node pool, SSH settings for Linux nodes, and Kubernetes and network configurations.

- **kubeConfig**: This is an output that will provide you with the access configuration needed to interact with your AKS cluster using `kubectl` or any Kubernetes-compatible tools.

- **aksKubeConfig**: We are transforming the `kubeConfigRaw` output from the cluster into a format that Pulumi's Kubernetes provider can consume.

- **Provider**: The Kubernetes provider instance that allows Pulumi to deploy resources to your AKS cluster.

- **Chart**: This is the Helm Chart resource that represents the Ark/Velero deployment. We specify the chart name, version, repository, and any custom values that need to be passed to the chart during deployment.

The `values` field within the Helm chart is used to provide configuration specific to the Ark install, like specifying the backup storage provider, which in this case would be Azure. The actual values will depend on the details of your setup and the Ark Helm chart documentation.

You would need to replace placeholders such as `ssh-rsa ...`, `REPLACE_WITH_CLIENT_ID`, and `REPLACE_WITH_SECRET`, with your actual values.

**Please note**: The actual names and versions of resources and references such as the Helm chart for Ark might change over time, so it's always a good practice to refer to the official Helm repository and AKS documentation for updated values and practices.