API Versioning in ML Model Serving with Azure API Management

Question

Pulumi · Accepted Answer

API versioning is an essential feature in software development, especially for services that are consumed by a variety of clients. It ensures backward compatibility while enabling iterative feature enhancements and maintenance. In a machine learning (ML) context, serving different versions of ML models is critical, as different clients might depend on different versions of the same model.

Azure API Management (APIM) is a service that helps create consistent and modern API gateways for existing backend services. It supports API versioning, making it an excellent choice for serving different versions of ML models.

Below is a Pulumi program that sets up Azure API Management with API versioning for ML model serving. The program will:

1. Define an API Version Set - This is a set of versioning configurations that determine how your API versions are set up and identified.
2. Create an API and link it to the API Version Set - Here, we'll set up the actual API instance and link it to the version set defined earlier.
3. Release the API - After setting up your API, a release step is required to make a specific instance of the API available for consumption.

We'll use `azure-native` resource providers, as they offer the most updated resources and management capabilities for Azure services.

```python
import pulumi
from pulumi_azure_native import apimanagement as apim

# Create an Azure Resource Group
resource_group = apim.ResourceGroup("resourceGroup")

# Create an instance of Azure API Management
api_management_service = apim.ApiManagementService("apiManagementService",
    resource_group_name=resource_group.name,
    location=resource_group.location,
    publisher_name="Your Publisher Name",
    publisher_email="publisher@email.com",
    sku_name="Consumption_0",  # For demo purposes, we choose the Consumption tier
)

# Define API Version Set
version_set = apim.ApiVersionSet("apiVersionSet",
    resource_group_name=resource_group.name,
    service_name=api_management_service.name,
    display_name="ML Model Serving Versions",
    versioning_scheme="Segment",  # This could be "Header", "Query", or "Segment", depending on your preference.
)

# Create an API linked to the Version Set for our ML model
api_v1 = apim.Api("apiV1",
    resource_group_name=resource_group.name,
    service_name=api_management_service.name,
    api_id="ml-model-v1",
    display_name="ML Model Serving v1",
    path="ml-model",
    api_version="v1",
    api_version_set_id=version_set.id,
    description="Version 1 of the ML Model Serving API",
    protocols=["https"],  # Use only secure protocols
    service_url="http://backend-for-ml-model-v1",  # Your actual service URL goes here
)

# Release the API version v1, making it available for consumption
release_v1 = apim.ApiRelease("releaseV1",
    resource_group_name=resource_group.name,
    service_name=api_management_service.name,
    api_id=api_v1.id,
    release_id="ml-model-release-v1",
    api_release_notes="Initial Release of ML Model v1",
)

# Export the Public IP that can consume the API
pulumi.export("apiManagementServiceIp", api_management_service.public_ip_addresses)
```

### Explanation

- We start by creating a `ResourceGroup` which is a logical container for Azure resources.
- We then instantiate an `ApiManagementService`, which is our APIM service.
- An `ApiVersionSet` is defined to specify how API versions will be managed. The `versioning_scheme` parameter allows you to choose how the version information is provided when calling the API.
- Next, we create an actual API (`apiV1`) that serves the first version of the ML model. The `path` specifies the URL path, the `api_version` indicates the API's version, and the `service_url` is the actual endpoint of the model-serving backend.
- We also create an `ApiRelease` to make the API version available for clients to consume. The `release_id` and `api_release_notes` help to document and identify the release in the management console.
  
By orchestrating these resources together, we can effectively manage versions of APIs used to serve ML models with Azure APIM. The Public IP address(es) of the deployed API Management Service is exported so you can access the service externally.