Kubernetes-based MLOps with Azure ML & AKS

Question

Pulumi · Accepted Answer

To set up Kubernetes-based MLOps on Azure, we'll break the task down into a few key steps:

1. Provision an Azure Kubernetes Service (AKS) cluster, which will be the environment where our machine learning models will be trained and deployed.
2. Set up Azure Machine Learning (Azure ML), which will provide the MLOps capabilities such as experiment tracking, model management, and operationalization features.

Let's go through each step with the corresponding Pulumi resources, explaining their roles and how they fit into our MLOps setup.

### Step 1: Provision an AKS Cluster

We will use the `ManagedCluster` class from the `azure-native.containerservice` module to create an AKS cluster. This class represents an AKS cluster in Azure and allows you to configure various aspects like node size, count, and Kubernetes version, among other settings.

### Step 2: Set up Azure Machine Learning

The Azure Machine Learning workspace is a foundational resource in the cloud that you use to experiment, train, and deploy machine learning models. We'll use the `Workspace` class from the `azure-native.machinelearningservices` module to create an Azure ML workspace.

Now let's put it all together into a Pulumi program written in Python:

```python
import pulumi
import pulumi_azure_native.containerservice as containerservice
import pulumi_azure_native.resources as resources
import pulumi_azure_native.machinelearningservices as machinelearningservices

# First, we need to create a resource group where all our resources will live
resource_group = resources.ResourceGroup('rg')

# Now let's create the AKS cluster. For simplicity, we use default settings for node size and count.
aks_cluster = containerservice.ManagedCluster(
    'aksCluster',
    resource_group_name=resource_group.name,
    agent_pool_profiles=[{
        'count': 3,
        'max_pods': 110,
        'mode': 'System',
        'name': 'agentpool',
        'node_labels': {},
        'os_type': 'Linux',
        'vm_size': 'Standard_DS2_v2',
    }],
    dns_prefix='aksmlops',
    enable_rbac=True,  # Enable RBAC for Kubernetes authorization
    kubernetes_version='1.18.14',  # Specify the version of Kubernetes
    location=resource_group.location,
    sku={
        'name': 'Basic',
        'tier': 'Free',
    }
)

# Create the Azure ML workspace
ml_workspace = machinelearningservices.Workspace(
    'mlWorkspace',
    resource_group_name=resource_group.name,
    location=resource_group.location,
    sku='Enterprise'  # Choose the Enterprise SKU for more advanced capabilities
)

# Export the AKS cluster name and Azure ML Workspace name
pulumi.export('aks_cluster_name', aks_cluster.name)
pulumi.export('ml_workspace_name', ml_workspace.name)
```

This code sets up an Azure Kubernetes Service (AKS) cluster and an Azure ML workspace. The AKS cluster is configured with three nodes using a Standard_DS2_v2 VM size and enables RBAC for security. It specifies a Kubernetes version; make sure to choose a version supported by Azure at the time of deployment.

The ML workspace is set up with an Enterprise SKU, which provides more features than the basic version. This is a foundational setup and can be expanded with additional configurations such as virtual networks, container registries, storage accounts, and more, depending on the MLOps requirements.

To execute this program, you would need to have the Pulumi CLI installed and configured for your Azure account. Save the code in a file called `__main__.py`, and run it using the pulumi CLI.

Please note that deploying infrastructure will incur costs in your Azure account according to the services used and the pricing tier you choose. Always review the service plans and costs associated with Azure services before provisioning resources.