AI Application Traffic Routing with Azure App Service Slots

Question

Pulumi · Accepted Answer

Azure App Service is a fully managed platform for building, deploying, and scaling web apps. One of the powerful features of Azure App Service is the ability to use deployment slots, which are live apps with their own hostnames that can be used for testing, staging, and rolling out updates with minimal downtime.

Deployment slots are ideal for traffic routing scenarios where you may want to direct a small percentage of production traffic to a new version of your application to validate changes before a full rollout. A common pattern is to have a 'production' slot which is the live application, and a 'staging' slot which can be used to validate the next release.

Traffic routing in Azure App Service can be achieved by configuring the traffic percentages to various slots. You can have multiple slots, and you can route a certain percentage of traffic to each one without having to domain names or load balancers.

In this Pulumi program, we create an Azure App Service with two slots: `production` and `staging`. The `production` slot is the live version of the app, while the `staging` slot receives a smaller portion of the traffic. You can adjust the traffic percentages as needed.

Below is a program that demonstrates how to achieve this setup using Pulumi with Azure.

```python
import pulumi
import pulumi_azure_native as azure_native

# Configuration for the App Service (replace these with your own values or Pulumi config)
app_service_name = "my-app-service"
resource_group_name = "my-resource-group"

# Create an Azure Resource Group
resource_group = azure_native.resources.ResourceGroup("resource_group",
                                                      resource_group_name=resource_group_name)

# Create an App Service Plan
app_service_plan = azure_native.web.AppServicePlan("app_service_plan",
                                                   resource_group_name=resource_group.name,
                                                   kind="App",
                                                   sku=azure_native.web.SkuDescriptionArgs(
                                                       name="F1",
                                                       tier="Free"
                                                   ))

# Create the Production App Service
production_app_service = azure_native.web.WebApp("production_app_service",
                                                 resource_group_name=resource_group.name,
                                                 server_farm_id=app_service_plan.id)

# Create a Staging slot for the App Service
staging_slot = azure_native.web.WebAppSlot("staging_slot",
                                           resource_group_name=resource_group.name,
                                           name=production_app_service.name,
                                           slot="staging")

# Route 10% of the traffic to the Staging Slot and 90% to Production
# Setting the traffic percentage on the staging slot
staging_slot_traffic_routing = azure_native.web.WebAppSlotConfigurationNames("staging_slot_traffic_routing",
                                                                             resource_group_name=resource_group.name,
                                                                             name=production_app_service.name,
                                                                             slot=staging_slot.name,
                                                                             sticky_slot_configuration_names=azure_native.web.SlotSwapStatusArgs(
                                                                                 routing_rules=[
                                                                                     azure_native.web.RampUpRuleArgs(
                                                                                         action_host_name=staging_slot.id,
                                                                                         change_step=10,
                                                                                         change_interval_in_minutes=5,
                                                                                         min_reroute_percentage=0,
                                                                                         max_reroute_percentage=10,
                                                                                         name="staging_traffic",
                                                                                         reroute_percentage=10,
                                                                                     )
                                                                                 ]
                                                                             ))

# Export the URLs of the production and staging slots
pulumi.export("production_url", production_app_service.default_host_name)
pulumi.export("staging_url", staging_slot.default_host_name)
```

In this program:

1. We start by creating a resource group using the `ResourceGroup` class, which is a logical container for resources deployed on Azure.
2. An `AppServicePlan` is then created where we specify our preferred pricing tier and size.
3. Next, we create the production app service (`WebApp`) within this plan. This is where your production application lives.
4. We define a deployment slot named `staging` using the `WebAppSlot` class. This will handle the pre-production version of your app.
5. We define a `WebAppSlotConfigurationNames` to specify the traffic routing rule. Here we’re telling Azure to direct 10% of the traffic to the staging slot and hence, by default, the rest (90%) goes to production.
6. Finally, we export the hostnames of the production and staging slots so that they can be accessed from the Pulumi stack's output.

**Note:** The percentage of traffic is defined in the `RampUpRuleArgs` of the `staging_slot_traffic_routing`. The `change_step` determines the percentage point increases, the `change_interval_in_minutes` determines the time before the next increase in traffic percentage, `min_reroute_percentage` and `max_reroute_percentage` define the range of traffic routing, and `reroute_percentage` sets the fixed percentage of traffic to reroute.

This pattern can be extended to have more complex deployment strategies, such as blue-green deployments, feature toggles, or A/B testing scenarios. Remember to adjust your routing percentages and intervals according to your specific use case and traffic volume.