Real-time Machine Learning Model Inference Scoring with Azure Event Grid

Question

Pulumi · Accepted Answer

To accomplish real-time machine learning model inference scoring with Azure Event Grid, we will set up an Azure Event Grid system that subscribes to events from your machine learning service and triggers an Azure Function for scoring. The Azure Function will then handle the scoring of the data in real time as the events are received.

Below is a step-by-step explanation of the infrastructure we'll create with Pulumi in Python:

1. **Azure Event Grid Topic**: A custom topic that will receive events from your machine learning service. This is the endpoint to which you'll send event data for scoring.

2. **Azure Function**: A serverless compute service that will handle the execution of your scoring code when an event is received. Azure Functions allow for executing code in response to events without the need for managing infrastructure.

3. **Event Grid Subscription**: An event subscription will route the events from the Event Grid Topic to the Azure Function.

4. **Azure Storage Account**: This is required as Azure Functions need a storage account. The account will store the code and configurations for the function, and can also be used to store any logs or outputs.

Now, here's the Pulumi program that will create these resources:

```python
import pulumi
import pulumi_azure_native as azure_native

# Step 1: Create the Event Grid Topic
topic = azure_native.eventgrid.Topic("eventgrid_topic",
                                     resource_group_name="your_resource_group_name",
                                     location="your_azure_location")

# Step 2: Create the Azure Function
# First, create a storage account for the function
storage_account = azure_native.storage.StorageAccount("storageaccount",
                                                      resource_group_name="your_resource_group_name",
                                                      location="your_azure_location",
                                                      sku=azure_native.storage.SkuArgs(name="Standard_LRS"),
                                                      kind="StorageV2")

# Create a container in the storage account
storage_container = azure_native.storage.BlobContainer("storagecontainer",
                                                       resource_group_name="your_resource_group_name",
                                                       account_name=storage_account.name)

# Now create the function app
function_app = azure_native.web.FunctionApp("functionapp",
                                            resource_group_name="your_resource_group_name",
                                            location="your_azure_location",
                                            app_service_plan_id="your_app_service_plan_id",
                                            storage_account_name=storage_account.name)

# Step 3: Create the Event Grid Subscription to subscribe to the Topic
# and route events to the Azure Function
event_subscription = azure_native.eventgrid.EventSubscription("event_subscription",
                                                              scope=topic.id,
                                                              destination=azure_native.eventgrid.AzureFunctionEventSubscriptionDestinationArgs(
                                                                  resource_id=function_app.id,
                                                              ))

# Export the URL endpoint of the function, which can be used as an HTTP trigger
function_app_url = function_app.default_hostname.apply(lambda hostname: f"https://{hostname}")
pulumi.export("function_app_url", function_app_url)

# Export the primary endpoint of the topic to which events will be sent
topic_primary_endpoint = topic.endpoint
pulumi.export("topic_primary_endpoint", topic_primary_endpoint)
```

Replace `"your_resource_group_name"`, `"your_azure_location"`, and `"your_app_service_plan_id"` with your actual Azure resource group name, location, and App Service Plan ID. These are required to provision the resources in the correct location and associate them with the existing resources.

Please note:
- The `AzureFunctionEventSubscriptionDestinationArgs` configures the event subscription to send the triggering event to the Azure Function we created.
- The `storage_account` is required for the Azure Function for storing configuration and executable code.

Running this Pulumi program will set groundwork for your machine learning model scoring pipeline. You would then deploy your machine learning scoring code to the Azure Function to complete the setup.