Docs Packages
  1. Pulumi Registry
  2. AWS Classic
  3. API Docs
  4. evidently
  5. Launch
aws logo
AWS Classic v5.41.0, May 15 23

aws.evidently.Launch

Explore with Pulumi AI

Provides a CloudWatch Evidently Launch resource.

Example Usage

Basic

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()
    {
        Project = aws_evidently_project.Example.Name,
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.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 main

import (
	"github.com/pulumi/pulumi-aws/sdk/v5/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{
			Project: pulumi.Any(aws_evidently_project.Example.Name),
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(aws_evidently_feature.Example.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
	})
}

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()        
            .project(aws_evidently_project.example().name())
            .groups(LaunchGroupArgs.builder()
                .feature(aws_evidently_feature.example().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());

    }
}

import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    project=aws_evidently_project["example"]["name"],
    groups=[aws.evidently.LaunchGroupArgs(
        feature=aws_evidently_feature["example"]["name"],
        name="Variation1",
        variation="Variation1",
    )],
    scheduled_splits_config=aws.evidently.LaunchScheduledSplitsConfigArgs(
        steps=[aws.evidently.LaunchScheduledSplitsConfigStepArgs(
            group_weights={
                "Variation1": 0,
            },
            start_time="2024-01-07 01:43:59+00:00",
        )],
    ))

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

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

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

With 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()
    {
        Project = aws_evidently_project.Example.Name,
        Description = "example description",
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.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 main

import (
	"github.com/pulumi/pulumi-aws/sdk/v5/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{
			Project:     pulumi.Any(aws_evidently_project.Example.Name),
			Description: pulumi.String("example description"),
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(aws_evidently_feature.Example.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
	})
}

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()        
            .project(aws_evidently_project.example().name())
            .description("example description")
            .groups(LaunchGroupArgs.builder()
                .feature(aws_evidently_feature.example().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());

    }
}

import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    project=aws_evidently_project["example"]["name"],
    description="example description",
    groups=[aws.evidently.LaunchGroupArgs(
        feature=aws_evidently_feature["example"]["name"],
        name="Variation1",
        variation="Variation1",
    )],
    scheduled_splits_config=aws.evidently.LaunchScheduledSplitsConfigArgs(
        steps=[aws.evidently.LaunchScheduledSplitsConfigStepArgs(
            group_weights={
                "Variation1": 0,
            },
            start_time="2024-01-07 01:43:59+00:00",
        )],
    ))

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

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

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

With multiple groups

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()
    {
        Project = aws_evidently_project.Example.Name,
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.Name,
                Name = "Variation1",
                Variation = "Variation1",
                Description = "first-group",
            },
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.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 main

import (
	"github.com/pulumi/pulumi-aws/sdk/v5/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{
			Project: pulumi.Any(aws_evidently_project.Example.Name),
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:     pulumi.Any(aws_evidently_feature.Example.Name),
					Name:        pulumi.String("Variation1"),
					Variation:   pulumi.String("Variation1"),
					Description: pulumi.String("first-group"),
				},
				&evidently.LaunchGroupArgs{
					Feature:     pulumi.Any(aws_evidently_feature.Example.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
	})
}

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()        
            .project(aws_evidently_project.example().name())
            .groups(            
                LaunchGroupArgs.builder()
                    .feature(aws_evidently_feature.example().name())
                    .name("Variation1")
                    .variation("Variation1")
                    .description("first-group")
                    .build(),
                LaunchGroupArgs.builder()
                    .feature(aws_evidently_feature.example().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());

    }
}

import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    project=aws_evidently_project["example"]["name"],
    groups=[
        aws.evidently.LaunchGroupArgs(
            feature=aws_evidently_feature["example"]["name"],
            name="Variation1",
            variation="Variation1",
            description="first-group",
        ),
        aws.evidently.LaunchGroupArgs(
            feature=aws_evidently_feature["example"]["name"],
            name="Variation2",
            variation="Variation2",
            description="second-group",
        ),
    ],
    scheduled_splits_config=aws.evidently.LaunchScheduledSplitsConfigArgs(
        steps=[aws.evidently.LaunchScheduledSplitsConfigStepArgs(
            group_weights={
                "Variation1": 0,
                "Variation2": 0,
            },
            start_time="2024-01-07 01:43:59+00:00",
        )],
    ))

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

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

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

With metric_monitors

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()
    {
        Project = aws_evidently_project.Example.Name,
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.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 main

import (
	"github.com/pulumi/pulumi-aws/sdk/v5/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{
			Project: pulumi.Any(aws_evidently_project.Example.Name),
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(aws_evidently_feature.Example.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
	})
}

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()        
            .project(aws_evidently_project.example().name())
            .groups(LaunchGroupArgs.builder()
                .feature(aws_evidently_feature.example().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());

    }
}

