Progressive delivery with automated promotion or demotion

Question

Pulumi · Accepted Answer

Progressive delivery is an advanced deployment technique that allows you to release changes to your software gradually. It typically involves deploying a new version to a subset of users or servers, monitoring the performance and stability, and then using an automated process to increase the rollout or rollback based on certain criteria.

To implement progressive delivery with automated promotion or demotion, you need to:

1. Define a deployment that can be progressively released and monitored.
2. Set up rules or metrics that determine the success of the new version.
3. Automate the process to promote the new version to more users or demote it by rolling back if the criteria are not met.

Let's build this with the Azure platform as an example, using Pulumi to define the infrastructure as code. We will set up an example using Azure App Service's deployment slots to implement the progressive delivery. You can use deployment slots to deploy a new version to a staging slot, warm it up, and then swap it with the production slot if everything looks good.

Below is a Pulumi TypeScript program that demonstrates how to set up an Azure App Service with multiple deployment slots. The actual monitoring, promotion, and demotion logic would need to be implemented as part of your CI/CD pipeline or using Azure Functions or Logic Apps by tapping into the operational insights Azure provides.

Here's how to write the Pulumi code to set up the infrastructure:

```typescript
import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

// Create an Azure Resource Group
const resourceGroup = new azure.core.ResourceGroup("resourceGroup", {
    location: "West US",
});

// Create an Azure App Service Plan
const appServicePlan = new azure.appservice.Plan("appServicePlan", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    kind: "App",
    sku: {
        tier: "Standard",
        size: "S1",
    },
});

// Create an Azure App Service
const appService = new azure.appservice.AppService("appService", {
    resourceGroupName: resourceGroup.name,
    location: resourceGroup.location,
    appServicePlanId: appServicePlan.id,
    httpsOnly: true,
});

// Create a Deployment Slot for the Staging environment
const stagingSlot = new azure.appservice.Slot("stagingSlot", {
    name: "staging",
    appServiceName: appService.name,
    resourceGroupName: resourceGroup.name,
    appServicePlanId: appServicePlan.id,
});

// Export the URL of the Production instance and Staging slot
export const productionUrl = appService.defaultSiteHostname;
export const stagingUrl = stagingSlot.defaultSiteHostname;
```

This program sets up an Azure App Service with a "staging" deployment slot. To implement the progressive delivery, your next steps after deploying this infrastructure would involve:

1. Deploying your app to the staging slot.
2. Verifying the app's performance in the staging slot, using Azure Monitor or any third-party monitoring tool.
3. Swapping the staging slot with the production slot using Azure CLI or the Azure Management Portal if the new version is stable.

The actual continuous deployment logic and criteria for success would be part of your application's operational code or deployment pipeline logic - it isn't something that can be defined directly in the infrastructure code itself.

Implementing full progressive delivery with automatic promotion and demotion would typically incorporate this infrastructure with Application Insights for monitoring, Azure Functions or Logic Apps for automation, and possibly Azure DevOps or another CI/CD system for orchestration of deployment pipelines.