pulumi-aws-kotlin/com.pulumi.aws.fis.kotlin/ExperimentTemplateArgs

ExperimentTemplateArgs

data class ExperimentTemplateArgs(val actions: Output<List<ExperimentTemplateActionArgs>>? = null, val description: Output<String>? = null, val experimentOptions: Output<ExperimentTemplateExperimentOptionsArgs>? = null, val logConfiguration: Output<ExperimentTemplateLogConfigurationArgs>? = null, val roleArn: Output<String>? = null, val stopConditions: Output<List<ExperimentTemplateStopConditionArgs>>? = null, val tags: Output<Map<String, String>>? = null, val targets: Output<List<ExperimentTemplateTargetArgs>>? = null) : ConvertibleToJava<ExperimentTemplateArgs>

Provides an FIS Experiment Template, which can be used to run an experiment. An experiment template contains one or more actions to run on specified targets during an experiment. It also contains the stop conditions that prevent the experiment from going out of bounds. See Amazon Fault Injection Simulator for more information.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.fis.ExperimentTemplate("example", {
    description: "example",
    roleArn: exampleAwsIamRole.arn,
    stopConditions: [{
        source: "none",
    }],
    actions: [{
        name: "example-action",
        actionId: "aws:ec2:terminate-instances",
        target: {
            key: "Instances",
            value: "example-target",
        },
    }],
    targets: [{
        name: "example-target",
        resourceType: "aws:ec2:instance",
        selectionMode: "COUNT(1)",
        resourceTags: [{
            key: "env",
            value: "example",
        }],
    }],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.fis.ExperimentTemplate("example",
    description="example",
    role_arn=example_aws_iam_role["arn"],
    stop_conditions=[{
        "source": "none",
    }],
    actions=[{
        "name": "example-action",
        "action_id": "aws:ec2:terminate-instances",
        "target": {
            "key": "Instances",
            "value": "example-target",
        },
    }],
    targets=[{
        "name": "example-target",
        "resource_type": "aws:ec2:instance",
        "selection_mode": "COUNT(1)",
        "resource_tags": [{
            "key": "env",
            "value": "example",
        }],
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Fis.ExperimentTemplate("example", new()
    {
        Description = "example",
        RoleArn = exampleAwsIamRole.Arn,
        StopConditions = new[]
        {
            new Aws.Fis.Inputs.ExperimentTemplateStopConditionArgs
            {
                Source = "none",
            },
        },
        Actions = new[]
        {
            new Aws.Fis.Inputs.ExperimentTemplateActionArgs
            {
                Name = "example-action",
                ActionId = "aws:ec2:terminate-instances",
                Target = new Aws.Fis.Inputs.ExperimentTemplateActionTargetArgs
                {
                    Key = "Instances",
                    Value = "example-target",
                },
            },
        },
        Targets = new[]
        {
            new Aws.Fis.Inputs.ExperimentTemplateTargetArgs
            {
                Name = "example-target",
                ResourceType = "aws:ec2:instance",
                SelectionMode = "COUNT(1)",
                ResourceTags = new[]
                {
                    new Aws.Fis.Inputs.ExperimentTemplateTargetResourceTagArgs
                    {
                        Key = "env",
                        Value = "example",
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/fis"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := fis.NewExperimentTemplate(ctx, "example", &fis.ExperimentTemplateArgs{
			Description: pulumi.String("example"),
			RoleArn:     pulumi.Any(exampleAwsIamRole.Arn),
			StopConditions: fis.ExperimentTemplateStopConditionArray{
				&fis.ExperimentTemplateStopConditionArgs{
					Source: pulumi.String("none"),
				},
			},
			Actions: fis.ExperimentTemplateActionArray{
				&fis.ExperimentTemplateActionArgs{
					Name:     pulumi.String("example-action"),
					ActionId: pulumi.String("aws:ec2:terminate-instances"),
					Target: &fis.ExperimentTemplateActionTargetArgs{
						Key:   pulumi.String("Instances"),
						Value: pulumi.String("example-target"),
					},
				},
			},
			Targets: fis.ExperimentTemplateTargetArray{
				&fis.ExperimentTemplateTargetArgs{
					Name:          pulumi.String("example-target"),
					ResourceType:  pulumi.String("aws:ec2:instance"),
					SelectionMode: pulumi.String("COUNT(1)"),
					ResourceTags: fis.ExperimentTemplateTargetResourceTagArray{
						&fis.ExperimentTemplateTargetResourceTagArgs{
							Key:   pulumi.String("env"),
							Value: pulumi.String("example"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.fis.ExperimentTemplate;
import com.pulumi.aws.fis.ExperimentTemplateArgs;
import com.pulumi.aws.fis.inputs.ExperimentTemplateStopConditionArgs;
import com.pulumi.aws.fis.inputs.ExperimentTemplateActionArgs;
import com.pulumi.aws.fis.inputs.ExperimentTemplateActionTargetArgs;
import com.pulumi.aws.fis.inputs.ExperimentTemplateTargetArgs;
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 ExperimentTemplate("example", ExperimentTemplateArgs.builder()
            .description("example")
            .roleArn(exampleAwsIamRole.arn())
            .stopConditions(ExperimentTemplateStopConditionArgs.builder()
                .source("none")
                .build())
            .actions(ExperimentTemplateActionArgs.builder()
                .name("example-action")
                .actionId("aws:ec2:terminate-instances")
                .target(ExperimentTemplateActionTargetArgs.builder()
                    .key("Instances")
                    .value("example-target")
                    .build())
                .build())
            .targets(ExperimentTemplateTargetArgs.builder()
                .name("example-target")
                .resourceType("aws:ec2:instance")
                .selectionMode("COUNT(1)")
                .resourceTags(ExperimentTemplateTargetResourceTagArgs.builder()
                    .key("env")
                    .value("example")
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:fis:ExperimentTemplate
    properties:
      description: example
      roleArn: ${exampleAwsIamRole.arn}
      stopConditions:
        - source: none
      actions:
        - name: example-action
          actionId: aws:ec2:terminate-instances
          target:
            key: Instances
            value: example-target
      targets:
        - name: example-target
          resourceType: aws:ec2:instance
          selectionMode: COUNT(1)
          resourceTags:
            - key: env
              value: example
Content copied to clipboard

Import

Using pulumi import, import FIS Experiment Templates using the id. For example:

$ pulumi import aws:fis/experimentTemplate:ExperimentTemplate template EXT123AbCdEfGhIjK
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(actions: Output<List<ExperimentTemplateActionArgs>>? = null, description: Output<String>? = null, experimentOptions: Output<ExperimentTemplateExperimentOptionsArgs>? = null, logConfiguration: Output<ExperimentTemplateLogConfigurationArgs>? = null, roleArn: Output<String>? = null, stopConditions: Output<List<ExperimentTemplateStopConditionArgs>>? = null, tags: Output<Map<String, String>>? = null, targets: Output<List<ExperimentTemplateTargetArgs>>? = null)

Properties

Link copied to clipboard
val actions: Output<List<ExperimentTemplateActionArgs>>? = null

Action to be performed during an experiment. See below.

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

Description for the experiment template.

Link copied to clipboard
val experimentOptions: Output<ExperimentTemplateExperimentOptionsArgs>? = null

The experiment options for the experiment template. See experiment_options below for more details!

Link copied to clipboard
val logConfiguration: Output<ExperimentTemplateLogConfigurationArgs>? = null

The configuration for experiment logging. See below.

Link copied to clipboard
val roleArn: Output<String>? = null

ARN of an IAM role that grants the AWS FIS service permission to perform service actions on your behalf.

Link copied to clipboard
val stopConditions: Output<List<ExperimentTemplateStopConditionArgs>>? = null

When an ongoing experiment should be stopped. See below. The following arguments are optional:

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Key-value mapping of tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

Link copied to clipboard
val targets: Output<List<ExperimentTemplateTargetArgs>>? = null

Target of an action. See below.

Functions

Link copied to clipboard
open override fun toJava(): ExperimentTemplateArgs