Event-driven ML Workflows on Azure Container Apps

Question

Pulumi · Accepted Answer

When setting up event-driven machine learning (ML) workflows on Azure using Container Apps, you need to design a system where a particular event (like data arrival, webhook call, etc.) triggers the execution of a container that runs a ML model. The Azure Container Apps service is particularly suited for this kind of workflow since it allows for the deployment of containerized applications that can scale based on events.

Here is a brief overview of what you need to do:

1. **Define the Container App**: Create a container app resource in your infrastructure as code (IaC) that represents the ML container that will be triggered by events.

2. **Configure the Event Trigger**: Depending on the type of event you want to trigger your workflow on, you'll create and configure the appropriate Azure service (like Event Grid, Service Bus, Queue, etc.) and link it with your container app.

3. **Deploy the ML Model**: Ensure that your ML model and its dependencies are properly containerized and deployed to Azure Container Registry, which is then used by the Azure Container App service to run your model.

4. **Set Autoscaling Rules**: Define rules that determine how your application should scale up or down based on the incoming events.

5. **Implement Health Probes**: For resilience, include health probes in your container to allow Azure to monitor your app and restart it if necessary.

6. **Define a Revision Strategy**: In case you have multiple versions of the container running, configure a revision strategy for rolling updates.

Now let's take this overview and translate it into a Pulumi Python program. We'll create a container app, set it to scale based on HTTP traffic for simplicity, and assume that the container image is already pushed to the Azure Container Registry. If your event source is different, you would adjust the scaling rules accordingly.

```python
import pulumi
import pulumi_azure_native as azure_native
from pulumi_azure_native import app

# This example assumes that the Azure Resource Group and the Container App Environment already exist.
# Replace 'your_resource_group_name' and 'your_containerapp_environment_id' with your specific names.
resource_group_name = 'your_resource_group_name'
containerapp_environment_id = 'your_containerapp_environment_id'

# Create the Container App with the necessary properties
container_app = app.ContainerApp("ml-workflow-app",
    resource_group_name=resource_group_name,
    managed_environment_id=containerapp_environment_id,
    configuration=app.ConfigurationArgs(
        dapr=app.DaprArgs(
            enabled=True,  # If you are using Dapr for microservices communication
            app_id="mlapp",  # Replace with your Dapr App ID
            app_port=80,  # The port your app listens on
        ),
        ingress=app.IngressArgs(
            external=True,  # Exposes the app to external traffic
            target_port=80,  # Port to route the external traffic to
        ),
        secrets=[app.SecretArgs(
            name="ml-model-secret",  # Name of the secret
            value="secret_value",  # The secret value, replace with the actual secret
        )],
    ),
    template=app.TemplateArgs(
        containers=[
            app.ContainerArgs(
                name="ml-container",  # Name of the container
                image="your_registry_name.azurecr.io/your_ml_image:latest",  # Replace with your container image path
                resources=app.ContainerResourcesArgs(
                    cpu=1.0,  # Amount of CPU assigned to the container
                    memory="1.5Gi",  # Amount of memory assigned to the container
                ),
            )
        ],
        scale=app.ScaleArgs(
            min_replicas=0,  # Minimum instances for the app (can be scaled down to 0 when not in use)
            max_replicas=5,  # Maximum number of instances
            rules=[app.ScaleRuleArgs(  # The scaling rule
                http=app.ScaleRuleHttpArgs(
                    metadata={
                        "concurrentRequests": "50"  # Number of concurrent requests before scaling out
                    }
                )
            )],
        ),
    ),
    location="westus2",  # Location of your app, replace with the appropriate Azure region
)

# Export the URL of the container app
pulumi.export("url", pulumi.Output.concat("https://", container_app.configuration.apply(lambda c: c.ingress.fqdn)))
```

Here's a breakdown of what this code does:

- We import the necessary Pulumi Azure Native SDKs to define the resources we need.
- We assume that we already have a resource group and a Container App environment set up. These ids are used in the `resource_group_name` and `containerapp_environment_id` variables.
- We create an Azure Container App with the name `ml-workflow-app`, and configure it with:
  - **Dapr for microservices communications** if needed, setting `enabled` to `True` and specifying the `app_id` and `app_port`. Dapr helps to build resilient, event-driven applications, but if you're not using it, you can omit this part.
  - **Ingress settings** defining how the app is exposed to the internet.
  - **Secrets** that might be used by your container, such as connection strings or API keys.
  - **Container configuration** which includes the details about the container image to use and the resources to allocate.
  - **Scaling rules** that dictates when new container instances should be created or destroyed based on the number of concurrent HTTP requests.
- We export the URL of the Container App, which can be used to trigger the ML workflow.

Remember that this is just a basic setup to get you started; you would need to adapt your Pulumi program to the specific needs of your ML workflow and the types of events that you are responding to.