Launch class

Provides a CloudWatch Evidently Launch resource.

> Warning: This resource is deprecated. Use AWS AppConfig feature flags instead.

Example Usage

Basic

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

const example = new aws.evidently.Launch("example", {
    scheduledSplitsConfig: {
        steps: [{
            groupWeights: {
                Variation1: 0,
            },
            startTime: "2024-01-07 01:43:59+00:00",
        }],
    },
    groups: [{
        feature: exampleAwsEvidentlyFeature.name,
        name: "Variation1",
        variation: "Variation1",
    }],
    name: "example",
    project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    scheduled_splits_config={
        "steps": [{
            "group_weights": {
                "Variation1": 0,
            },
            "start_time": "2024-01-07 01:43:59+00:00",
        }],
    },
    groups=[{
        "feature": example_aws_evidently_feature["name"],
        "name": "Variation1",
        "variation": "Variation1",
    }],
    name="example",
    project=example_aws_evidently_project["name"])
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()
    {
        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",
                },
            },
        },
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = exampleAwsEvidentlyFeature.Name,
                Name = "Variation1",
                Variation = "Variation1",
            },
        },
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
    });

});
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{
			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"),
					},
				},
			},
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(exampleAwsEvidentlyFeature.Name),
					Name:      pulumi.String("Variation1"),
					Variation: pulumi.String("Variation1"),
				},
			},
			Name:    pulumi.String("example"),
			Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_evidently_launch" "example" {
  scheduled_splits_config = {
    steps = [{
      "groupWeights" = {
        "Variation1" = 0
      }
      "startTime" = "2024-01-07 01:43:59+00:00"
    }]
  }
  groups {
    feature   = exampleAwsEvidentlyFeature.name
    name      = "Variation1"
    variation = "Variation1"
  }
  name    = "example"
  project = exampleAwsEvidentlyProject.name
}
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.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
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()
            .scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
                .steps(LaunchScheduledSplitsConfigStepArgs.builder()
                    .groupWeights(Map.of("Variation1", 0))
                    .startTime("2024-01-07 01:43:59+00:00")
                    .build())
                .build())
            .groups(LaunchGroupArgs.builder()
                .feature(exampleAwsEvidentlyFeature.name())
                .name("Variation1")
                .variation("Variation1")
                .build())
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .build());

    }
}
resources:
  example:
    type: aws:evidently:Launch
    properties:
      scheduledSplitsConfig:
        steps:
          - groupWeights:
              Variation1: 0
            startTime: 2024-01-07 01:43:59+00:00
      groups:
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation1
          variation: Variation1
      name: example
      project: ${exampleAwsEvidentlyProject.name}

With description

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

const example = new aws.evidently.Launch("example", {
    scheduledSplitsConfig: {
        steps: [{
            groupWeights: {
                Variation1: 0,
            },
            startTime: "2024-01-07 01:43:59+00:00",
        }],
    },
    groups: [{
        feature: exampleAwsEvidentlyFeature.name,
        name: "Variation1",
        variation: "Variation1",
    }],
    name: "example",
    project: exampleAwsEvidentlyProject.name,
    description: "example description",
});
import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    scheduled_splits_config={
        "steps": [{
            "group_weights": {
                "Variation1": 0,
            },
            "start_time": "2024-01-07 01:43:59+00:00",
        }],
    },
    groups=[{
        "feature": example_aws_evidently_feature["name"],
        "name": "Variation1",
        "variation": "Variation1",
    }],
    name="example",
    project=example_aws_evidently_project["name"],
    description="example description")
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()
    {
        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",
                },
            },
        },
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = exampleAwsEvidentlyFeature.Name,
                Name = "Variation1",
                Variation = "Variation1",
            },
        },
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
        Description = "example description",
    });

});
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{
			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"),
					},
				},
			},
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(exampleAwsEvidentlyFeature.Name),
					Name:      pulumi.String("Variation1"),
					Variation: pulumi.String("Variation1"),
				},
			},
			Name:        pulumi.String("example"),
			Project:     pulumi.Any(exampleAwsEvidentlyProject.Name),
			Description: pulumi.String("example description"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_evidently_launch" "example" {
  scheduled_splits_config = {
    steps = [{
      "groupWeights" = {
        "Variation1" = 0
      }
      "startTime" = "2024-01-07 01:43:59+00:00"
    }]
  }
  groups {
    feature   = exampleAwsEvidentlyFeature.name
    name      = "Variation1"
    variation = "Variation1"
  }
  name        = "example"
  project     = exampleAwsEvidentlyProject.name
  description = "example description"
}
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.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
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()
            .scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
                .steps(LaunchScheduledSplitsConfigStepArgs.builder()
                    .groupWeights(Map.of("Variation1", 0))
                    .startTime("2024-01-07 01:43:59+00:00")
                    .build())
                .build())
            .groups(LaunchGroupArgs.builder()
                .feature(exampleAwsEvidentlyFeature.name())
                .name("Variation1")
                .variation("Variation1")
                .build())
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .description("example description")
            .build());

    }
}
resources:
  example:
    type: aws:evidently:Launch
    properties:
      scheduledSplitsConfig:
        steps:
          - groupWeights:
              Variation1: 0
            startTime: 2024-01-07 01:43:59+00:00
      groups:
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation1
          variation: Variation1
      name: example
      project: ${exampleAwsEvidentlyProject.name}
      description: example description

