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

Question

Pulumi · Accepted Answer

To deploy the MySQL 8 Helm chart on Azure Kubernetes Service (AKS), we'll go through a series of steps using Pulumi and its ecosystem. Firstly, we will set up an AKS cluster, followed by installing the MySQL Helm chart on it.

For the AKS cluster setup, we'll use the `azure-native` provider for Pulumi, which is the native Azure Resource Manager (ARM) provider that interacts with Azure using the ARM API. The `azure-native` provider allows us to use Azure resources directly in a typescript-friendly way, including AKS.

After the AKS cluster is created, we’ll use the `kubernetes` provider from Pulumi to deploy the MySQL 8 Helm chart. The `kubernetes` provider enables Pulumi to interact with the Kubernetes API and manage Kubernetes resources including deploying Helm charts. The `helm.sh/v3.Chart` resource allows us to deploy applications packaged as Helm charts.

Here's the step-by-step TypeScript program:

1. Import necessary Pulumi and Azure components.
2. Create a new AKS cluster, specifying the required properties such as node count, VM size, and others.
3. Once the AKS cluster has been provisioned, we'll acquire the KubeConfig to interact with it.
4. Deploy the MySQL 8 Helm chart using the Helm chart resource in Pulumi.

Let's see the Pulumi TypeScript program:

```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 AKS cluster
const resourceGroup = new azure_native.resources.ResourceGroup("myResourceGroup");

// Specify the properties of the AKS cluster
const managedCluster = new azure_native.containerservice.ManagedCluster("myAKSCluster", {
    resourceGroupName: resourceGroup.name,
    agentPoolProfiles: [{
        count: 1,  // Specify the number of nodes in the AKS cluster
        vmSize: "Standard_DS2_v2",  // Specify the VM size for the nodes
        maxPods: 110,  // Specify the maximum number of pods on each node
        mode: "System",
        name: "agentpool",
        osType: "Linux",
        type: "VirtualMachineScaleSets",
    }],
    dnsPrefix: "mypulumiaks",
    enableRBAC: true,
    kubernetesVersion: "1.20.5",
    linuxProfile: {
        adminUsername: "adminuser",
        ssh: {
            publicKeys: [{
                keyData: "ssh-rsa AAAAB3NzaC1yc...",
            }],
        },
    },
    location: resourceGroup.location,
    nodeResourceGroup: `MC_azure-native-go_${pulumi.getProject()}_${pulumi.getStack()}`,
    resourceName: "myAKSCluster",
});

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

// Step 3: Create a Kubernetes Provider using the acquired KubeConfig
const k8sProvider = new k8s.Provider("k8sProvider", {
    kubeconfig: creds.kubeconfigs[0].value.apply(c => Buffer.from(c, "base64").toString()),
});

// Step 4: Deploy the MySQL 8 Helm chart using the Helm Chart resource in Pulumi
const mysql = new k8s.helm.v3.Chart("mysql-release", {
    chart: "mysql",
    version: "8.8.2", // Specify the version of MySQL Helm chart
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
}, { provider: k8sProvider });

// Export the kubeconfig and MySQL service endpoint
export const kubeConfig = creds.kubeconfigs[0].value;
export const mysqlServiceEndpoint = mysql.getResource("v1/Service", "mysql-release-mysql").status.apply(s => `mysql://${s.loadBalancer.ingress[0].ip}`);
```

### Explanation

- **ResourceGroup (`azure_native.resources.ResourceGroup`)**: This initializes a new resource group in Azure to host all related resources for the AKS cluster.

- **ManagedCluster (`azure_native.containerservice.ManagedCluster`)**: This is the AKS resource. It specifies the location, version of Kubernetes, node properties, and other parameters required to create the AKS cluster.

- **KubeConfig Retrieval**: With the `listManagedClusterUserCredentials` function, we are retrieving the credentials necessary to interact with the AKS cluster. This includes the KubeConfig, which we need to set up the Kubernetes provider.

- **Kubernetes Provider (`k8s.Provider`)**: This resource enables Pulumi to communicate with the Kubernetes cluster using the KubeConfig obtained.

- **Helm Chart (`k8s.helm.v3.Chart`)**: This resource is used to deploy a Helm chart, in this case, the MySQL chart from the Bitnami Helm repository.

- **Exports**: After deployment, the KubeConfig is exported as a sensitive output to enable interacting with the AKS cluster using kubectl. Additionally, we're exporting the MySQL service endpoint that can be used to connect to MySQL after it's deployed.

To apply this Pulumi program, save it in a file named `index.ts`, and then execute `pulumi up` from the command line in the same directory. This will initiate the provisioning of resources as defined. Ensure you have the Pulumi CLI installed and configured for Azure beforehand.