Launch class
Provides a CloudWatch Evidently Launch resource.
> Warning: This resource is deprecated. Use AWS AppConfig feature flags instead.
Example Usage
Basic
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
name: "example",
project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
},
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
name="example",
project=example_aws_evidently_project["name"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_evidently_launch" "example" {
scheduled_splits_config = {
steps = [{
"groupWeights" = {
"Variation1" = 0
}
"startTime" = "2024-01-07 01:43:59+00:00"
}]
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation1"
variation = "Variation1"
}
name = "example"
project = exampleAwsEvidentlyProject.name
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.name("example")
.project(exampleAwsEvidentlyProject.name())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
name: example
project: ${exampleAwsEvidentlyProject.name}
With description
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
name: "example",
project: exampleAwsEvidentlyProject.name,
description: "example description",
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
},
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
name="example",
project=example_aws_evidently_project["name"],
description="example description")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Description = "example description",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Description: pulumi.String("example description"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_evidently_launch" "example" {
scheduled_splits_config = {
steps = [{
"groupWeights" = {
"Variation1" = 0
}
"startTime" = "2024-01-07 01:43:59+00:00"
}]
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation1"
variation = "Variation1"
}
name = "example"
project = exampleAwsEvidentlyProject.name
description = "example description"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.name("example")
.project(exampleAwsEvidentlyProject.name())
.description("example description")
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
name: example
project: ${exampleAwsEvidentlyProject.name}
description: example description
With multiple groups
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
Variation2: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
description: "first-group",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
description: "second-group",
},
],
name: "example",
project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
"Variation2": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
},
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
"description": "first-group",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
"description": "second-group",
},
],
name="example",
project=example_aws_evidently_project["name"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
{ "Variation2", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
Description = "first-group",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
Description = "second-group",
},
},
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
"Variation2": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
Description: pulumi.String("first-group"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
Description: pulumi.String("second-group"),
},
},
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_evidently_launch" "example" {
scheduled_splits_config = {
steps = [{
"groupWeights" = {
"Variation1" = 0
"Variation2" = 0
}
"startTime" = "2024-01-07 01:43:59+00:00"
}]
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation1"
variation = "Variation1"
description = "first-group"
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation2"
variation = "Variation2"
description = "second-group"
}
name = "example"
project = exampleAwsEvidentlyProject.name
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 0),
Map.entry("Variation2", 0)
))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.description("first-group")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.description("second-group")
.build())
.name("example")
.project(exampleAwsEvidentlyProject.name())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
Variation2: 0
startTime: 2024-01-07 01:43:59+00:00
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
description: first-group
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
description: second-group
name: example
project: ${exampleAwsEvidentlyProject.name}
With metricMonitors
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
metricMonitors: [
{
metricDefinition: {
entityIdKey: "entity_id_key1",
eventPattern: "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
name: "name1",
unitLabel: "unit_label1",
valueKey: "value_key1",
},
},
{
metricDefinition: {
entityIdKey: "entity_id_key2",
eventPattern: "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
name: "name2",
unitLabel: "unit_label2",
valueKey: "value_key2",
},
},
],
name: "example",
project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
},
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
metric_monitors=[
{
"metric_definition": {
"entity_id_key": "entity_id_key1",
"event_pattern": "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
"name": "name1",
"unit_label": "unit_label1",
"value_key": "value_key1",
},
},
{
"metric_definition": {
"entity_id_key": "entity_id_key2",
"event_pattern": "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
"name": "name2",
"unit_label": "unit_label2",
"value_key": "value_key2",
},
},
],
name="example",
project=example_aws_evidently_project["name"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
MetricMonitors = new[]
{
new Aws.Evidently.Inputs.LaunchMetricMonitorArgs
{
MetricDefinition = new Aws.Evidently.Inputs.LaunchMetricMonitorMetricDefinitionArgs
{
EntityIdKey = "entity_id_key1",
EventPattern = "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
Name = "name1",
UnitLabel = "unit_label1",
ValueKey = "value_key1",
},
},
new Aws.Evidently.Inputs.LaunchMetricMonitorArgs
{
MetricDefinition = new Aws.Evidently.Inputs.LaunchMetricMonitorMetricDefinitionArgs
{
EntityIdKey = "entity_id_key2",
EventPattern = "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
Name = "name2",
UnitLabel = "unit_label2",
ValueKey = "value_key2",
},
},
},
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
MetricMonitors: evidently.LaunchMetricMonitorArray{
&evidently.LaunchMetricMonitorArgs{
MetricDefinition: &evidently.LaunchMetricMonitorMetricDefinitionArgs{
EntityIdKey: pulumi.String("entity_id_key1"),
EventPattern: pulumi.String("{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}"),
Name: pulumi.String("name1"),
UnitLabel: pulumi.String("unit_label1"),
ValueKey: pulumi.String("value_key1"),
},
},
&evidently.LaunchMetricMonitorArgs{
MetricDefinition: &evidently.LaunchMetricMonitorMetricDefinitionArgs{
EntityIdKey: pulumi.String("entity_id_key2"),
EventPattern: pulumi.String("{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}"),
Name: pulumi.String("name2"),
UnitLabel: pulumi.String("unit_label2"),
ValueKey: pulumi.String("value_key2"),
},
},
},
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_evidently_launch" "example" {
scheduled_splits_config = {
steps = [{
"groupWeights" = {
"Variation1" = 0
}
"startTime" = "2024-01-07 01:43:59+00:00"
}]
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation1"
variation = "Variation1"
}
metric_monitors {
metric_definition = {
entity_id_key = "entity_id_key1"
event_pattern = "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}"
name = "name1"
unit_label = "unit_label1"
value_key = "value_key1"
}
}
metric_monitors {
metric_definition = {
entity_id_key = "entity_id_key2"
event_pattern = "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}"
name = "name2"
unit_label = "unit_label2"
value_key = "value_key2"
}
}
name = "example"
project = exampleAwsEvidentlyProject.name
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchMetricMonitorArgs;
import com.pulumi.aws.evidently.inputs.LaunchMetricMonitorMetricDefinitionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.metricMonitors(
LaunchMetricMonitorArgs.builder()
.metricDefinition(LaunchMetricMonitorMetricDefinitionArgs.builder()
.entityIdKey("entity_id_key1")
.eventPattern("{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}")
.name("name1")
.unitLabel("unit_label1")
.valueKey("value_key1")
.build())
.build(),
LaunchMetricMonitorArgs.builder()
.metricDefinition(LaunchMetricMonitorMetricDefinitionArgs.builder()
.entityIdKey("entity_id_key2")
.eventPattern("{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}")
.name("name2")
.unitLabel("unit_label2")
.valueKey("value_key2")
.build())
.build())
.name("example")
.project(exampleAwsEvidentlyProject.name())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
metricMonitors:
- metricDefinition:
entityIdKey: entity_id_key1
eventPattern: '{"Price":[{"numeric":[">",11,"<=",22]}]}'
name: name1
unitLabel: unit_label1
valueKey: value_key1
- metricDefinition:
entityIdKey: entity_id_key2
eventPattern: '{"Price":[{"numeric":[">",9,"<=",19]}]}'
name: name2
unitLabel: unit_label2
valueKey: value_key2
name: example
project: ${exampleAwsEvidentlyProject.name}
With randomizationSalt
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
name: "example",
project: exampleAwsEvidentlyProject.name,
randomizationSalt: "example randomization salt",
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
},
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
name="example",
project=example_aws_evidently_project["name"],
randomization_salt="example randomization salt")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
RandomizationSalt = "example randomization salt",
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
RandomizationSalt: pulumi.String("example randomization salt"),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_evidently_launch" "example" {
scheduled_splits_config = {
steps = [{
"groupWeights" = {
"Variation1" = 0
}
"startTime" = "2024-01-07 01:43:59+00:00"
}]
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation1"
variation = "Variation1"
}
name = "example"
project = exampleAwsEvidentlyProject.name
randomization_salt = "example randomization salt"
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.name("example")
.project(exampleAwsEvidentlyProject.name())
.randomizationSalt("example randomization salt")
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
name: example
project: ${exampleAwsEvidentlyProject.name}
randomizationSalt: example randomization salt
With multiple steps
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
scheduledSplitsConfig: {
steps: [
{
groupWeights: {
Variation1: 15,
Variation2: 10,
},
startTime: "2024-01-07 01:43:59+00:00",
},
{
groupWeights: {
Variation1: 20,
Variation2: 25,
},
startTime: "2024-01-08 01:43:59+00:00",
},
],
},
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
},
],
name: "example",
project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
scheduled_splits_config={
"steps": [
{
"group_weights": {
"Variation1": 15,
"Variation2": 10,
},
"start_time": "2024-01-07 01:43:59+00:00",
},
{
"group_weights": {
"Variation1": 20,
"Variation2": 25,
},
"start_time": "2024-01-08 01:43:59+00:00",
},
],
},
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
},
],
name="example",
project=example_aws_evidently_project["name"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 15 },
{ "Variation2", 10 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 20 },
{ "Variation2", 25 },
},
StartTime = "2024-01-08 01:43:59+00:00",
},
},
},
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
},
},
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(15),
"Variation2": pulumi.Int(10),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(20),
"Variation2": pulumi.Int(25),
},
StartTime: pulumi.String("2024-01-08 01:43:59+00:00"),
},
},
},
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
},
},
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_evidently_launch" "example" {
scheduled_splits_config = {
steps = [{
"groupWeights" = {
"Variation1" = 15
"Variation2" = 10
}
"startTime" = "2024-01-07 01:43:59+00:00"
}, {
"groupWeights" = {
"Variation1" = 20
"Variation2" = 25
}
"startTime" = "2024-01-08 01:43:59+00:00"
}]
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation1"
variation = "Variation1"
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation2"
variation = "Variation2"
}
name = "example"
project = exampleAwsEvidentlyProject.name
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(
LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 15),
Map.entry("Variation2", 10)
))
.startTime("2024-01-07 01:43:59+00:00")
.build(),
LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 20),
Map.entry("Variation2", 25)
))
.startTime("2024-01-08 01:43:59+00:00")
.build())
.build())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.build())
.name("example")
.project(exampleAwsEvidentlyProject.name())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 15
Variation2: 10
startTime: 2024-01-07 01:43:59+00:00
- groupWeights:
Variation1: 20
Variation2: 25
startTime: 2024-01-08 01:43:59+00:00
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
name: example
project: ${exampleAwsEvidentlyProject.name}
With segment overrides
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
scheduledSplitsConfig: {
steps: [{
segmentOverrides: [
{
evaluationOrder: 1,
segment: exampleAwsEvidentlySegment.name,
weights: {
Variation2: 10000,
},
},
{
evaluationOrder: 2,
segment: exampleAwsEvidentlySegment.name,
weights: {
Variation1: 40000,
Variation2: 30000,
},
},
],
groupWeights: {
Variation1: 0,
Variation2: 0,
},
startTime: "2024-01-08 01:43:59+00:00",
}],
},
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
},
],
name: "example",
project: exampleAwsEvidentlyProject.name,
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
scheduled_splits_config={
"steps": [{
"segment_overrides": [
{
"evaluation_order": 1,
"segment": example_aws_evidently_segment["name"],
"weights": {
"Variation2": 10000,
},
},
{
"evaluation_order": 2,
"segment": example_aws_evidently_segment["name"],
"weights": {
"Variation1": 40000,
"Variation2": 30000,
},
},
],
"group_weights": {
"Variation1": 0,
"Variation2": 0,
},
"start_time": "2024-01-08 01:43:59+00:00",
}],
},
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
},
],
name="example",
project=example_aws_evidently_project["name"])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
SegmentOverrides = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs
{
EvaluationOrder = 1,
Segment = exampleAwsEvidentlySegment.Name,
Weights =
{
{ "Variation2", 10000 },
},
},
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs
{
EvaluationOrder = 2,
Segment = exampleAwsEvidentlySegment.Name,
Weights =
{
{ "Variation1", 40000 },
{ "Variation2", 30000 },
},
},
},
GroupWeights =
{
{ "Variation1", 0 },
{ "Variation2", 0 },
},
StartTime = "2024-01-08 01:43:59+00:00",
},
},
},
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
},
},
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
});
});
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
SegmentOverrides: evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArray{
&evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs{
EvaluationOrder: pulumi.Int(1),
Segment: pulumi.Any(exampleAwsEvidentlySegment.Name),
Weights: pulumi.IntMap{
"Variation2": pulumi.Int(10000),
},
},
&evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs{
EvaluationOrder: pulumi.Int(2),
Segment: pulumi.Any(exampleAwsEvidentlySegment.Name),
Weights: pulumi.IntMap{
"Variation1": pulumi.Int(40000),
"Variation2": pulumi.Int(30000),
},
},
},
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
"Variation2": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-08 01:43:59+00:00"),
},
},
},
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
},
},
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
})
if err != nil {
return err
}
return nil
})
}
pulumi {
required_providers {
aws = {
source = "pulumi/aws"
}
}
}
resource "aws_evidently_launch" "example" {
scheduled_splits_config = {
steps = [{
"segmentOverrides" = [{
"evaluationOrder" = 1
"segment" = exampleAwsEvidentlySegment.name
"weights" = {
"Variation2" = 10000
}
}, {
"evaluationOrder" = 2
"segment" = exampleAwsEvidentlySegment.name
"weights" = {
"Variation1" = 40000
"Variation2" = 30000
}
}]
"groupWeights" = {
"Variation1" = 0
"Variation2" = 0
}
"startTime" = "2024-01-08 01:43:59+00:00"
}]
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation1"
variation = "Variation1"
}
groups {
feature = exampleAwsEvidentlyFeature.name
name = "Variation2"
variation = "Variation2"
}
name = "example"
project = exampleAwsEvidentlyProject.name
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.segmentOverrides(
LaunchScheduledSplitsConfigStepSegmentOverrideArgs.builder()
.evaluationOrder(1)
.segment(exampleAwsEvidentlySegment.name())
.weights(Map.of("Variation2", 10000))
.build(),
LaunchScheduledSplitsConfigStepSegmentOverrideArgs.builder()
.evaluationOrder(2)
.segment(exampleAwsEvidentlySegment.name())
.weights(Map.ofEntries(
Map.entry("Variation1", 40000),
Map.entry("Variation2", 30000)
))
.build())
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 0),
Map.entry("Variation2", 0)
))
.startTime("2024-01-08 01:43:59+00:00")
.build())
.build())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.build())
.name("example")
.project(exampleAwsEvidentlyProject.name())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
scheduledSplitsConfig:
steps:
- segmentOverrides:
- evaluationOrder: 1
segment: ${exampleAwsEvidentlySegment.name}
weights:
Variation2: 10000
- evaluationOrder: 2
segment: ${exampleAwsEvidentlySegment.name}
weights:
Variation1: 40000
Variation2: 30000
groupWeights:
Variation1: 0
Variation2: 0
startTime: 2024-01-08 01:43:59+00:00
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
name: example
project: ${exampleAwsEvidentlyProject.name}
Import
Import using the name of the launch and arn of the project separated by a ::
Using pulumi import to import CloudWatch Evidently Launch using the name of the launch and name of the project or arn of the hosting CloudWatch Evidently Project separated by a :. For example:
Import using the name of the launch and name of the project separated by a ::
$ pulumi import aws:evidently/launch:Launch example exampleLaunchName:exampleProjectName
Import using the name of the launch and arn of the project separated by a ::
$ pulumi import aws:evidently/launch:Launch example exampleLaunchName:arn:aws:evidently:us-east-1:123456789012:project/exampleProjectName
Constructors
- Launch(String name, {LaunchArgs? args, CustomResourceOptions? options})
-
Creates a new Launch.
nameThe Pulumi resource name.argsArguments used to configure this Launch. The set of arguments for Launch.optionsResource options controlling this resource's behavior. - Launch.reference(String urn)
- Creates a typed reference to an existing Launch resource.
Properties
-
arn
↔ Output<
String> -
The ARN of the launch.
latefinal
-
childResources
→ Set<
Resource> -
finalinherited
-
completionSources
↔ Map<
String, IOutputCompletionSource> -
latefinalinherited
-
createdTime
↔ Output<
String> -
The date and time that the launch is created.
latefinal
-
description
↔ Output<
String?> -
Specifies the description of the launch.
latefinal
-
executions
↔ Output<
List< LaunchExecution> > -
A block that contains information about the start and end times of the launch. Detailed below
latefinal
-
groups
↔ Output<
List< LaunchGroup> > -
One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.
latefinal
- hashCode → int
-
The hash code for this object.
no setterinherited
-
id
↔ Output<
String> -
getter/setter pairinherited
- isCustom → bool
-
Returns whether this resource is provider-managed.
no setterinherited
- isProtected → bool
-
Returns whether this resource is protected from deletion.
no setterinherited
- isRemote → bool
-
Whether this resource is registered as remote.
no setterinherited
- isResourceReference → bool
-
Whether this instance represents a resource value returned over RPC.
finalinherited
-
lastUpdatedTime
↔ Output<
String> -
The date and time that the launch was most recently updated.
latefinal
-
metricMonitors
↔ Output<
List< LaunchMetricMonitor> ?> -
One or up to three blocks that define the metrics that will be used to monitor the launch performance. Detailed below.
latefinal
-
name
↔ Output<
String> -
The name for the new launch. Minimum length of
1. Maximum length of127.latefinal -
project
↔ Output<
String> -
The name or ARN of the project that is to contain the new launch.
latefinal
-
randomizationSalt
↔ Output<
String?> -
When Evidently assigns a particular user session to a launch, it must use a randomization ID to determine which variation the user session is served. This randomization ID is a combination of the entity ID and randomizationSalt. If you omit randomizationSalt, Evidently uses the launch name as the randomizationSalt.
latefinal
-
region
↔ Output<
String> -
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
-
resourceTransforms
→ List<
ResourceTransform> -
Inherited/explicit async transforms.
no setterinherited
- runtimeType → Type
-
A representation of the runtime type of the object.
no setterinherited
-
scheduledSplitsConfig
↔ Output<
LaunchScheduledSplitsConfig?> -
A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.
latefinal
-
status
↔ Output<
String> -
The current state of the launch. Valid values are
CREATED,UPDATING,RUNNING,COMPLETED, andCANCELLED.latefinal -
statusReason
↔ Output<
String> -
If the launch was stopped, this is the string that was entered by the person who stopped the launch, to explain why it was stopped.
latefinal
-
Tags to apply to the launch. If configured with a provider
defaultTagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.latefinal -
A map of tags assigned to the resource, including those inherited from the provider
defaultTagsconfiguration block.latefinal -
transformations
→ List<
ResourceTransformation> -
Inherited/explicit legacy transformations.
no setterinherited
-
type
↔ Output<
String> -
The type of launch.
latefinal
-
urn
↔ Output<
String> -
latefinalinherited
Methods
-
failId(
Object error) → void -
Completes this resource ID with an error when registration fails.
inherited
-
failOutputs(
Object error) → void -
Completes all output properties with
error.inherited -
failUrn(
Object error) → void -
Completes this resource URN with an error when registration fails.
inherited
-
getProvider(
String moduleMember) → ProviderResource? -
Returns provider for
moduleMember's package, if configured.inherited -
getResourceName(
) → String -
Returns this resource's logical name.
inherited
-
getResourceType(
) → String -
Returns this resource's Pulumi type token.
inherited
-
noSuchMethod(
Invocation invocation) → dynamic -
Invoked when a nonexistent method or property is accessed.
inherited
-
registerOutput<
T> (String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output< T> -
Registers a dynamic output property for this resource.
inherited
-
resolveId(
String? value, {required bool isKnown}) → void -
Resolves the provider-assigned ID for this resource.
inherited
-
resolveOutputs(
Struct outputs) → void -
Resolves all output properties from a monitor response payload.
inherited
-
resolveUrn(
String value) → void -
Resolves this resource's URN once assigned by the engine.
inherited
-
serializeProperties(
Map< String, dynamic> properties) → Future<Struct> -
Serializes resource properties for RPC transmission.
inherited
-
toString(
) → String -
A string representation of this object.
inherited
Operators
-
operator ==(
Object other) → bool -
The equality operator.
inherited