Slot-Specific Configurations for AI Services on Azure App Service

Question

Pulumi · Accepted Answer

In Azure App Service, deployment slots are live apps with their own hostnames. App content and configurations elements can be swapped between two deployment slots, including the production slot. Slot-specific configurations allow you to test your app in a staging deployment slot before swapping it with the production slot.

Deployment slot settings are actually stored as part of the Azure App Service configuration. This means that when you deploy changes to the staging slot, your app settings, connection strings, and general configuration values can stay with the slot on a swap operation, if configured as such.

To enable slot-specific settings for an Azure App Service, you will define settings that are 'sticky' to the deployment slot and which remain with the slot after a swap is performed. For settings such as connection strings or app settings, you can select the option to make them slot-specific in the Azure Portal or via Azure Resource Management templates.

For AI services in Azure App Service, specific aspects like API keys or endpoint URLs pertinent to an AI service could be configured as slot-specific settings to ensure the correct link with either the staging or production environment upon deployment or slot-swapping.

Let's proceed to write a Pulumi program that creates an app service, an app service plan, which is required to host any app service, and then a deployment slot with slot-specific configurations. I'll walk you through the resources and properties used to accomplish this.

First, we set up an App Service Plan, which is the hosting plan within Azure specifying the location and capabilities of our App Service. Then, we create an App Service within this plan. Following, we add a deployment slot to the App Service, and specify some slot-specific app settings which could represent our AI service configurations.

```python
import pulumi
import pulumi_azure as azure

# Create an Azure Resource Group
resource_group = azure.core.ResourceGroup('rg', location='West US')

# Create an Azure App Service Plan
app_service_plan = azure.appservice.Plan('app-service-plan',
    resource_group_name=resource_group.name,
    kind='App',
    sku=azure.appservice.PlanSkuArgs(
        tier='Basic',
        size='B1'
    )
)

# Create an Azure App Service
app_service = azure.appservice.AppService('app-service',
    resource_group_name=resource_group.name,
    app_service_plan_id=app_service_plan.id,
    site_config=azure.appservice.AppServiceSiteConfigArgs(
        dotnet_framework_version='v4.0'
    ),
    app_settings={
        "SOME_SETTING": "my_value", # Non-sticky setting that applies to all slots
    }
)

# Create a deployment slot with slot-specific configuration (sticky to the slot)
slot = azure.appservice.Slot('staging-slot',
    resource_group_name=resource_group.name,
    app_service_name=app_service.name,
    app_service_plan_id=app_service_plan.id,
    location=resource_group.location,
    app_settings={
        "AI_API_KEY": "staging_key", # A slot-specific setting for AI services
        "AI_ENDPOINT": "staging_endpoint" # A slot-specific setting for AI services
    }
)

# Export the web app endpoint
pulumi.export('endpoint', slot.default_site_hostname)
```

Explanation of resources used:

- `azure.core.ResourceGroup`: Manages a resource group, which is a container that holds related resources for an Azure solution.
- `azure.appservice.Plan`: Manages an App Service Plan, which defines the location and capabilities like the size and scaling features of the web app.
- `azure.appservice.AppService`: Manages an Azure App Service, a service for hosting web applications, REST APIs, and back-end services.
- `azure.appservice.Slot`: Manages a deployment slot within the Azure App Service, allowing for testing in a clone of your production environment.

In the example above, we create a staging slot for the app service. Notice how we configure the `app_settings` with hypothetical AI service keys and endpoints. These settings are meant to be examples of what you could set as slot-specific configurations (stick to a slot during swaps).

Lastly, we export the hostname of the staging slot which can be used to access the deployed app in the slot.

This program serves as a template; you would replace values like `AI_API_KEY` and `AI_ENDPOINT` with actual configuration values for your AI services and set up the region, resource group, and app service plan details as per your requirements.