import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    project=aws_evidently_project["example"]["name"],
    groups=[aws.evidently.LaunchGroupArgs(
        feature=aws_evidently_feature["example"]["name"],
        name="Variation1",
        variation="Variation1",
    )],
    metric_monitors=[
        aws.evidently.LaunchMetricMonitorArgs(
            metric_definition=aws.evidently.LaunchMetricMonitorMetricDefinitionArgs(
                entity_id_key="entity_id_key1",
                event_pattern="{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
                name="name1",
                unit_label="unit_label1",
                value_key="value_key1",
            ),
        ),
        aws.evidently.LaunchMetricMonitorArgs(
            metric_definition=aws.evidently.LaunchMetricMonitorMetricDefinitionArgs(
                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=aws.evidently.LaunchScheduledSplitsConfigArgs(
        steps=[aws.evidently.LaunchScheduledSplitsConfigStepArgs(
            group_weights={
                "Variation1": 0,
            },
            start_time="2024-01-07 01:43:59+00:00",
        )],
    ))

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

const example = new aws.evidently.Launch("example", {
    project: aws_evidently_project.example.name,
    groups: [{
        feature: aws_evidently_feature.example.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",
        }],
    },
});

resources:
  example:
    type: aws:evidently:Launch
    properties:
      project: ${aws_evidently_project.example.name}
      groups:
        - feature: ${aws_evidently_feature.example.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

With 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()
    {
        Project = aws_evidently_project.Example.Name,
        RandomizationSalt = "example randomization salt",
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.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 main

import (
	"github.com/pulumi/pulumi-aws/sdk/v5/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{
			Project:           pulumi.Any(aws_evidently_project.Example.Name),
			RandomizationSalt: pulumi.String("example randomization salt"),
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(aws_evidently_feature.Example.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
	})
}

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()        
            .project(aws_evidently_project.example().name())
            .randomizationSalt("example randomization salt")
            .groups(LaunchGroupArgs.builder()
                .feature(aws_evidently_feature.example().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());

    }
}

import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    project=aws_evidently_project["example"]["name"],
    randomization_salt="example randomization salt",
    groups=[aws.evidently.LaunchGroupArgs(
        feature=aws_evidently_feature["example"]["name"],
        name="Variation1",
        variation="Variation1",
    )],
    scheduled_splits_config=aws.evidently.LaunchScheduledSplitsConfigArgs(
        steps=[aws.evidently.LaunchScheduledSplitsConfigStepArgs(
            group_weights={
                "Variation1": 0,
            },
            start_time="2024-01-07 01:43:59+00:00",
        )],
    ))

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

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

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

With multiple steps

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()
    {
        Project = aws_evidently_project.Example.Name,
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.Name,
                Name = "Variation1",
                Variation = "Variation1",
            },
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.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 main

import (
	"github.com/pulumi/pulumi-aws/sdk/v5/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{
			Project: pulumi.Any(aws_evidently_project.Example.Name),
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(aws_evidently_feature.Example.Name),
					Name:      pulumi.String("Variation1"),
					Variation: pulumi.String("Variation1"),
				},
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(aws_evidently_feature.Example.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
	})
}

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()        
            .project(aws_evidently_project.example().name())
            .groups(            
                LaunchGroupArgs.builder()
                    .feature(aws_evidently_feature.example().name())
                    .name("Variation1")
                    .variation("Variation1")
                    .build(),
                LaunchGroupArgs.builder()
                    .feature(aws_evidently_feature.example().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());

    }
}

import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    project=aws_evidently_project["example"]["name"],
    groups=[
        aws.evidently.LaunchGroupArgs(
            feature=aws_evidently_feature["example"]["name"],
            name="Variation1",
            variation="Variation1",
        ),
        aws.evidently.LaunchGroupArgs(
            feature=aws_evidently_feature["example"]["name"],
            name="Variation2",
            variation="Variation2",
        ),
    ],
    scheduled_splits_config=aws.evidently.LaunchScheduledSplitsConfigArgs(
        steps=[
            aws.evidently.LaunchScheduledSplitsConfigStepArgs(
                group_weights={
                    "Variation1": 15,
                    "Variation2": 10,
                },
                start_time="2024-01-07 01:43:59+00:00",
            ),
            aws.evidently.LaunchScheduledSplitsConfigStepArgs(
                group_weights={
                    "Variation1": 20,
                    "Variation2": 25,
                },
                start_time="2024-01-08 01:43:59+00:00",
            ),
        ],
    ))

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

const example = new aws.evidently.Launch("example", {
    project: aws_evidently_project.example.name,
    groups: [
        {
            feature: aws_evidently_feature.example.name,
            name: "Variation1",
            variation: "Variation1",
        },
        {
            feature: aws_evidently_feature.example.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",
            },
        ],
    },
});

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

With segment overrides

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()
    {
        Project = aws_evidently_project.Example.Name,
        Groups = new[]
        {
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.Name,
                Name = "Variation1",
                Variation = "Variation1",
            },
            new Aws.Evidently.Inputs.LaunchGroupArgs
            {
                Feature = aws_evidently_feature.Example.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 = aws_evidently_segment.Example.Name,
                            Weights = 
                            {
                                { "Variation2", 10000 },
                            },
                        },
                        new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs
                        {
                            EvaluationOrder = 2,
                            Segment = aws_evidently_segment.Example.Name,
                            Weights = 
                            {
                                { "Variation1", 40000 },
                                { "Variation2", 30000 },
                            },
                        },
                    },
                    StartTime = "2024-01-08 01:43:59+00:00",
                },
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v5/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{
			Project: pulumi.Any(aws_evidently_project.Example.Name),
			Groups: evidently.LaunchGroupArray{
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(aws_evidently_feature.Example.Name),
					Name:      pulumi.String("Variation1"),
					Variation: pulumi.String("Variation1"),
				},
				&evidently.LaunchGroupArgs{
					Feature:   pulumi.Any(aws_evidently_feature.Example.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(aws_evidently_segment.Example.Name),
								Weights: pulumi.IntMap{
									"Variation2": pulumi.Int(10000),
								},
							},
							&evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs{
								EvaluationOrder: pulumi.Int(2),
								Segment:         pulumi.Any(aws_evidently_segment.Example.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
	})
}

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()        
            .project(aws_evidently_project.example().name())
            .groups(            
                LaunchGroupArgs.builder()
                    .feature(aws_evidently_feature.example().name())
                    .name("Variation1")
                    .variation("Variation1")
                    .build(),
                LaunchGroupArgs.builder()
                    .feature(aws_evidently_feature.example().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(aws_evidently_segment.example().name())
                            .weights(Map.of("Variation2", 10000))
                            .build(),
                        LaunchScheduledSplitsConfigStepSegmentOverrideArgs.builder()
                            .evaluationOrder(2)
                            .segment(aws_evidently_segment.example().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());

    }
}

import pulumi
import pulumi_aws as aws

example = aws.evidently.Launch("example",
    project=aws_evidently_project["example"]["name"],
    groups=[
        aws.evidently.LaunchGroupArgs(
            feature=aws_evidently_feature["example"]["name"],
            name="Variation1",
            variation="Variation1",
        ),
        aws.evidently.LaunchGroupArgs(
            feature=aws_evidently_feature["example"]["name"],
            name="Variation2",
            variation="Variation2",
        ),
    ],
    scheduled_splits_config=aws.evidently.LaunchScheduledSplitsConfigArgs(
        steps=[aws.evidently.LaunchScheduledSplitsConfigStepArgs(
            group_weights={
                "Variation1": 0,
                "Variation2": 0,
            },
            segment_overrides=[
                aws.evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs(
                    evaluation_order=1,
                    segment=aws_evidently_segment["example"]["name"],
                    weights={
                        "Variation2": 10000,
                    },
                ),
                aws.evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs(
                    evaluation_order=2,
                    segment=aws_evidently_segment["example"]["name"],
                    weights={
                        "Variation1": 40000,
                        "Variation2": 30000,
                    },
                ),
            ],
            start_time="2024-01-08 01:43:59+00:00",
        )],
    ))

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

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

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

Create Launch Resource

new Launch(name: string, args: LaunchArgs, opts?: CustomResourceOptions);
@overload
def Launch(resource_name: str,
           opts: Optional[ResourceOptions] = None,
           description: Optional[str] = None,
           groups: Optional[Sequence[LaunchGroupArgs]] = None,
           metric_monitors: Optional[Sequence[LaunchMetricMonitorArgs]] = None,
           name: Optional[str] = None,
           project: Optional[str] = None,
           randomization_salt: Optional[str] = None,
           scheduled_splits_config: Optional[LaunchScheduledSplitsConfigArgs] = None,
           tags: Optional[Mapping[str, str]] = None)
@overload
def Launch(resource_name: str,
           args: LaunchArgs,
           opts: Optional[ResourceOptions] = None)
func NewLaunch(ctx *Context, name string, args LaunchArgs, opts ...ResourceOption) (*Launch, error)
public Launch(string name, LaunchArgs args, CustomResourceOptions? opts = null)
public Launch(String name, LaunchArgs args)
public Launch(String name, LaunchArgs args, CustomResourceOptions options)

type: aws:evidently:Launch
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.
name string
The unique name of the resource.
args LaunchArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name str
The unique name of the resource.
args LaunchArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name string
The unique name of the resource.
args LaunchArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name string
The unique name of the resource.
args LaunchArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name String
The unique name of the resource.
args LaunchArgs
The arguments to resource properties.
options CustomResourceOptions
Bag of options to control resource's behavior.

Launch Resource Properties

To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

Inputs

The Launch resource accepts the following input properties:

Groups List<LaunchGroupArgs>

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

Project string

The name or ARN of the project that is to contain the new launch.

Description string

Specifies the description of the launch.

MetricMonitors List<LaunchMetricMonitorArgs>

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

Name string

The name for the new launch. Minimum length of 1. Maximum length of 127.

RandomizationSalt 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.

ScheduledSplitsConfig LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

Tags Dictionary<string, string>

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Groups []LaunchGroupArgs

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

Project string

The name or ARN of the project that is to contain the new launch.

Description string

Specifies the description of the launch.

MetricMonitors []LaunchMetricMonitorArgs

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

Name string

The name for the new launch. Minimum length of 1. Maximum length of 127.

RandomizationSalt 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.

ScheduledSplitsConfig LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

Tags map[string]string

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

groups List<LaunchGroupArgs>

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

project String

The name or ARN of the project that is to contain the new launch.

description String

Specifies the description of the launch.

metricMonitors List<LaunchMetricMonitorArgs>

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

name String

The name for the new launch. Minimum length of 1. Maximum length of 127.

randomizationSalt 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.

scheduledSplitsConfig LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

tags Map<String,String>

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

groups LaunchGroupArgs[]

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

project string

The name or ARN of the project that is to contain the new launch.

description string

Specifies the description of the launch.

metricMonitors LaunchMetricMonitorArgs[]

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

name string

The name for the new launch. Minimum length of 1. Maximum length of 127.

randomizationSalt 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.

scheduledSplitsConfig LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

tags {[key: string]: string}

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

groups Sequence[LaunchGroupArgs]

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

project str

The name or ARN of the project that is to contain the new launch.

description str

Specifies the description of the launch.

metric_monitors Sequence[LaunchMetricMonitorArgs]

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

name str

The name for the new launch. Minimum length of 1. Maximum length of 127.

randomization_salt str

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.

scheduled_splits_config LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

tags Mapping[str, str]

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

groups List<Property Map>

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

project String

The name or ARN of the project that is to contain the new launch.

description String

Specifies the description of the launch.

metricMonitors List<Property Map>

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

name String

The name for the new launch. Minimum length of 1. Maximum length of 127.

randomizationSalt 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.

scheduledSplitsConfig Property Map

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

tags Map<String>

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Outputs

All input properties are implicitly available as output properties. Additionally, the Launch resource produces the following output properties:

Arn string

The ARN of the launch.

CreatedTime string

The date and time that the launch is created.

Executions List<LaunchExecution>

A block that contains information about the start and end times of the launch. Detailed below

Id string

The provider-assigned unique ID for this managed resource.

LastUpdatedTime string

The date and time that the launch was most recently updated.

Status string

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

StatusReason 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.

TagsAll Dictionary<string, string>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Type string

The type of launch.

Arn string

The ARN of the launch.

CreatedTime string

The date and time that the launch is created.

Executions []LaunchExecution

A block that contains information about the start and end times of the launch. Detailed below

Id string

The provider-assigned unique ID for this managed resource.

LastUpdatedTime string

The date and time that the launch was most recently updated.

Status string

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

StatusReason 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.

TagsAll map[string]string

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Type string

The type of launch.

arn String

The ARN of the launch.

createdTime String

The date and time that the launch is created.

executions List<LaunchExecution>

A block that contains information about the start and end times of the launch. Detailed below

id String

The provider-assigned unique ID for this managed resource.

lastUpdatedTime String

The date and time that the launch was most recently updated.

status String

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

statusReason 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.

tagsAll Map<String,String>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

type String

The type of launch.

arn string

The ARN of the launch.

createdTime string

The date and time that the launch is created.

executions LaunchExecution[]

A block that contains information about the start and end times of the launch. Detailed below

id string

The provider-assigned unique ID for this managed resource.

lastUpdatedTime string

The date and time that the launch was most recently updated.

status string

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

statusReason 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.

tagsAll {[key: string]: string}

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

type string

The type of launch.

arn str

The ARN of the launch.

created_time str

The date and time that the launch is created.

executions Sequence[LaunchExecution]

A block that contains information about the start and end times of the launch. Detailed below

id str

The provider-assigned unique ID for this managed resource.

last_updated_time str

The date and time that the launch was most recently updated.

status str

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

status_reason str

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.

tags_all Mapping[str, str]

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

type str

The type of launch.

arn String

The ARN of the launch.

createdTime String

The date and time that the launch is created.

executions List<Property Map>

A block that contains information about the start and end times of the launch. Detailed below

id String

The provider-assigned unique ID for this managed resource.

lastUpdatedTime String

The date and time that the launch was most recently updated.

status String

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

statusReason 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.

tagsAll Map<String>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

type String

The type of launch.

Look up Existing Launch Resource

Get an existing Launch resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

public static get(name: string, id: Input<ID>, state?: LaunchState, opts?: CustomResourceOptions): Launch
@staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        arn: Optional[str] = None,
        created_time: Optional[str] = None,
        description: Optional[str] = None,
        executions: Optional[Sequence[LaunchExecutionArgs]] = None,
        groups: Optional[Sequence[LaunchGroupArgs]] = None,
        last_updated_time: Optional[str] = None,
        metric_monitors: Optional[Sequence[LaunchMetricMonitorArgs]] = None,
        name: Optional[str] = None,
        project: Optional[str] = None,
        randomization_salt: Optional[str] = None,
        scheduled_splits_config: Optional[LaunchScheduledSplitsConfigArgs] = None,
        status: Optional[str] = None,
        status_reason: Optional[str] = None,
        tags: Optional[Mapping[str, str]] = None,
        tags_all: Optional[Mapping[str, str]] = None,
        type: Optional[str] = None) -> Launch
