Docs Home
AWS v6.60.0 published on Tuesday, Nov 19, 2024 by Pulumi
aws.evidently.Launch
Explore with Pulumi AI
Provides a CloudWatch Evidently Launch resource.
Example Usage
Basic
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
With description
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
description: "example description",
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
description="example description",
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Description: pulumi.String("example description"),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Description = "example description",
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.description("example description")
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
description: example description
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
With multiple groups
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
description: "first-group",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
description: "second-group",
},
],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
Variation2: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
"description": "first-group",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
"description": "second-group",
},
],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
"Variation2": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
Description: pulumi.String("first-group"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
Description: pulumi.String("second-group"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
"Variation2": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
Description = "first-group",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
Description = "second-group",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
{ "Variation2", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.description("first-group")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.description("second-group")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 0),
Map.entry("Variation2", 0)
))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
description: first-group
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
description: second-group
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
Variation2: 0
startTime: 2024-01-07 01:43:59+00:00
With metric_monitors
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
metricMonitors: [
{
metricDefinition: {
entityIdKey: "entity_id_key1",
eventPattern: "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
name: "name1",
unitLabel: "unit_label1",
valueKey: "value_key1",
},
},
{
metricDefinition: {
entityIdKey: "entity_id_key2",
eventPattern: "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
name: "name2",
unitLabel: "unit_label2",
valueKey: "value_key2",
},
},
],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
metric_monitors=[
{
"metric_definition": {
"entity_id_key": "entity_id_key1",
"event_pattern": "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
"name": "name1",
"unit_label": "unit_label1",
"value_key": "value_key1",
},
},
{
"metric_definition": {
"entity_id_key": "entity_id_key2",
"event_pattern": "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
"name": "name2",
"unit_label": "unit_label2",
"value_key": "value_key2",
},
},
],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
MetricMonitors: evidently.LaunchMetricMonitorArray{
&evidently.LaunchMetricMonitorArgs{
MetricDefinition: &evidently.LaunchMetricMonitorMetricDefinitionArgs{
EntityIdKey: pulumi.String("entity_id_key1"),
EventPattern: pulumi.String("{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}"),
Name: pulumi.String("name1"),
UnitLabel: pulumi.String("unit_label1"),
ValueKey: pulumi.String("value_key1"),
},
},
&evidently.LaunchMetricMonitorArgs{
MetricDefinition: &evidently.LaunchMetricMonitorMetricDefinitionArgs{
EntityIdKey: pulumi.String("entity_id_key2"),
EventPattern: pulumi.String("{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}"),
Name: pulumi.String("name2"),
UnitLabel: pulumi.String("unit_label2"),
ValueKey: pulumi.String("value_key2"),
},
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
MetricMonitors = new[]
{
new Aws.Evidently.Inputs.LaunchMetricMonitorArgs
{
MetricDefinition = new Aws.Evidently.Inputs.LaunchMetricMonitorMetricDefinitionArgs
{
EntityIdKey = "entity_id_key1",
EventPattern = "{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}",
Name = "name1",
UnitLabel = "unit_label1",
ValueKey = "value_key1",
},
},
new Aws.Evidently.Inputs.LaunchMetricMonitorArgs
{
MetricDefinition = new Aws.Evidently.Inputs.LaunchMetricMonitorMetricDefinitionArgs
{
EntityIdKey = "entity_id_key2",
EventPattern = "{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}",
Name = "name2",
UnitLabel = "unit_label2",
ValueKey = "value_key2",
},
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchMetricMonitorArgs;
import com.pulumi.aws.evidently.inputs.LaunchMetricMonitorMetricDefinitionArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.metricMonitors(
LaunchMetricMonitorArgs.builder()
.metricDefinition(LaunchMetricMonitorMetricDefinitionArgs.builder()
.entityIdKey("entity_id_key1")
.eventPattern("{\"Price\":[{\"numeric\":[\">\",11,\"<=\",22]}]}")
.name("name1")
.unitLabel("unit_label1")
.valueKey("value_key1")
.build())
.build(),
LaunchMetricMonitorArgs.builder()
.metricDefinition(LaunchMetricMonitorMetricDefinitionArgs.builder()
.entityIdKey("entity_id_key2")
.eventPattern("{\"Price\":[{\"numeric\":[\">\",9,\"<=\",19]}]}")
.name("name2")
.unitLabel("unit_label2")
.valueKey("value_key2")
.build())
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
metricMonitors:
- metricDefinition:
entityIdKey: entity_id_key1
eventPattern: '{"Price":[{"numeric":[">",11,"<=",22]}]}'
name: name1
unitLabel: unit_label1
valueKey: value_key1
- metricDefinition:
entityIdKey: entity_id_key2
eventPattern: '{"Price":[{"numeric":[">",9,"<=",19]}]}'
name: name2
unitLabel: unit_label2
valueKey: value_key2
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
With randomization_salt
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
randomizationSalt: "example randomization salt",
groups: [{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
}],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
},
startTime: "2024-01-07 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
randomization_salt="example randomization salt",
groups=[{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
}],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
},
"start_time": "2024-01-07 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
RandomizationSalt: pulumi.String("example randomization salt"),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
RandomizationSalt = "example randomization salt",
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.randomizationSalt("example randomization salt")
.groups(LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("Variation1", 0))
.startTime("2024-01-07 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
randomizationSalt: example randomization salt
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
startTime: 2024-01-07 01:43:59+00:00
With multiple steps
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
},
],
scheduledSplitsConfig: {
steps: [
{
groupWeights: {
Variation1: 15,
Variation2: 10,
},
startTime: "2024-01-07 01:43:59+00:00",
},
{
groupWeights: {
Variation1: 20,
Variation2: 25,
},
startTime: "2024-01-08 01:43:59+00:00",
},
],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
},
],
scheduled_splits_config={
"steps": [
{
"group_weights": {
"Variation1": 15,
"Variation2": 10,
},
"start_time": "2024-01-07 01:43:59+00:00",
},
{
"group_weights": {
"Variation1": 20,
"Variation2": 25,
},
"start_time": "2024-01-08 01:43:59+00:00",
},
],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(15),
"Variation2": pulumi.Int(10),
},
StartTime: pulumi.String("2024-01-07 01:43:59+00:00"),
},
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(20),
"Variation2": pulumi.Int(25),
},
StartTime: pulumi.String("2024-01-08 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 15 },
{ "Variation2", 10 },
},
StartTime = "2024-01-07 01:43:59+00:00",
},
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 20 },
{ "Variation2", 25 },
},
StartTime = "2024-01-08 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(
LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 15),
Map.entry("Variation2", 10)
))
.startTime("2024-01-07 01:43:59+00:00")
.build(),
LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 20),
Map.entry("Variation2", 25)
))
.startTime("2024-01-08 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 15
Variation2: 10
startTime: 2024-01-07 01:43:59+00:00
- groupWeights:
Variation1: 20
Variation2: 25
startTime: 2024-01-08 01:43:59+00:00
With segment overrides
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.evidently.Launch("example", {
name: "example",
project: exampleAwsEvidentlyProject.name,
groups: [
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation1",
variation: "Variation1",
},
{
feature: exampleAwsEvidentlyFeature.name,
name: "Variation2",
variation: "Variation2",
},
],
scheduledSplitsConfig: {
steps: [{
groupWeights: {
Variation1: 0,
Variation2: 0,
},
segmentOverrides: [
{
evaluationOrder: 1,
segment: exampleAwsEvidentlySegment.name,
weights: {
Variation2: 10000,
},
},
{
evaluationOrder: 2,
segment: exampleAwsEvidentlySegment.name,
weights: {
Variation1: 40000,
Variation2: 30000,
},
},
],
startTime: "2024-01-08 01:43:59+00:00",
}],
},
});
import pulumi
import pulumi_aws as aws
example = aws.evidently.Launch("example",
name="example",
project=example_aws_evidently_project["name"],
groups=[
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation1",
"variation": "Variation1",
},
{
"feature": example_aws_evidently_feature["name"],
"name": "Variation2",
"variation": "Variation2",
},
],
scheduled_splits_config={
"steps": [{
"group_weights": {
"Variation1": 0,
"Variation2": 0,
},
"segment_overrides": [
{
"evaluation_order": 1,
"segment": example_aws_evidently_segment["name"],
"weights": {
"Variation2": 10000,
},
},
{
"evaluation_order": 2,
"segment": example_aws_evidently_segment["name"],
"weights": {
"Variation1": 40000,
"Variation2": 30000,
},
},
],
"start_time": "2024-01-08 01:43:59+00:00",
}],
})
package main
import (
"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/evidently"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := evidently.NewLaunch(ctx, "example", &evidently.LaunchArgs{
Name: pulumi.String("example"),
Project: pulumi.Any(exampleAwsEvidentlyProject.Name),
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation1"),
Variation: pulumi.String("Variation1"),
},
&evidently.LaunchGroupArgs{
Feature: pulumi.Any(exampleAwsEvidentlyFeature.Name),
Name: pulumi.String("Variation2"),
Variation: pulumi.String("Variation2"),
},
},
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"Variation1": pulumi.Int(0),
"Variation2": pulumi.Int(0),
},
SegmentOverrides: evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArray{
&evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs{
EvaluationOrder: pulumi.Int(1),
Segment: pulumi.Any(exampleAwsEvidentlySegment.Name),
Weights: pulumi.IntMap{
"Variation2": pulumi.Int(10000),
},
},
&evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs{
EvaluationOrder: pulumi.Int(2),
Segment: pulumi.Any(exampleAwsEvidentlySegment.Name),
Weights: pulumi.IntMap{
"Variation1": pulumi.Int(40000),
"Variation2": pulumi.Int(30000),
},
},
},
StartTime: pulumi.String("2024-01-08 01:43:59+00:00"),
},
},
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
var example = new Aws.Evidently.Launch("example", new()
{
Name = "example",
Project = exampleAwsEvidentlyProject.Name,
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation1",
Variation = "Variation1",
},
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = exampleAwsEvidentlyFeature.Name,
Name = "Variation2",
Variation = "Variation2",
},
},
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "Variation1", 0 },
{ "Variation2", 0 },
},
SegmentOverrides = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs
{
EvaluationOrder = 1,
Segment = exampleAwsEvidentlySegment.Name,
Weights =
{
{ "Variation2", 10000 },
},
},
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs
{
EvaluationOrder = 2,
Segment = exampleAwsEvidentlySegment.Name,
Weights =
{
{ "Variation1", 40000 },
{ "Variation2", 30000 },
},
},
},
StartTime = "2024-01-08 01:43:59+00:00",
},
},
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.evidently.Launch;
import com.pulumi.aws.evidently.LaunchArgs;
import com.pulumi.aws.evidently.inputs.LaunchGroupArgs;
import com.pulumi.aws.evidently.inputs.LaunchScheduledSplitsConfigArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var example = new Launch("example", LaunchArgs.builder()
.name("example")
.project(exampleAwsEvidentlyProject.name())
.groups(
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation1")
.variation("Variation1")
.build(),
LaunchGroupArgs.builder()
.feature(exampleAwsEvidentlyFeature.name())
.name("Variation2")
.variation("Variation2")
.build())
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.ofEntries(
Map.entry("Variation1", 0),
Map.entry("Variation2", 0)
))
.segmentOverrides(
LaunchScheduledSplitsConfigStepSegmentOverrideArgs.builder()
.evaluationOrder(1)
.segment(exampleAwsEvidentlySegment.name())
.weights(Map.of("Variation2", 10000))
.build(),
LaunchScheduledSplitsConfigStepSegmentOverrideArgs.builder()
.evaluationOrder(2)
.segment(exampleAwsEvidentlySegment.name())
.weights(Map.ofEntries(
Map.entry("Variation1", 40000),
Map.entry("Variation2", 30000)
))
.build())
.startTime("2024-01-08 01:43:59+00:00")
.build())
.build())
.build());
}
}
resources:
example:
type: aws:evidently:Launch
properties:
name: example
project: ${exampleAwsEvidentlyProject.name}
groups:
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation1
variation: Variation1
- feature: ${exampleAwsEvidentlyFeature.name}
name: Variation2
variation: Variation2
scheduledSplitsConfig:
steps:
- groupWeights:
Variation1: 0
Variation2: 0
segmentOverrides:
- evaluationOrder: 1
segment: ${exampleAwsEvidentlySegment.name}
weights:
Variation2: 10000
- evaluationOrder: 2
segment: ${exampleAwsEvidentlySegment.name}
weights:
Variation1: 40000
Variation2: 30000
startTime: 2024-01-08 01:43:59+00:00
Create Launch Resource
Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.
Constructor syntax
new Launch(name: string, args: LaunchArgs, opts?: CustomResourceOptions);@overload
def Launch(resource_name: str,
args: LaunchArgs,
opts: Optional[ResourceOptions] = None)
@overload
def Launch(resource_name: str,
opts: Optional[ResourceOptions] = None,
groups: Optional[Sequence[LaunchGroupArgs]] = None,
project: Optional[str] = None,
description: Optional[str] = None,
metric_monitors: Optional[Sequence[LaunchMetricMonitorArgs]] = None,
name: Optional[str] = None,
randomization_salt: Optional[str] = None,
scheduled_splits_config: Optional[LaunchScheduledSplitsConfigArgs] = None,
tags: Optional[Mapping[str, str]] = 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.
Parameters
- 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.
Constructor example
The following reference example uses placeholder values for all input properties.
var launchResource = new Aws.Evidently.Launch("launchResource", new()
{
Groups = new[]
{
new Aws.Evidently.Inputs.LaunchGroupArgs
{
Feature = "string",
Name = "string",
Variation = "string",
Description = "string",
},
},
Project = "string",
Description = "string",
MetricMonitors = new[]
{
new Aws.Evidently.Inputs.LaunchMetricMonitorArgs
{
MetricDefinition = new Aws.Evidently.Inputs.LaunchMetricMonitorMetricDefinitionArgs
{
EntityIdKey = "string",
Name = "string",
ValueKey = "string",
EventPattern = "string",
UnitLabel = "string",
},
},
},
Name = "string",
RandomizationSalt = "string",
ScheduledSplitsConfig = new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigArgs
{
Steps = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepArgs
{
GroupWeights =
{
{ "string", 0 },
},
StartTime = "string",
SegmentOverrides = new[]
{
new Aws.Evidently.Inputs.LaunchScheduledSplitsConfigStepSegmentOverrideArgs
{
EvaluationOrder = 0,
Segment = "string",
Weights =
{
{ "string", 0 },
},
},
},
},
},
},
Tags =
{
{ "string", "string" },
},
});
example, err := evidently.NewLaunch(ctx, "launchResource", &evidently.LaunchArgs{
Groups: evidently.LaunchGroupArray{
&evidently.LaunchGroupArgs{
Feature: pulumi.String("string"),
Name: pulumi.String("string"),
Variation: pulumi.String("string"),
Description: pulumi.String("string"),
},
},
Project: pulumi.String("string"),
Description: pulumi.String("string"),
MetricMonitors: evidently.LaunchMetricMonitorArray{
&evidently.LaunchMetricMonitorArgs{
MetricDefinition: &evidently.LaunchMetricMonitorMetricDefinitionArgs{
EntityIdKey: pulumi.String("string"),
Name: pulumi.String("string"),
ValueKey: pulumi.String("string"),
EventPattern: pulumi.String("string"),
UnitLabel: pulumi.String("string"),
},
},
},
Name: pulumi.String("string"),
RandomizationSalt: pulumi.String("string"),
ScheduledSplitsConfig: &evidently.LaunchScheduledSplitsConfigArgs{
Steps: evidently.LaunchScheduledSplitsConfigStepArray{
&evidently.LaunchScheduledSplitsConfigStepArgs{
GroupWeights: pulumi.IntMap{
"string": pulumi.Int(0),
},
StartTime: pulumi.String("string"),
SegmentOverrides: evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArray{
&evidently.LaunchScheduledSplitsConfigStepSegmentOverrideArgs{
EvaluationOrder: pulumi.Int(0),
Segment: pulumi.String("string"),
Weights: pulumi.IntMap{
"string": pulumi.Int(0),
},
},
},
},
},
},
Tags: pulumi.StringMap{
"string": pulumi.String("string"),
},
})
var launchResource = new Launch("launchResource", LaunchArgs.builder()
.groups(LaunchGroupArgs.builder()
.feature("string")
.name("string")
.variation("string")
.description("string")
.build())
.project("string")
.description("string")
.metricMonitors(LaunchMetricMonitorArgs.builder()
.metricDefinition(LaunchMetricMonitorMetricDefinitionArgs.builder()
.entityIdKey("string")
.name("string")
.valueKey("string")
.eventPattern("string")
.unitLabel("string")
.build())
.build())
.name("string")
.randomizationSalt("string")
.scheduledSplitsConfig(LaunchScheduledSplitsConfigArgs.builder()
.steps(LaunchScheduledSplitsConfigStepArgs.builder()
.groupWeights(Map.of("string", 0))
.startTime("string")
.segmentOverrides(LaunchScheduledSplitsConfigStepSegmentOverrideArgs.builder()
.evaluationOrder(0)
.segment("string")
.weights(Map.of("string", 0))
.build())
.build())
.build())
.tags(Map.of("string", "string"))
.build());
launch_resource = aws.evidently.Launch("launchResource",
groups=[{
"feature": "string",
"name": "string",
"variation": "string",
"description": "string",
}],
project="string",
description="string",
metric_monitors=[{
"metric_definition": {
"entity_id_key": "string",
"name": "string",
"value_key": "string",
"event_pattern": "string",
"unit_label": "string",
},
}],
name="string",
randomization_salt="string",
scheduled_splits_config={
"steps": [{
"group_weights": {
"string": 0,
},
"start_time": "string",
"segment_overrides": [{
"evaluation_order": 0,
"segment": "string",
"weights": {
"string": 0,
},
}],
}],
},
tags={
"string": "string",
})
const launchResource = new aws.evidently.Launch("launchResource", {
groups: [{
feature: "string",
name: "string",
variation: "string",
description: "string",
}],
project: "string",
description: "string",
metricMonitors: [{
metricDefinition: {
entityIdKey: "string",
name: "string",
valueKey: "string",
eventPattern: "string",
unitLabel: "string",
},
}],
name: "string",
randomizationSalt: "string",
scheduledSplitsConfig: {
steps: [{
groupWeights: {
string: 0,
},
startTime: "string",
segmentOverrides: [{
evaluationOrder: 0,
segment: "string",
weights: {
string: 0,
},
}],
}],
},
tags: {
string: "string",
},
});
type: aws:evidently:Launch
properties:
description: string
groups:
- description: string
feature: string
name: string
variation: string
metricMonitors:
- metricDefinition:
entityIdKey: string
eventPattern: string
name: string
unitLabel: string
valueKey: string
name: string
project: string
randomizationSalt: string
scheduledSplitsConfig:
steps:
- groupWeights:
string: 0
segmentOverrides:
- evaluationOrder: 0
segment: string
weights:
string: 0
startTime: string
tags:
string: string
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
In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.
The Launch resource accepts the following input properties:
- Groups
List<Launch
Group> - 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.
- Metric
Monitors List<LaunchMetric Monitor> - 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 of127. - Randomization
Salt 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.
- Scheduled
Splits LaunchConfig Scheduled Splits Config - A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.
- Dictionary<string, string>
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- Groups
[]Launch
Group Args - 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.
- Metric
Monitors []LaunchMetric Monitor Args - 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 of127. - Randomization
Salt 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.
- Scheduled
Splits LaunchConfig Scheduled Splits Config Args - A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.
- map[string]string
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- groups
List<Launch
Group> - 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.
- metric
Monitors List<LaunchMetric Monitor> - 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 of127. - randomization
Salt 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.
- scheduled
Splits LaunchConfig Scheduled Splits Config - A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.
- Map<String,String>
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- groups
Launch
Group[] - 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.
- metric
Monitors LaunchMetric Monitor[] - 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 of127. - randomization
Salt 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.
- scheduled
Splits LaunchConfig Scheduled Splits Config - A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.
- {[key: string]: string}
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level.
- groups
Sequence[Launch
Group Args] - 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[LaunchMetric Monitor Args] - 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 of127. - 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_ Launchconfig Scheduled Splits Config Args - A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.
- Mapping[str, str]
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration 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.
- metric
Monitors 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 of127. - randomization
Salt 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.
- scheduled
Splits Property MapConfig - A block that defines the traffic allocation percentages among the feature variations during each step of the launch. Detailed below.
- Map<String>
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration 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.
- Created
Time string - The date and time that the launch is created.
- Executions
List<Launch
Execution> - 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.
- Last
Updated stringTime - 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, andCANCELLED. - Status
Reason 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.
- Dictionary<string, string>
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - Type string
- The type of launch.
- Arn string
- The ARN of the launch.
- Created
Time string - The date and time that the launch is created.
- Executions
[]Launch
Execution - 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.
- Last
Updated stringTime - 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, andCANCELLED. - Status
Reason 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.
- map[string]string
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - Type string
- The type of launch.
- arn String
- The ARN of the launch.
- created
Time String - The date and time that the launch is created.
- executions
List<Launch
Execution> - 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.
- last
Updated StringTime - 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, andCANCELLED. - status
Reason 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.
- Map<String,String>
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - type String
- The type of launch.
- arn string
- The ARN of the launch.
- created
Time string - The date and time that the launch is created.
- executions
Launch
Execution[] - 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.
- last
Updated stringTime - 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, andCANCELLED. - status
Reason 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.
- {[key: string]: string}
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration 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[Launch
Execution] - 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_ strtime - 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, andCANCELLED. - 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.
- Mapping[str, str]
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - type str
- The type of launch.
- arn String
- The ARN of the launch.
- created
Time 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.
- last
Updated StringTime - 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, andCANCELLED. - status
Reason 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.
- Map<String>
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration 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) -> Launchfunc 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.
- Arn string
- The ARN of the launch.
- Created
Time string - The date and time that the launch is created.
- Description string
- Specifies the description of the launch.
- Executions
List<Launch
Execution> - A block that contains information about the start and end times of the launch. Detailed below
- Groups
List<Launch
Group> - One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.
- Last
Updated stringTime - The date and time that the launch was most recently updated.
- Metric
Monitors List<LaunchMetric Monitor> - 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 of127. - Project string
- The name or ARN of the project that is to contain the new launch.
- Randomization
Salt 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.
- Scheduled
Splits LaunchConfig Scheduled Splits Config - 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, andCANCELLED. - Status
Reason 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.
- Dictionary<string, string>
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level. - Dictionary<string, string>
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - Type string
- The type of launch.
- Arn string
- The ARN of the launch.
- Created
Time string - The date and time that the launch is created.
- Description string
- Specifies the description of the launch.
- Executions
[]Launch
Execution Args - A block that contains information about the start and end times of the launch. Detailed below
- Groups
[]Launch
Group Args - One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.
- Last
Updated stringTime - The date and time that the launch was most recently updated.
- Metric
Monitors []LaunchMetric Monitor Args - 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 of127. - Project string
- The name or ARN of the project that is to contain the new launch.
- Randomization
Salt 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.
- Scheduled
Splits LaunchConfig Scheduled Splits Config Args - 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, andCANCELLED. - Status
Reason 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.
- map[string]string
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level. - map[string]string
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - Type string
- The type of launch.
- arn String
- The ARN of the launch.
- created
Time String - The date and time that the launch is created.
- description String
- Specifies the description of the launch.
- executions
List<Launch
Execution> - A block that contains information about the start and end times of the launch. Detailed below
- groups
List<Launch
Group> - One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.
- last
Updated StringTime - The date and time that the launch was most recently updated.
- metric
Monitors List<LaunchMetric Monitor> - 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 of127. - project String
- The name or ARN of the project that is to contain the new launch.
- randomization
Salt 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.
- scheduled
Splits LaunchConfig Scheduled Splits Config - 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, andCANCELLED. - status
Reason 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.
- Map<String,String>
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level. - Map<String,String>
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - type String
- The type of launch.
- arn string
- The ARN of the launch.
- created
Time string - The date and time that the launch is created.
- description string
- Specifies the description of the launch.
- executions
Launch
Execution[] - A block that contains information about the start and end times of the launch. Detailed below
- groups
Launch
Group[] - One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.
- last
Updated stringTime - The date and time that the launch was most recently updated.
- metric
Monitors LaunchMetric Monitor[] - 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 of127. - project string
- The name or ARN of the project that is to contain the new launch.
- randomization
Salt 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.
- scheduled
Splits LaunchConfig Scheduled Splits Config - 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, andCANCELLED. - status
Reason 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.
- {[key: string]: string}
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level. - {[key: string]: string}
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration 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[Launch
Execution Args] - A block that contains information about the start and end times of the launch. Detailed below
- groups
Sequence[Launch
Group Args] - One or up to five blocks that contain the feature and variations that are to be used for the launch. Detailed below.
- last_
updated_ strtime - The date and time that the launch was most recently updated.
- metric_
monitors Sequence[LaunchMetric Monitor Args] - 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 of127. - 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_ Launchconfig Scheduled Splits Config Args - 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, andCANCELLED. - 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.
- Mapping[str, str]
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level. - Mapping[str, str]
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - type str
- The type of launch.
- arn String
- The ARN of the launch.
- created
Time 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.
- last
Updated StringTime - The date and time that the launch was most recently updated.
- metric
Monitors 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 of127. - project String
- The name or ARN of the project that is to contain the new launch.
- randomization
Salt 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.
- scheduled
Splits Property MapConfig - 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, andCANCELLED. - status
Reason 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.
- Map<String>
- Tags to apply to the launch. If configured with a provider
default_tagsconfiguration block present, tags with matching keys will overwrite those defined at the provider-level. - Map<String>
- A map of tags assigned to the resource, including those inherited from the provider
default_tagsconfiguration block. - type String
- The type of launch.
Supporting Types
LaunchExecution, LaunchExecutionArgs
- Ended
Time string - The date and time that the launch ended.
- Started
Time string - The date and time that the launch started.
- Ended
Time string - The date and time that the launch ended.
- Started
Time string - The date and time that the launch started.
- ended
Time String - The date and time that the launch ended.
- started
Time String - The date and time that the launch started.
- ended
Time string - The date and time that the launch ended.
- started
Time 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.
- ended
Time String - The date and time that the launch ended.
- started
Time String - The date and time that the launch started.
LaunchGroup, LaunchGroupArgs
- 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, LaunchMetricMonitorArgs
- Metric
Definition LaunchMetric Monitor Metric Definition - A block that defines the metric. Detailed below.
- Metric
Definition LaunchMetric Monitor Metric Definition - A block that defines the metric. Detailed below.
- metric
Definition LaunchMetric Monitor Metric Definition - A block that defines the metric. Detailed below.
- metric
Definition LaunchMetric Monitor Metric Definition - A block that defines the metric. Detailed below.
- metric_
definition LaunchMetric Monitor Metric Definition - A block that defines the metric. Detailed below.
- metric
Definition Property Map - A block that defines the metric. Detailed below.
LaunchMetricMonitorMetricDefinition, LaunchMetricMonitorMetricDefinitionArgs
- Entity
Id stringKey - 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.
- Value
Key string - Specifies the value that is tracked to produce the metric.
- Event
Pattern string - Specifies The EventBridge event pattern that defines how the metric is recorded.
- Unit
Label string - Specifies a label for the units that the metric is measuring.
- Entity
Id stringKey - 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.
- Value
Key string - Specifies the value that is tracked to produce the metric.
- Event
Pattern string - Specifies The EventBridge event pattern that defines how the metric is recorded.
- Unit
Label string - Specifies a label for the units that the metric is measuring.
- entity
Id StringKey - 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.
- value
Key String - Specifies the value that is tracked to produce the metric.
- event
Pattern String - Specifies The EventBridge event pattern that defines how the metric is recorded.
- unit
Label String - Specifies a label for the units that the metric is measuring.
- entity
Id stringKey - 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.
- value
Key string - Specifies the value that is tracked to produce the metric.
- event
Pattern string - Specifies The EventBridge event pattern that defines how the metric is recorded.
- unit
Label string - Specifies a label for the units that the metric is measuring.
- entity_
id_ strkey - 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.
- entity
Id StringKey - 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.
- value
Key String - Specifies the value that is tracked to produce the metric.
- event
Pattern String - Specifies The EventBridge event pattern that defines how the metric is recorded.
- unit
Label String - Specifies a label for the units that the metric is measuring.
LaunchScheduledSplitsConfig, LaunchScheduledSplitsConfigArgs
- Steps
List<Launch
Scheduled Splits Config Step> - 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
[]Launch
Scheduled Splits Config Step - 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<Launch
Scheduled Splits Config Step> - 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
Launch
Scheduled Splits Config Step[] - 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[Launch
Scheduled Splits Config Step] - 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, LaunchScheduledSplitsConfigStepArgs
- Group
Weights 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.
- Start
Time string - Specifies the date and time that this step of the launch starts.
- Segment
Overrides List<LaunchScheduled Splits Config Step Segment Override> - 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 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.
- Start
Time string - Specifies the date and time that this step of the launch starts.
- Segment
Overrides []LaunchScheduled Splits Config Step Segment Override - 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 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.
- start
Time String - Specifies the date and time that this step of the launch starts.
- segment
Overrides List<LaunchScheduled Splits Config Step Segment Override> - 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 {[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.
- start
Time string - Specifies the date and time that this step of the launch starts.
- segment
Overrides LaunchScheduled Splits Config Step Segment Override[] - 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[LaunchScheduled Splits Config Step Segment Override] - 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 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.
- start
Time String - Specifies the date and time that this step of the launch starts.
- segment
Overrides 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, LaunchScheduledSplitsConfigStepSegmentOverrideArgs
- 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 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.
- 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 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.
- evaluation
Order 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.
- evaluation
Order 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.
- evaluation
Order 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
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
To learn more about importing existing cloud resources, see Importing resources.
Package Details
- Repository
- AWS Classic pulumi/pulumi-aws
- License
- Apache-2.0
- Notes
- This Pulumi package is based on the
awsTerraform Provider.