The aws:evidently/launch:Launch resource, part of the Pulumi AWS provider, defines CloudWatch Evidently launches that control how feature variations are rolled out to users over scheduled time periods. This resource is deprecated; AWS recommends using AppConfig feature flags instead. This guide focuses on four capabilities: scheduled traffic allocation, multi-variation testing, metric monitoring, and segment-based targeting.
Launches belong to Evidently projects and reference features and segments that must exist separately. The examples are intentionally small. Combine them with your own projects, features, and monitoring infrastructure.
Create a launch with scheduled traffic allocation
CloudWatch Evidently launches control how feature variations are rolled out over time. Most launches start with a single variation group and a schedule that defines when traffic shifts occur.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
The groups property defines which feature variations participate in the launch. The scheduledSplitsConfig property controls traffic allocation: each step specifies groupWeights (percentage of traffic to each variation) and a startTime when that allocation takes effect. Here, Variation1 receives 0% of traffic starting at the specified time.
Split traffic across multiple feature variations
A/B tests and multivariate experiments require multiple variation groups to compare different feature implementations.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
description: "first-group",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
description: "second-group",
},
],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
Variation2: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
"description": "first-group",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
"description": "second-group",
},
],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
"Variation2": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
Description: pulumi.String("first-group"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
Description: pulumi.String("second-group"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
"Variation2": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
Description = "first-group",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
Description = "second-group",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
{ "Variation2", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.description("first-group")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.description("second-group")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 0),
Map.entry("Variation2", 0)
))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
description: first-group
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
description: second-group
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
Variation2: 0
startTime: 2024-01-07 01:43:59+00:00
Each group in the groups array represents one feature variation. The scheduledSplitsConfig must include weights for all defined groups. This configuration sets up two variations but allocates 0% traffic to both, preparing the launch for later activation.
Gradually increase traffic with multi-step rollouts
Progressive rollouts reduce risk by gradually shifting traffic from one variation to another over multiple scheduled steps.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
},
],
scheduledSplitsConfig: {
steps: [
{
groupWeights: {
Variation1: 15,
Variation2: 10,
},
startTime: "2024-01-07 01:43:59+00:00",
},
{
groupWeights: {
Variation1: 20,
Variation2: 25,
},
startTime: "2024-01-08 01:43:59+00:00",
},
],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
},
],
scheduled_splits_config={
"steps": [
{
"group_weights": {
"Variation1": 15,
"Variation2": 10,
},
"start_time": "2024-01-07 01:43:59+00:00",
},
{
"group_weights": {
"Variation1": 20,
"Variation2": 25,
},
"start_time": "2024-01-08 01:43:59+00:00",
},
],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(15),
"Variation2": pulumi.Int(10),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(20),
"Variation2": pulumi.Int(25),
},
StartTime: pulumi.String("2024-01-08 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 15 },
{ "Variation2", 10 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 20 },
{ "Variation2", 25 },
},
StartTime = "2024-01-08 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(
LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 15),
Map.entry("Variation2", 10)
))
.startTime("2024-01-07 01:43:59+00:00")
.build(),
LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 20),
Map.entry("Variation2", 25)
))
.startTime("2024-01-08 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 15
Variation2: 10
startTime: 2024-01-07 01:43:59+00:00
- groupWeights:
Variation1: 20
Variation2: 25
startTime: 2024-01-08 01:43:59+00:00
Multiple steps in scheduledSplitsConfig create a phased rollout. The first step allocates 15% to Variation1 and 10% to Variation2 starting January 7. The second step increases allocation to 20% and 25% respectively on January 8. Each step’s startTime determines when the new weights take effect.
Monitor launch performance with custom metrics
Launches can track business metrics to measure the impact of feature variations on user behavior or system performance.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
metricMonitors: [
{
metricDefinition: {
entityIdKey: "entity_id_key1",
eventPattern: "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
name: "name1",
unitLabel: "unit_label1",
valueKey: "value_key1",
},
},
{
metricDefinition: {
entityIdKey: "entity_id_key2",
eventPattern: "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
name: "name2",
unitLabel: "unit_label2",
valueKey: "value_key2",
},
},
],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
metric_monitors=[
{
"metric_definition": {
"entity_id_key": "entity_id_key1",
"event_pattern": "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
"name": "name1",
"unit_label": "unit_label1",
"value_key": "value_key1",
},
},
{
"metric_definition": {
"entity_id_key": "entity_id_key2",
"event_pattern": "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
"name": "name2",
"unit_label": "unit_label2",
"value_key": "value_key2",
},
},
],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
MetricMonitors: evidently.LaunchMetricMonitorArray{
&evidently.LaunchMetricMonitorArgs{
MetricDefinition: &evidently.LaunchMetricMonitorMetricDefinitionArgs{
EntityIdKey: pulumi.String("entity_id_key1"),
EventPattern: pulumi.String("{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}"),
Name: pulumi.String("name1"),
UnitLabel: pulumi.String("unit_label1"),
ValueKey: pulumi.String("value_key1"),
},
},
&evidently.LaunchMetricMonitorArgs{
MetricDefinition: &evidently.LaunchMetricMonitorMetricDefinitionArgs{
EntityIdKey: pulumi.String("entity_id_key2"),
EventPattern: pulumi.String("{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}"),
Name: pulumi.String("name2"),
UnitLabel: pulumi.String("unit_label2"),
ValueKey: pulumi.String("value_key2"),
},
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
MetricMonitors = new[]
{
new Aws.Evidently.Inputs.LaunchMetricMonitorArgs
{
MetricDefinition = new Aws.Evidently.Inputs.LaunchMetricMonitorMetricDefinitionArgs
{
EntityIdKey = "entity_id_key1",
EventPattern = "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
Name = "name1",
UnitLabel = "unit_label1",
ValueKey = "value_key1",
},
},
new Aws.Evidently.Inputs.LaunchMetricMonitorArgs
{
MetricDefinition = new Aws.Evidently.Inputs.LaunchMetricMonitorMetricDefinitionArgs
{
EntityIdKey = "entity_id_key2",
EventPattern = "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
Name = "name2",
UnitLabel = "unit_label2",
ValueKey = "value_key2",
},
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchMetricMonitorArgs;
import com.pulumi.aws.evidently.inputs.LaunchMetricMonitorMetricDefinitionArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.metricMonitors(
LaunchMetricMonitorArgs.builder()
.metricDefinition(LaunchMetricMonitorMetricDefinitionArgs.builder()
.entityIdKey("entity_id_key1")
.eventPattern("{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}")
.name("name1")
.unitLabel("unit_label1")
.valueKey("value_key1")
.build())
.build(),
LaunchMetricMonitorArgs.builder()
.metricDefinition(LaunchMetricMonitorMetricDefinitionArgs.builder()
.entityIdKey("entity_id_key2")
.eventPattern("{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}")
.name("name2")
.unitLabel("unit_label2")
.valueKey("value_key2")
.build())
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
metricMonitors:
- metricDefinition:
entityIdKey: entity_id_key1
eventPattern: '{"Price":[{"numeric":[">",11,"<=",22]}]}'
name: name1
unitLabel: unit_label1
valueKey: value_key1
- metricDefinition:
entityIdKey: entity_id_key2
eventPattern: '{"Price":[{"numeric":[">",9,"<=",19]}]}'
name: name2
unitLabel: unit_label2
valueKey: value_key2
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
The metricMonitors property defines metrics to track during the launch. Each metricDefinition specifies an entityIdKey (identifies the entity being measured), eventPattern (JSON filter for relevant events), and valueKey (extracts the metric value). The eventPattern uses JSON syntax to filter events, here matching prices in specific numeric ranges.
Target specific user segments with overrides
Some launches need to treat different user segments differently, routing specific audiences to particular variations regardless of the overall traffic split.
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
},
],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
Variation2: 0,
},
segmentOverrides: [
{
evaluationOrder: 1,
segment: exampleAwsEvidentlySegment.name,
weights: {
Variation2: 10000,
},
},
{
evaluationOrder: 2,
segment: exampleAwsEvidentlySegment.name,
weights: {
Variation1: 40000,
Variation2: 30000,
},
},
],
startTime: "2024-01-08 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
},
],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
"Variation2": 0,
},
"segment_overrides": [
{
"evaluation_order": 1,
"segment": example_aws_evidently_segment["name"],
"weights": {
"Variation2": 10000,
},
},
{
"evaluation_order": 2,
"segment": example_aws_evidently_segment["name"],
"weights": {
"Variation1": 40000,
"Variation2": 30000,
},
},
],
"start_time": "2024-01-08 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
"Variation2": pulumi.Int(0),
},
SegmentOverrides: evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArray{
&evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs{
EvaluationOrder: pulumi.Int(1),
Segment: pulumi.Any(exampleAwsEvidentlySegment.Name),
Weights: pulumi.IntMap{
"Variation2": pulumi.Int(10000),
},
},
&evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs{
EvaluationOrder: pulumi.Int(2),
Segment: pulumi.Any(exampleAwsEvidentlySegment.Name),
Weights: pulumi.IntMap{
"Variation1": pulumi.Int(40000),
"Variation2": pulumi.Int(30000),
},
},
},
StartTime: pulumi.String("2024-01-08 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
{ "Variation2", 0 },
},
SegmentOverrides = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs
{
EvaluationOrder = 1,
Segment = exampleAwsEvidentlySegment.Name,
Weights =
{
{ "Variation2", 10000 },
},
},
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs
{
EvaluationOrder = 2,
Segment = exampleAwsEvidentlySegment.Name,
Weights =
{
{ "Variation1", 40000 },
{ "Variation2", 30000 },
},
},
},
StartTime = "2024-01-08 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 0),
Map.entry("Variation2", 0)
))
.segmentOverrides(
LaunchScheduledSplitsConfigStepSegmentOverrideArgs.builder()
.evaluationOrder(1)
.segment(exampleAwsEvidentlySegment.name())
.weights(Map.of("Variation2", 10000))
.build(),
LaunchScheduledSplitsConfigStepSegmentOverrideArgs.builder()
.evaluationOrder(2)
.segment(exampleAwsEvidentlySegment.name())
.weights(Map.ofEntries(
Map.entry("Variation1", 40000),
Map.entry("Variation2", 30000)
))
.build())
.startTime("2024-01-08 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
Variation2: 0
segmentOverrides:
- evaluationOrder: 1
segment: ${exampleAwsEvidentlySegment.name}
weights:
Variation2: 10000
- evaluationOrder: 2
segment: ${exampleAwsEvidentlySegment.name}
weights:
Variation1: 40000
Variation2: 30000
startTime: 2024-01-08 01:43:59+00:00
The segmentOverrides property within each step allows segment-specific traffic allocation. The evaluationOrder determines which override applies when a user matches multiple segments. The weights property allocates traffic within that segment, using basis points (10000 = 100%). Here, one segment receives 100% Variation2, while another splits between both variations.
Beyond these examples
These snippets focus on specific launch-level features: scheduled traffic allocation and multi-step rollouts, metric monitoring and performance tracking, and segment-based targeting. They’re intentionally minimal rather than full experimentation frameworks.
The examples reference pre-existing infrastructure such as Evidently projects and features, and Evidently segments for segment overrides. They focus on configuring the launch rather than provisioning the surrounding experimentation infrastructure.
To keep things focused, common launch patterns are omitted, including:
- Randomization salt configuration (randomizationSalt)
- Launch descriptions and metadata (description, tags)
- Launch lifecycle management (starting, stopping, status monitoring)
These omissions are intentional: the goal is to illustrate how each launch feature is wired, not provide drop-in experimentation modules. See the Evidently Launch resource reference for all available configuration options.
Let's configure AWS Evidently Launches
Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.
Try Pulumi Cloud for FREEFrequently Asked Questions
Deprecation & Migration
Should I still use CloudWatch Evidently Launch?
No, this resource is deprecated. Use AWS AppConfig feature flags instead for new projects.
Configuration Limits
How many groups can I add to a launch?
You can configure one to five groups, each containing a feature and variation.
How many metric monitors can I add?
You can add one to three metric monitors to track launch performance.
What are the length limits for the launch name?
The launch name must be between 1 and 127 characters.
Immutability & Updates
What properties are immutable after creating a launch?
Both
name and project are immutable. Changing either property forces resource replacement.Traffic Management & Randomization
What happens if I don't set randomizationSalt?
If you omit
randomizationSalt, Evidently uses the launch name as the randomization salt by default.How do I schedule traffic splits across multiple steps?
Configure
scheduledSplitsConfig with multiple steps, each specifying groupWeights and startTime for gradual rollout.Can I target specific user segments with different traffic weights?
Yes, use
segmentOverrides within scheduledSplitsConfig steps, specifying evaluationOrder, segment, and weights for each override.Import & Management
How do I import an existing Evidently launch?
Use the format
launchName:projectName or launchName:projectArn separated by a colon during import.Using a different cloud?
Explore monitoring guides for other cloud providers: