pulumi-aws-kotlin/com.pulumi.aws.evidently.kotlin/Launch

Launch

class Launch : KotlinCustomResource

Provides a CloudWatch Evidently Launch resource.

Example Usage

Basic

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());
    }
}
Content copied to clipboard

With description

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.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());
    }
}
Content copied to clipboard

With multiple groups

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());
    }
}
Content copied to clipboard

With metric_monitors

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());
    }
}
Content copied to clipboard

With randomization_salt

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.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());
    }
}
Content copied to clipboard

With multiple steps

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());
    }
}
Content copied to clipboard

With segment overrides

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());
    }
}
Content copied to clipboard

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
Content copied to clipboard

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

$ pulumi import aws:evidently/launch:Launch example exampleLaunchName:exampleProjectName
Content copied to clipboard

Properties

Link copied to clipboard
val arn: Output<String>

The ARN of the launch.

Link copied to clipboard
val createdTime: Output<String>

The date and time that the launch is created.

Link copied to clipboard
val description: Output<String>?

Specifies the description of the launch.

Link copied to clipboard
val executions: Output<List<LaunchExecution>>

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

Link copied to clipboard
val groups: Output<List<LaunchGroup>>

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

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val lastUpdatedTime: Output<String>

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

Link copied to clipboard
val metricMonitors: Output<List<LaunchMetricMonitor>>?

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

Link copied to clipboard
val name: Output<String>

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

Link copied to clipboard
val project: Output<String>

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

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val randomizationSalt: Output<String>?

When Evidently assigns a particular user session to a launch, it must use a randomization ID to determine which variation the user session is served. This randomization ID is a combination of the entity ID and randomizationSalt. If you omit randomizationSalt, Evidently uses the launch name as the randomizationSalt.

Link copied to clipboard
val scheduledSplitsConfig: Output<LaunchScheduledSplitsConfig>?

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

Link copied to clipboard
val status: Output<String>

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

Link copied to clipboard
val statusReason: Output<String>

If the launch was stopped, this is the string that was entered by the person who stopped the launch, to explain why it was stopped.

Link copied to clipboard
val tags: Output<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.

Link copied to clipboard
val tagsAll: Output<Map<String, String>>

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

Link copied to clipboard
val type: Output<String>

The type of launch.

Link copied to clipboard
val urn: Output<String>