How do I implement canary deployments with weighted traffic splitting?

In this example, we will implement a canary deployment strategy on AWS using Pulumi. Canary deployments allow you to release a new version of your application to a small subset of users before rolling it out to the entire user base. This helps in identifying issues with the new version without affecting all users. We will use AWS Application Load Balancer (ALB) to distribute traffic between the old and new versions of our application based on specified weights.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

// Create an ALB
const alb = new aws.lb.LoadBalancer("app-load-balancer", {
    internal: false,
    loadBalancerType: "application",
    securityGroups: [], // Add appropriate security groups
    subnets: [], // Add appropriate subnets
});

// Create a target group for the old version of the application
const oldTargetGroup = new aws.lb.TargetGroup("old-target-group", {
    port: 80,
    protocol: "HTTP",
    vpcId: "", // Add your VPC ID
    targetType: "instance",
});

// Create a target group for the new version of the application
const newTargetGroup = new aws.lb.TargetGroup("new-target-group", {
    port: 80,
    protocol: "HTTP",
    vpcId: "", // Add your VPC ID
    targetType: "instance",
});

// Create a listener for the ALB
const listener = new aws.lb.Listener("app-listener", {
    loadBalancerArn: alb.arn,
    port: 80,
    protocol: "HTTP",
    defaultActions: [
        {
            type: "forward",
            forward: {
                targetGroups: [
                    { arn: oldTargetGroup.arn, weight: 80 },
                    { arn: newTargetGroup.arn, weight: 20 },
                ],
            },
        },
    ],
});

// Export the ALB DNS name
export const albDnsName = alb.dnsName;

Key Points

• Load Balancer: We create an Application Load Balancer (ALB) to manage incoming traffic.
• Target Groups: Two target groups are created, one for the old version and one for the new version of the application.
• Listener: A listener is set up on the ALB to forward traffic to the target groups based on specified weights (80% to the old version and 20% to the new version).
• Traffic Splitting: The listener’s default action splits traffic between the two target groups using the defined weights.

Summary

In this example, we implemented a canary deployment using AWS Application Load Balancer with Pulumi. We created an ALB, defined two target groups for the old and new versions of the application, and set up a listener to split traffic between these target groups based on specified weights. This setup allows for controlled rollout of the new application version to a subset of users, minimizing risk and ensuring stability.