With multiple groups

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

const example = new aws.evidently.Launch("example", {
    scheduledSplitsConfig: {
        steps: [{
            groupWeights: {
                Variation1: 0,
                Variation2: 0,
            },
            startTime: "2024-01-07 01:43:59+00:00",
        }],
    },
    groups: [
        {
            feature: exampleAwsEvidentlyFeature.name,
            name: "Variation1",
            variation: "Variation1",
            description: "first-group",
        },
        {
            feature: exampleAwsEvidentlyFeature.name,
            name: "Variation2",
            variation: "Variation2",
            description: "second-group",
        },
    ],
    name: "example",
    project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    scheduled_splits_config={
        "steps": [{
            "group_weights": {
                "Variation1": 0,
                "Variation2": 0,
            },
            "start_time": "2024-01-07 01:43:59+00:00",
        }],
    },
    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",
        },
    ],
    name="example",
    project=example_aws_evidently_project["name"])
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()
    {
        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",
                },
            },
        },
        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",
            },
        },
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
    });

});
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{
			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"),
					},
				},
			},
			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"),
				},
			},
			Name:    pulumi.String("example"),
			Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_evidently_launch" "example" {
  scheduled_splits_config = {
    steps = [{
      "groupWeights" = {
        "Variation1" = 0
        "Variation2" = 0
      }
      "startTime" = "2024-01-07 01:43:59+00:00"
    }]
  }
  groups {
    feature     = exampleAwsEvidentlyFeature.name
    name        = "Variation1"
    variation   = "Variation1"
    description = "first-group"
  }
  groups {
    feature     = exampleAwsEvidentlyFeature.name
    name        = "Variation2"
    variation   = "Variation2"
    description = "second-group"
  }
  name    = "example"
  project = exampleAwsEvidentlyProject.name
}
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.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
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()
            .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())
            .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())
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .build());

    }
}
resources:
  example:
    type: aws:evidently:Launch
    properties:
      scheduledSplitsConfig:
        steps:
          - groupWeights:
              Variation1: 0
              Variation2: 0
            startTime: 2024-01-07 01:43:59+00:00
      groups:
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation1
          variation: Variation1
          description: first-group
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation2
          variation: Variation2
          description: second-group
      name: example
      project: ${exampleAwsEvidentlyProject.name}

With metricMonitors

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

const example = new aws.evidently.Launch("example", {
    scheduledSplitsConfig: {
        steps: [{
            groupWeights: {
                Variation1: 0,
            },
            startTime: "2024-01-07 01:43:59+00:00",
        }],
    },
    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",
            },
        },
    ],
    name: "example",
    project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    scheduled_splits_config={
        "steps": [{
            "group_weights": {
                "Variation1": 0,
            },
            "start_time": "2024-01-07 01:43:59+00:00",
        }],
    },
    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",
            },
        },
    ],
    name="example",
    project=example_aws_evidently_project["name"])
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()
    {
        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",
                },
            },
        },
        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",
                },
            },
        },
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
    });

});
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{
			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"),
					},
				},
			},
			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"),
					},
				},
			},
			Name:    pulumi.String("example"),
			Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_evidently_launch" "example" {
  scheduled_splits_config = {
    steps = [{
      "groupWeights" = {
        "Variation1" = 0
      }
      "startTime" = "2024-01-07 01:43:59+00:00"
    }]
  }
  groups {
    feature   = exampleAwsEvidentlyFeature.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_monitors {
    metric_definition = {
      entity_id_key = "entity_id_key2"
      event_pattern = "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}"
      name          = "name2"
      unit_label    = "unit_label2"
      value_key     = "value_key2"
    }
  }
  name    = "example"
  project = exampleAwsEvidentlyProject.name
}
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.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchMetricMonitorArgs;
import com.pulumi.aws.evidently.inputs.LaunchMetricMonitorMetricDefinitionArgs;
import java.util.ArrayList;
import java.util.Arrays;
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()
            .scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
                .steps(LaunchScheduledSplitsConfigStepArgs.builder()
                    .groupWeights(Map.of("Variation1", 0))
                    .startTime("2024-01-07 01:43:59+00:00")
                    .build())
                .build())
            .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())
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .build());

    }
}
resources:
  example:
    type: aws:evidently:Launch
    properties:
      scheduledSplitsConfig:
        steps:
          - groupWeights:
              Variation1: 0
            startTime: 2024-01-07 01:43:59+00:00
      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
      name: example
      project: ${exampleAwsEvidentlyProject.name}