func GetLaunch(ctx *Context, name string, id IDInput, state *LaunchState, opts ...ResourceOption) (*Launch, error)
public static Launch Get(string name, Input<string> id, LaunchState? state, CustomResourceOptions? opts = null)
public static Launch get(String name, Output<String> id, LaunchState state, CustomResourceOptions options)
Resource lookup is not supported in YAML
name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
resource_name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
name
The unique name of the resulting resource.
id
The unique provider ID of the resource to lookup.
state
Any extra arguments used during the lookup.
opts
A bag of options that control this resource's behavior.
The following state arguments are supported:
Arn string

The ARN of the launch.

CreatedTime string

The date and time that the launch is created.

Description string

Specifies the description of the launch.

Executions List<LaunchExecutionArgs>

A block that contains information about the start and end times of the launch. Detailed below

Groups List<LaunchGroupArgs>

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

LastUpdatedTime string

The date and time that the launch was most recently updated.

MetricMonitors List<LaunchMetricMonitorArgs>

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

Name string

The name for the new launch. Minimum length of 1. Maximum length of 127.

Project string

The name or ARN of the project that is to contain the new launch.

RandomizationSalt 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.

ScheduledSplitsConfig LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

Status string

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

StatusReason 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.

Tags Dictionary<string, string>

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

