Deploy the mysql-persistent helm chart on Azure Kubernetes Service (AKS)

Question

Pulumi · Accepted Answer

To deploy the `mysql-persistent` Helm chart on Azure Kubernetes Service (AKS), we need to complete a few steps:

1. Set up an AKS cluster: You'll need a Kubernetes cluster running on Azure. The `ProvisionedCluster` resource in the `azure-native` package can be used to provision an AKS cluster.
2. Install and Configure Helm: Helm is a package manager for Kubernetes that simplifies deploying applications. Pulumi's `Chart` resource from the `kubernetes` package will be used for deploying the Helm chart.
3. Deploy the `mysql-persistent` chart: The chart will be deployed into the AKS cluster using the `Chart` resource.

Now let's write a Pulumi program in TypeScript to execute the above steps.

First, you'll need to import the necessary Pulumi packages.

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

Next, we will provision the AKS cluster. In this step, we define the AKS cluster properties, such as the size of the nodes and the number of nodes. We'll also define the identity of the cluster for managing it and the Kubernetes version.

```typescript
const resourceGroupName = new azure.resources.ResourceGroup("myResourceGroup");

const k8sCluster = new azure.containerservice.KubernetesCluster("myAKSCluster", {
    resourceGroupName: resourceGroupName.name,
    // Define the AKS cluster properties here
    // For example, specifying the location, Kubernetes version, and node size:
    location: resourceGroupName.location,
    defaultNodePool: {
        name: "akspool",
        nodeCount: 2,
        vmSize: "Standard_D2_v2",
    },
    identity: {
        type: "SystemAssigned",
    },
    kubernetesVersion: "1.19.7",
});

// Expose a K8s provider instance using the above AKS cluster
const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: k8sCluster.kubeConfigRaw,
});
```

Now that you have an AKS cluster, use Helm to deploy `mysql-persistent`. You'll need to specify the repository and chart name. The chart can be configured via the `values` parameter.

```typescript
const mysqlChart = new kubernetes.helm.v3.Chart("mysql-persistent", {
    chart: "mysql",
    version: "1.6.4", // Specify the version of the chart you want to deploy
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami", // This is the repository where the mysql chart is hosted
    },
    // Define the chart values
    // These are dependent on the chart you are using
    values: {
        // You can customize the Helm chart values here e.g., setting a persistent volume.
        persistence: {
            enabled: true,
            size: "8Gi",
        },
    },
}, { provider: k8sProvider });
```

In the above code, we create a new `Chart` resource for the `mysql-persistent` Helm chart. We specify the chart name, chart version, and the Helm repository's URL. Through the `values` parameter, we enable persistence and request an 8 GiB volume size. This configuration may vary based on your specific requirements for the MySQL deployment.

Finally, if you need to access the MySQL URL or other information outside of Pulumi, you can expose them as stack outputs:

```typescript
export const mysqlEndpoint = mysqlChart.getResourceProperty("v1/Service", "mysql-persistent", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

In the last line, we export the `mysqlEndpoint` variable, which provides the IP address of the MySQL service once it is deployed and its load balancer is allocated an IP. This relies on the chart creating a service named `mysql-persistent`. If the chart has a different service name or you configure it with different values, adjust the getResourceProperty arguments accordingly.

The entire code will provision an AKS and deploy a `mysql-persistent` Helm chart into it:

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

const resourceGroupName = new azure.resources.ResourceGroup("myResourceGroup");

const k8sCluster = new azure.containerservice.KubernetesCluster("myAKSCluster", {
    resourceGroupName: resourceGroupName.name,
    location: resourceGroupName.location,
    defaultNodePool: {
        name: "akspool",
        nodeCount: 2,
        vmSize: "Standard_D2_v2",
    },
    identity: {
        type: "SystemAssigned",
    },
    kubernetesVersion: "1.19.7",
});

const k8sProvider = new kubernetes.Provider("k8sProvider", {
    kubeconfig: k8sCluster.kubeConfigRaw,
});

const mysqlChart = new kubernetes.helm.v3.Chart("mysql-persistent", {
    chart: "mysql",
    version: "1.6.4",
    fetchOpts: {
        repo: "https://charts.bitnami.com/bitnami",
    },
    values: {
        persistence: {
            enabled: true,
            size: "8Gi",
        },
    },
}, { provider: k8sProvider });

export const mysqlEndpoint = mysqlChart.getResourceProperty("v1/Service", "mysql-persistent", "status").apply(status => status.loadBalancer.ingress[0].ip);
```

To run this Pulumi code, you will need to have Pulumi CLI installed and configured with Azure credentials. Save this code in a file with a `.ts` extension, then run `pulumi up` to provision the resources. The process will include creating a new AKS cluster and deploying the MySQL Helm chart within it. After deployment, information about the MySQL instance will be available in the exports from Pulumi.