With randomizationSalt

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

const example = new aws.evidently.Launch("example", {
    scheduledSplitsConfig: {
        steps: [{
            groupWeights: {
                Variation1: 0,
            },
            startTime: "2024-01-07 01:43:59+00:00",
        }],
    },
    groups: [{
        feature: exampleAwsEvidentlyFeature.name,
        name: "Variation1",
        variation: "Variation1",
    }],
    name: "example",
    project: exampleAwsEvidentlyProject.name,
    randomizationSalt: "example randomization salt",
});
import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    scheduled_splits_config={
        "steps": [{
            "group_weights": {
                "Variation1": 0,
            },
            "start_time": "2024-01-07 01:43:59+00:00",
        }],
    },
    groups=[{
        "feature": example_aws_evidently_feature["name"],
        "name": "Variation1",
        "variation": "Variation1",
    }],
    name="example",
    project=example_aws_evidently_project["name"],
    randomization_salt="example randomization salt")
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()
    {
        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",
                },
            },
        },
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = exampleAwsEvidentlyFeature.Name,
                Name = "Variation1",
                Variation = "Variation1",
            },
        },
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
        RandomizationSalt = "example randomization salt",
    });

});
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{
			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"),
					},
				},
			},
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(exampleAwsEvidentlyFeature.Name),
					Name:      pulumi.String("Variation1"),
					Variation: pulumi.String("Variation1"),
				},
			},
			Name:              pulumi.String("example"),
			Project:           pulumi.Any(exampleAwsEvidentlyProject.Name),
			RandomizationSalt: pulumi.String("example randomization salt"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_evidently_launch" "example" {
  scheduled_splits_config = {
    steps = [{
      "groupWeights" = {
        "Variation1" = 0
      }
      "startTime" = "2024-01-07 01:43:59+00:00"
    }]
  }
  groups {
    feature   = exampleAwsEvidentlyFeature.name
    name      = "Variation1"
    variation = "Variation1"
  }
  name               = "example"
  project            = exampleAwsEvidentlyProject.name
  randomization_salt = "example randomization salt"
}
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.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
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()
            .scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
                .steps(LaunchScheduledSplitsConfigStepArgs.builder()
                    .groupWeights(Map.of("Variation1", 0))
                    .startTime("2024-01-07 01:43:59+00:00")
                    .build())
                .build())
            .groups(LaunchGroupArgs.builder()
                .feature(exampleAwsEvidentlyFeature.name())
                .name("Variation1")
                .variation("Variation1")
                .build())
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .randomizationSalt("example randomization salt")
            .build());

    }
}
resources:
  example:
    type: aws:evidently:Launch
    properties:
      scheduledSplitsConfig:
        steps:
          - groupWeights:
              Variation1: 0
            startTime: 2024-01-07 01:43:59+00:00
      groups:
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation1
          variation: Variation1
      name: example
      project: ${exampleAwsEvidentlyProject.name}
      randomizationSalt: example randomization salt

With multiple steps

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