TagsAll Dictionary<string, string>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Type string

The type of launch.

Arn string

The ARN of the launch.

CreatedTime string

The date and time that the launch is created.

Description string

Specifies the description of the launch.

Executions []LaunchExecutionArgs

A block that contains information about the start and end times of the launch. Detailed below

Groups []LaunchGroupArgs

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

LastUpdatedTime string

The date and time that the launch was most recently updated.

MetricMonitors []LaunchMetricMonitorArgs

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

Name string

The name for the new launch. Minimum length of 1. Maximum length of 127.

Project string

The name or ARN of the project that is to contain the new launch.

RandomizationSalt 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.

ScheduledSplitsConfig LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

Status string

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

StatusReason 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.

Tags map[string]string

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

TagsAll map[string]string

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Type string

The type of launch.

arn String

The ARN of the launch.

createdTime String

The date and time that the launch is created.

description String

Specifies the description of the launch.

executions List<LaunchExecutionArgs>

A block that contains information about the start and end times of the launch. Detailed below

groups List<LaunchGroupArgs>

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

lastUpdatedTime String

The date and time that the launch was most recently updated.

metricMonitors List<LaunchMetricMonitorArgs>

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

name String

The name for the new launch. Minimum length of 1. Maximum length of 127.

project String

The name or ARN of the project that is to contain the new launch.

randomizationSalt 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.

scheduledSplitsConfig LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

status String

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

statusReason 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.

tags Map<String,String>

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

tagsAll Map<String,String>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

type String

The type of launch.

arn string

The ARN of the launch.

createdTime string

The date and time that the launch is created.

description string

Specifies the description of the launch.

executions LaunchExecutionArgs[]

A block that contains information about the start and end times of the launch. Detailed below

groups LaunchGroupArgs[]

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

lastUpdatedTime string

The date and time that the launch was most recently updated.

metricMonitors LaunchMetricMonitorArgs[]

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

name string

The name for the new launch. Minimum length of 1. Maximum length of 127.

project string

The name or ARN of the project that is to contain the new launch.

randomizationSalt 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.

scheduledSplitsConfig LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

status string

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

statusReason 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.

tags {[key: string]: string}

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

tagsAll {[key: string]: string}

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

type string

The type of launch.

arn str

The ARN of the launch.

created_time str

The date and time that the launch is created.

description str

Specifies the description of the launch.

executions Sequence[LaunchExecutionArgs]

A block that contains information about the start and end times of the launch. Detailed below

groups Sequence[LaunchGroupArgs]

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

last_updated_time str

The date and time that the launch was most recently updated.

metric_monitors Sequence[LaunchMetricMonitorArgs]

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

name str

The name for the new launch. Minimum length of 1. Maximum length of 127.

