Real-time Machine Learning with Fastly CDN

Question

Pulumi · Accepted Answer

To set up a real-time machine learning scenario with a CDN like Fastly, we'll need two main components:

1. **Machine Learning API Service**: A backend service that hosts our machine learning model which can perform real-time inferences. This service needs to be scalable and accessible from the internet.

2. **Content Delivery Network**: A CDN like Fastly that can cache and deliver content with low latency. While a CDN is generally used for caching static resources, it can also be used to route requests to a dynamic backend like our Machine Learning API Service.

Here, I’ll create a Python Pulumi program that configures an Azure environment to host a machine learning service that is made available through Fastly. However, as of my last update, Pulumi doesn't have direct integration with Fastly. So, I'll focus on setting up the Azure part, which will be ready to connect to Fastly as a backend.

We will use:
- Azure Machine Learning to host our ML model.
- Azure App Service to deploy our ML API as a web app, which will be the backend for Fastly.
- Pulumi's Azure Native provider, which provides direct access to Azure resources.

Here is a high-level overview of what the program does:
- It creates an Azure resource group to hold all of our resources.
- It then provisions an Azure Machine Learning workspace.
- Following this, we set up an App Service Plan and a Web App where we can deploy our ML service API.
- Lastly, we export the necessary endpoints that will be used to connect the services to the Fastly CDN.

Let's write the program:

```python
import pulumi
import pulumi_azure_native as azure_native

# Create an Azure Resource Group
resource_group = azure_native.resources.ResourceGroup("ml-cdn-resource-group")

# Create an Azure Machine Learning Workspace
ml_workspace = azure_native.machinelearningservices.Workspace(
    "ml-workspace",
    resource_group_name=resource_group.name,
    location=resource_group.location,
    sku=azure_native.machinelearningservices.SkuArgs(
        name="Standard_DS1_V2"
    ),
    identity=azure_native.machinelearningservices.IdentityArgs(
        type="SystemAssigned"
    )
)

# Set up Azure App Service Plan
app_service_plan = azure_native.web.AppServicePlan(
    "app-service-plan",
    resource_group_name=resource_group.name,
    location=resource_group.location,
    sku=azure_native.web.SkuDescriptionArgs(
        name="B1",  # Basic tier, which is good for a dev/test environment
        tier="Basic",
        size="B1",
        family="B",
        capacity=1
    )
)

# Deploy an App Service with a dummy image for illustration purposes
app_service = azure_native.web.WebApp(
    "ml-service-api",
    resource_group_name=resource_group.name,
    location=resource_group.location,
    server_farm_id=app_service_plan.id,
    site_config=azure_native.web.SiteConfigArgs(
        app_settings=[
            azure_native.web.NameValuePairArgs(
                name="WEBSITES_PORT",
                value="80",  # Assuming the ML service API runs on port 80
            ),
        ],
    ),
)

# Export the Web App endpoint - this will be used to connect to Fastly
pulumi.export("web_app_endpoint", app_service.default_site_hostname)
```

Let's break this down:

- `ResourceGroup`: This is a container that holds related resources for an Azure solution.

- `Workspace`: Azure Machine Learning workspace is an Azure resource that provides a central place for all machine learning activities.

- `AppServicePlan`: This is a plan that defines the resources available to a web app running in Azure.

- `WebApp`: Represents our API service, hosting the machine learning model which Fastly would use as its origin.

Once you've set up these resources, you would then go to your Fastly dashboard and create a service that routes requests to the `web_app_endpoint`. You would configure Fastly to handle caching rules and any other CDN-specific settings according to your needs.

Please note that an actual machine learning application would have additional requirements, like a scoring script, a properly trained model, and potentially other components like data storage or an event hub, that are not covered in this infrastructure code. Also, managing application deployment and versioning the model are tasks that would need further automation scripts and DevOps workflows.

To proceed with deploying a real-world machine learning service, you would need to supplement infrastructure as code with continuous deployment tools and practices, and connection to the CDN would need to be set up via corresponding API or management console, outside of Pulumi.