const example = new aws.evidently.Launch("example", {
    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",
            },
        ],
    },
    groups: [
        {
            feature: exampleAwsEvidentlyFeature.name,
            name: "Variation1",
            variation: "Variation1",
        },
        {
            feature: exampleAwsEvidentlyFeature.name,
            name: "Variation2",
            variation: "Variation2",
        },
    ],
    name: "example",
    project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    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",
            },
        ],
    },
    groups=[
        {
            "feature": example_aws_evidently_feature["name"],
            "name": "Variation1",
            "variation": "Variation1",
        },
        {
            "feature": example_aws_evidently_feature["name"],
            "name": "Variation2",
            "variation": "Variation2",
        },
    ],
    name="example",
    project=example_aws_evidently_project["name"])
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()
    {
        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",
                },
            },
        },
        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",
            },
        },
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
    });

});
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{
			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"),
					},
				},
			},
			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"),
				},
			},
			Name:    pulumi.String("example"),
			Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_evidently_launch" "example" {
  scheduled_splits_config = {
    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"
    }]
  }
  groups {
    feature   = exampleAwsEvidentlyFeature.name
    name      = "Variation1"
    variation = "Variation1"
  }
  groups {
    feature   = exampleAwsEvidentlyFeature.name
    name      = "Variation2"
    variation = "Variation2"
  }
  name    = "example"
  project = exampleAwsEvidentlyProject.name
}
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.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
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()
            .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())
            .groups(
                LaunchGroupArgs.builder()
                    .feature(exampleAwsEvidentlyFeature.name())
                    .name("Variation1")
                    .variation("Variation1")
                    .build(),
                LaunchGroupArgs.builder()
                    .feature(exampleAwsEvidentlyFeature.name())
                    .name("Variation2")
                    .variation("Variation2")
                    .build())
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .build());

    }
}
resources:
  example:
    type: aws:evidently:Launch
    properties:
      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
      groups:
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation1
          variation: Variation1
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation2
          variation: Variation2
      name: example
      project: ${exampleAwsEvidentlyProject.name}

With segment overrides

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

const example = new aws.evidently.Launch("example", {
    scheduledSplitsConfig: {
        steps: [{
            segmentOverrides: [
                {
                    evaluationOrder: 1,
                    segment: exampleAwsEvidentlySegment.name,
                    weights: {
                        Variation2: 10000,
                    },
                },
                {
                    evaluationOrder: 2,
                    segment: exampleAwsEvidentlySegment.name,
                    weights: {
                        Variation1: 40000,
                        Variation2: 30000,
                    },
                },
            ],
            groupWeights: {
                Variation1: 0,
                Variation2: 0,
            },
            startTime: "2024-01-08 01:43:59+00:00",
        }],
    },
    groups: [
        {
            feature: exampleAwsEvidentlyFeature.name,
            name: "Variation1",
            variation: "Variation1",
        },
        {
            feature: exampleAwsEvidentlyFeature.name,
            name: "Variation2",
            variation: "Variation2",
        },
    ],
    name: "example",
    project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    scheduled_splits_config={
        "steps": [{
            "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,
                    },
                },
            ],
            "group_weights": {
                "Variation1": 0,
                "Variation2": 0,
            },
            "start_time": "2024-01-08 01:43:59+00:00",
        }],
    },
    groups=[
        {
            "feature": example_aws_evidently_feature["name"],
            "name": "Variation1",
            "variation": "Variation1",
        },
        {
            "feature": example_aws_evidently_feature["name"],
            "name": "Variation2",
            "variation": "Variation2",
        },
    ],
    name="example",
    project=example_aws_evidently_project["name"])
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()
    {
        ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
        {
            Steps = new[]
            {
                new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
                {
                    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 },
                            },
                        },
                    },
                    GroupWeights =
                    {
                        { "Variation1", 0 },
                        { "Variation2", 0 },
                    },
                    StartTime = "2024-01-08 01:43:59+00:00",
                },
            },
        },
        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",
            },
        },
        Name = "example",
        Project = exampleAwsEvidentlyProject.Name,
    });

});
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{
			ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
				Steps: evidently.LaunchScheduledSplitsConfigStepArray{
					&evidently.LaunchScheduledSplitsConfigStepArgs{
						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),
								},
							},
						},
						GroupWeights: pulumi.IntMap{
							"Variation1": pulumi.Int(0),
							"Variation2": pulumi.Int(0),
						},
						StartTime: pulumi.String("2024-01-08 01:43:59+00:00"),
					},
				},
			},
			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"),
				},
			},
			Name:    pulumi.String("example"),
			Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_evidently_launch" "example" {
  scheduled_splits_config = {
    steps = [{
      "segmentOverrides" = [{
        "evaluationOrder" = 1
        "segment"         = exampleAwsEvidentlySegment.name
        "weights" = {
          "Variation2" = 10000
        }
        }, {
        "evaluationOrder" = 2
        "segment"         = exampleAwsEvidentlySegment.name
        "weights" = {
          "Variation1" = 40000
          "Variation2" = 30000
        }
      }]
      "groupWeights" = {
        "Variation1" = 0
        "Variation2" = 0
      }
      "startTime" = "2024-01-08 01:43:59+00:00"
    }]
  }
  groups {
    feature   = exampleAwsEvidentlyFeature.name
    name      = "Variation1"
    variation = "Variation1"
  }
  groups {
    feature   = exampleAwsEvidentlyFeature.name
    name      = "Variation2"
    variation = "Variation2"
  }
  name    = "example"
  project = exampleAwsEvidentlyProject.name
}
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.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
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()
            .scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
                .steps(LaunchScheduledSplitsConfigStepArgs.builder()
                    .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())
                    .groupWeights(Map.ofEntries(
                        Map.entry("Variation1", 0),
                        Map.entry("Variation2", 0)
                    ))
                    .startTime("2024-01-08 01:43:59+00:00")
                    .build())
                .build())
            .groups(
                LaunchGroupArgs.builder()
                    .feature(exampleAwsEvidentlyFeature.name())
                    .name("Variation1")
                    .variation("Variation1")
                    .build(),
                LaunchGroupArgs.builder()
                    .feature(exampleAwsEvidentlyFeature.name())
                    .name("Variation2")
                    .variation("Variation2")
                    .build())
            .name("example")
            .project(exampleAwsEvidentlyProject.name())
            .build());

    }
}
resources:
  example:
    type: aws:evidently:Launch
    properties:
      scheduledSplitsConfig:
        steps:
          - segmentOverrides:
              - evaluationOrder: 1
                segment: ${exampleAwsEvidentlySegment.name}
                weights:
                  Variation2: 10000
              - evaluationOrder: 2
                segment: ${exampleAwsEvidentlySegment.name}
                weights:
                  Variation1: 40000
                  Variation2: 30000
            groupWeights:
              Variation1: 0
              Variation2: 0
            startTime: 2024-01-08 01:43:59+00:00
      groups:
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation1
          variation: Variation1
        - feature: ${exampleAwsEvidentlyFeature.name}
          name: Variation2
          variation: Variation2
      name: example
      project: ${exampleAwsEvidentlyProject.name}