project str

The name or ARN of the project that is to contain the new launch.

randomization_salt str

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.

scheduled_splits_config LaunchScheduledSplitsConfigArgs

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

status str

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

status_reason str

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.

tags Mapping[str, str]

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

tags_all Mapping[str, str]

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

type str

The type of launch.

arn String

The ARN of the launch.

createdTime String

The date and time that the launch is created.

description String

Specifies the description of the launch.

executions List<Property Map>

A block that contains information about the start and end times of the launch. Detailed below

groups List<Property Map>

One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.

lastUpdatedTime String

The date and time that the launch was most recently updated.

metricMonitors List<Property Map>

One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.

name String

The name for the new launch. Minimum length of 1. Maximum length of 127.

project String

The name or ARN of the project that is to contain the new launch.

randomizationSalt 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.

scheduledSplitsConfig Property Map

A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.

status String

The current state of the launch. Valid values are CREATED, UPDATING, RUNNING, COMPLETED, and CANCELLED.

statusReason 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.

tags Map<String>

Tags to apply to the launch. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

tagsAll Map<String>

A map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

type String

The type of launch.

Supporting Types

LaunchExecution

EndedTime string

The date and time that the launch ended.

StartedTime string

The date and time that the launch started.

EndedTime string

The date and time that the launch ended.

StartedTime string

The date and time that the launch started.

endedTime String

The date and time that the launch ended.

startedTime String

The date and time that the launch started.

endedTime string

The date and time that the launch ended.

startedTime string

The date and time that the launch started.

ended_time str

The date and time that the launch ended.

started_time str

The date and time that the launch started.

endedTime String

The date and time that the launch ended.

startedTime String

The date and time that the launch started.

LaunchGroup

Feature string

Specifies the name of the feature that the launch is using.

Name string

Specifies the name of the lahnch group.

Variation string

Specifies the feature variation to use for this launch group.

Description string

Specifies the description of the launch group.

Feature string

Specifies the name of the feature that the launch is using.

Name string

Specifies the name of the lahnch group.

Variation string

Specifies the feature variation to use for this launch group.

Description string

Specifies the description of the launch group.

feature String

Specifies the name of the feature that the launch is using.

name String

Specifies the name of the lahnch group.

variation String

Specifies the feature variation to use for this launch group.

description String

Specifies the description of the launch group.

feature string

Specifies the name of the feature that the launch is using.

name string

Specifies the name of the lahnch group.

variation string

Specifies the feature variation to use for this launch group.

description string

Specifies the description of the launch group.

feature str

Specifies the name of the feature that the launch is using.

name str

Specifies the name of the lahnch group.

variation str

Specifies the feature variation to use for this launch group.

description str

Specifies the description of the launch group.

feature String

Specifies the name of the feature that the launch is using.

name String

Specifies the name of the lahnch group.

variation String

Specifies the feature variation to use for this launch group.

description String

Specifies the description of the launch group.

LaunchMetricMonitor

MetricDefinition LaunchMetricMonitorMetricDefinition

A block that defines the metric. Detailed below.

MetricDefinition LaunchMetricMonitorMetricDefinition

A block that defines the metric. Detailed below.

metricDefinition LaunchMetricMonitorMetricDefinition

A block that defines the metric. Detailed below.

metricDefinition LaunchMetricMonitorMetricDefinition

A block that defines the metric. Detailed below.

metric_definition LaunchMetricMonitorMetricDefinition

A block that defines the metric. Detailed below.

metricDefinition Property Map

A block that defines the metric. Detailed below.

LaunchMetricMonitorMetricDefinition

EntityIdKey string

Specifies the entity, such as a user or session, that does an action that causes a metric value to be recorded. An example is userDetails.userID.

Name string

Specifies the name for the metric.

ValueKey string

Specifies the value that is tracked to produce the metric.

EventPattern string

Specifies The EventBridge event pattern that defines how the metric is recorded.

UnitLabel string

Specifies a label for the units that the metric is measuring.

EntityIdKey string

Specifies the entity, such as a user or session, that does an action that causes a metric value to be recorded. An example is userDetails.userID.

Name string

Specifies the name for the metric.

ValueKey string

Specifies the value that is tracked to produce the metric.

EventPattern string

Specifies The EventBridge event pattern that defines how the metric is recorded.

UnitLabel string

Specifies a label for the units that the metric is measuring.

entityIdKey String

Specifies the entity, such as a user or session, that does an action that causes a metric value to be recorded. An example is userDetails.userID.

name String

Specifies the name for the metric.

valueKey String

Specifies the value that is tracked to produce the metric.

eventPattern String

Specifies The EventBridge event pattern that defines how the metric is recorded.

unitLabel String

Specifies a label for the units that the metric is measuring.

entityIdKey string

Specifies the entity, such as a user or session, that does an action that causes a metric value to be recorded. An example is userDetails.userID.