Import

Import using the name of the launch and arn of the project separated by a ::

Using pulumi import to import CloudWatch Evidently Launch using the name of the launch and name of the project or arn of the hosting CloudWatch Evidently Project separated by a :. For example:

Import using the name of the launch and name of the project separated by a ::

$ pulumi import aws:evidently/launch:Launch example exampleLaunchName:exampleProjectName

Import using the name of the launch and arn of the project separated by a ::

$ pulumi import aws:evidently/launch:Launch example exampleLaunchName:arn:aws:evidently:us-east-1:123456789012:project/exampleProjectName

Constructors

Launch(String name, {LaunchArgs? args, CustomResourceOptions? options})
Creates a new Launch. name The Pulumi resource name. args Arguments used to configure this Launch. The set of arguments for Launch. options Resource options controlling this resource's behavior.
Launch.reference(String urn)
Creates a typed reference to an existing Launch resource.

Properties

arn ↔ Output<String>
The ARN of the launch.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
createdTime ↔ Output<String>
The date and time that the launch is created.
latefinal
description ↔ Output<String?>
Specifies the description of the launch.
latefinal
executions ↔ Output<List<LaunchExecution>>
A block that contains information about the start and end times of the launch. Detailed below
latefinal
groups ↔ Output<List<LaunchGroup>>
One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
lastUpdatedTime ↔ Output<String>
The date and time that the launch was most recently updated.
latefinal
metricMonitors ↔ Output<List<LaunchMetricMonitor>?>
One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.
latefinal
name ↔ Output<String>
The name for the new launch. Minimum length of 1. Maximum length of 127.
latefinal
project ↔ Output<String>
The name or ARN of the project that is to contain the new launch.
latefinal
randomizationSalt ↔ Output<String?>
When Evidently assigns a particular user session to a launch, it must use a randomization ID to determine which variation the user session is served. This randomization ID is a combination of the entity ID and randomizationSalt. If you omit randomizationSalt, Evidently uses the launch name as the randomizationSalt.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
scheduledSplitsConfig ↔ Output<LaunchScheduledSplitsConfig?>
A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.
latefinal
status ↔ Output<String>
The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.
latefinal
statusReason ↔ Output<String>
If the launch was stopped, this is the string that was entered by the person who stopped the launch, to explain why it was stopped.
latefinal
tags ↔ Output<Map<String, String>?>
Tags to apply to the launch. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
type ↔ Output<String>
The type of launch.
latefinal
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {LaunchState? state, CustomResourceOptions? options}) → Launch
Gets an existing Launch resource's state with the given name and id.