name string

Specifies the name for the metric.

valueKey string

Specifies the value that is tracked to produce the metric.

eventPattern string

Specifies The EventBridge event pattern that defines how the metric is recorded.

unitLabel string

Specifies a label for the units that the metric is measuring.

entity_id_key str

Specifies the entity, such as a user or session, that does an action that causes a metric value to be recorded. An example is userDetails.userID.

name str

Specifies the name for the metric.

value_key str

Specifies the value that is tracked to produce the metric.

event_pattern str

Specifies The EventBridge event pattern that defines how the metric is recorded.

unit_label str

Specifies a label for the units that the metric is measuring.

entityIdKey String

Specifies the entity, such as a user or session, that does an action that causes a metric value to be recorded. An example is userDetails.userID.

name String

Specifies the name for the metric.

valueKey String

Specifies the value that is tracked to produce the metric.

eventPattern String

Specifies The EventBridge event pattern that defines how the metric is recorded.

unitLabel String

Specifies a label for the units that the metric is measuring.

LaunchScheduledSplitsConfig

Steps List<LaunchScheduledSplitsConfigStep>

One or up to six blocks that define the traffic allocation percentages among the feature variations during each step of the launch. This also defines the start time of each step. Detailed below.

Steps []LaunchScheduledSplitsConfigStep

One or up to six blocks that define the traffic allocation percentages among the feature variations during each step of the launch. This also defines the start time of each step. Detailed below.

steps List<LaunchScheduledSplitsConfigStep>

One or up to six blocks that define the traffic allocation percentages among the feature variations during each step of the launch. This also defines the start time of each step. Detailed below.

steps LaunchScheduledSplitsConfigStep[]

One or up to six blocks that define the traffic allocation percentages among the feature variations during each step of the launch. This also defines the start time of each step. Detailed below.

steps Sequence[LaunchScheduledSplitsConfigStep]

One or up to six blocks that define the traffic allocation percentages among the feature variations during each step of the launch. This also defines the start time of each step. Detailed below.

steps List<Property Map>

One or up to six blocks that define the traffic allocation percentages among the feature variations during each step of the launch. This also defines the start time of each step. Detailed below.

LaunchScheduledSplitsConfigStep

GroupWeights Dictionary<string, int>

The traffic allocation percentages among the feature variations during one step of a launch. This is a set of key-value pairs. The keys are variation names. The values represent the percentage of traffic to allocate to that variation during this step. For more information, refer to the AWS documentation for ScheduledSplitConfig groupWeights.

StartTime string

Specifies the date and time that this step of the launch starts.

SegmentOverrides List<LaunchScheduledSplitsConfigStepSegmentOverride>

One or up to six blocks that specify different traffic splits for one or more audience segments. A segment is a portion of your audience that share one or more characteristics. Examples could be Chrome browser users, users in Europe, or Firefox browser users in Europe who also fit other criteria that your application collects, such as age. Detailed below.

GroupWeights map[string]int

The traffic allocation percentages among the feature variations during one step of a launch. This is a set of key-value pairs. The keys are variation names. The values represent the percentage of traffic to allocate to that variation during this step. For more information, refer to the AWS documentation for ScheduledSplitConfig groupWeights.

StartTime string

Specifies the date and time that this step of the launch starts.

SegmentOverrides []LaunchScheduledSplitsConfigStepSegmentOverride

One or up to six blocks that specify different traffic splits for one or more audience segments. A segment is a portion of your audience that share one or more characteristics. Examples could be Chrome browser users, users in Europe, or Firefox browser users in Europe who also fit other criteria that your application collects, such as age. Detailed below.

groupWeights Map<String,Integer>

The traffic allocation percentages among the feature variations during one step of a launch. This is a set of key-value pairs. The keys are variation names. The values represent the percentage of traffic to allocate to that variation during this step. For more information, refer to the AWS documentation for ScheduledSplitConfig groupWeights.

startTime String

Specifies the date and time that this step of the launch starts.

segmentOverrides List<LaunchScheduledSplitsConfigStepSegmentOverride>

One or up to six blocks that specify different traffic splits for one or more audience segments. A segment is a portion of your audience that share one or more characteristics. Examples could be Chrome browser users, users in Europe, or Firefox browser users in Europe who also fit other criteria that your application collects, such as age. Detailed below.

groupWeights {[key: string]: number}

The traffic allocation percentages among the feature variations during one step of a launch. This is a set of key-value pairs. The keys are variation names. The values represent the percentage of traffic to allocate to that variation during this step. For more information, refer to the AWS documentation for ScheduledSplitConfig groupWeights.

startTime string

Specifies the date and time that this step of the launch starts.

segmentOverrides LaunchScheduledSplitsConfigStepSegmentOverride[]

One or up to six blocks that specify different traffic splits for one or more audience segments. A segment is a portion of your audience that share one or more characteristics. Examples could be Chrome browser users, users in Europe, or Firefox browser users in Europe who also fit other criteria that your application collects, such as age. Detailed below.

group_weights Mapping[str, int]

The traffic allocation percentages among the feature variations during one step of a launch. This is a set of key-value pairs. The keys are variation names. The values represent the percentage of traffic to allocate to that variation during this step. For more information, refer to the AWS documentation for ScheduledSplitConfig groupWeights.

start_time str

Specifies the date and time that this step of the launch starts.

segment_overrides Sequence[LaunchScheduledSplitsConfigStepSegmentOverride]

One or up to six blocks that specify different traffic splits for one or more audience segments. A segment is a portion of your audience that share one or more characteristics. Examples could be Chrome browser users, users in Europe, or Firefox browser users in Europe who also fit other criteria that your application collects, such as age. Detailed below.

groupWeights Map<Number>

The traffic allocation percentages among the feature variations during one step of a launch. This is a set of key-value pairs. The keys are variation names. The values represent the percentage of traffic to allocate to that variation during this step. For more information, refer to the AWS documentation for ScheduledSplitConfig groupWeights.

startTime String

Specifies the date and time that this step of the launch starts.

segmentOverrides List<Property Map>

One or up to six blocks that specify different traffic splits for one or more audience segments. A segment is a portion of your audience that share one or more characteristics. Examples could be Chrome browser users, users in Europe, or Firefox browser users in Europe who also fit other criteria that your application collects, such as age. Detailed below.

LaunchScheduledSplitsConfigStepSegmentOverride

EvaluationOrder int

Specifies a number indicating the order to use to evaluate segment overrides, if there are more than one. Segment overrides with lower numbers are evaluated first.

Segment string

The name or ARN of the segment to use.

Weights Dictionary<string, int>

The traffic allocation percentages among the feature variations to assign to this segment. This is a set of key-value pairs. The keys are variation names. The values represent the amount of traffic to allocate to that variation for this segment. This is expressed in thousandths of a percent, so a weight of 50000 represents 50% of traffic.

EvaluationOrder int

Specifies a number indicating the order to use to evaluate segment overrides, if there are more than one. Segment overrides with lower numbers are evaluated first.

Segment string

The name or ARN of the segment to use.

Weights map[string]int

The traffic allocation percentages among the feature variations to assign to this segment. This is a set of key-value pairs. The keys are variation names. The values represent the amount of traffic to allocate to that variation for this segment. This is expressed in thousandths of a percent, so a weight of 50000 represents 50% of traffic.

evaluationOrder Integer

Specifies a number indicating the order to use to evaluate segment overrides, if there are more than one. Segment overrides with lower numbers are evaluated first.

segment String

The name or ARN of the segment to use.

weights Map<String,Integer>

The traffic allocation percentages among the feature variations to assign to this segment. This is a set of key-value pairs. The keys are variation names. The values represent the amount of traffic to allocate to that variation for this segment. This is expressed in thousandths of a percent, so a weight of 50000 represents 50% of traffic.

evaluationOrder number

Specifies a number indicating the order to use to evaluate segment overrides, if there are more than one. Segment overrides with lower numbers are evaluated first.

segment string

The name or ARN of the segment to use.

weights {[key: string]: number}

The traffic allocation percentages among the feature variations to assign to this segment. This is a set of key-value pairs. The keys are variation names. The values represent the amount of traffic to allocate to that variation for this segment. This is expressed in thousandths of a percent, so a weight of 50000 represents 50% of traffic.

evaluation_order int

Specifies a number indicating the order to use to evaluate segment overrides, if there are more than one. Segment overrides with lower numbers are evaluated first.

segment str

The name or ARN of the segment to use.

weights Mapping[str, int]

The traffic allocation percentages among the feature variations to assign to this segment. This is a set of key-value pairs. The keys are variation names. The values represent the amount of traffic to allocate to that variation for this segment. This is expressed in thousandths of a percent, so a weight of 50000 represents 50% of traffic.

evaluationOrder Number

Specifies a number indicating the order to use to evaluate segment overrides, if there are more than one. Segment overrides with lower numbers are evaluated first.

segment String

The name or ARN of the segment to use.

weights Map<Number>

The traffic allocation percentages among the feature variations to assign to this segment. This is a set of key-value pairs. The keys are variation names. The values represent the amount of traffic to allocate to that variation for this segment. This is expressed in thousandths of a percent, so a weight of 50000 represents 50% of traffic.

Import

CloudWatch Evidently Launch can be imported using the name of the launch and name or arn of the hosting CloudWatch Evidently Project separated by a :, e.g. with the name of the launch and arn of the project,

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

e.g. with the name of the launch and name of the project,

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

Package Details

Repository
AWS Classic pulumi/pulumi-aws
License
Apache-2.0
Notes

This Pulumi package is based on the aws Terraform Provider.