Docs Packages
  1. Packages
  2. AWS Native
  3. API Docs
  4. stepfunctions
  5. StateMachine

AWS Native is in preview. AWS Classic is fully supported.

AWS Native v0.109.0 published on Wednesday, Jun 26, 2024 by Pulumi
pulumi/pulumi-aws-native

aws-native.stepfunctions.StateMachine

Explore with Pulumi AI

aws-native logo

AWS Native is in preview. AWS Classic is fully supported.

AWS Native v0.109.0 published on Wednesday, Jun 26, 2024 by Pulumi
pulumi/pulumi-aws-native

    Resource schema for StateMachine

    Example Usage

    Example

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AwsNative = Pulumi.AwsNative;

return await Deployment.RunAsync(() => 
{
    var myStateMachine = new AwsNative.StepFunctions.StateMachine("myStateMachine", new()
    {
        StateMachineName = "HelloWorld-StateMachine",
        StateMachineType = AwsNative.StepFunctions.StateMachineType.Standard,
        DefinitionString = "{\"StartAt\": \"HelloWorld\",  \"States\": {\"HelloWorld\": {\"Type\": \"Task\", \"Resource\":  \"arn:aws:lambda:us-east-1:111122223333;:function:HelloFunction\", \"End\": true}}}",
        RoleArn = "arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1;",
    });

});

    package main

import (
	"github.com/pulumi/pulumi-aws-native/sdk/go/aws/stepfunctions"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := stepfunctions.NewStateMachine(ctx, "myStateMachine", &stepfunctions.StateMachineArgs{
			StateMachineName: pulumi.String("HelloWorld-StateMachine"),
			StateMachineType: stepfunctions.StateMachineTypeStandard,
			DefinitionString: pulumi.String("{\"StartAt\": \"HelloWorld\",  \"States\": {\"HelloWorld\": {\"Type\": \"Task\", \"Resource\":  \"arn:aws:lambda:us-east-1:111122223333;:function:HelloFunction\", \"End\": true}}}"),
			RoleArn:          pulumi.String("arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1;"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    Coming soon!

    import pulumi
import pulumi_aws_native as aws_native

my_state_machine = aws_native.stepfunctions.StateMachine("myStateMachine",
    state_machine_name="HelloWorld-StateMachine",
    state_machine_type=aws_native.stepfunctions.StateMachineType.STANDARD,
    definition_string="{\"StartAt\": \"HelloWorld\",  \"States\": {\"HelloWorld\": {\"Type\": \"Task\", \"Resource\":  \"arn:aws:lambda:us-east-1:111122223333;:function:HelloFunction\", \"End\": true}}}",
    role_arn="arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1;")

    import * as pulumi from "@pulumi/pulumi";
import * as aws_native from "@pulumi/aws-native";

const myStateMachine = new aws_native.stepfunctions.StateMachine("myStateMachine", {
    stateMachineName: "HelloWorld-StateMachine",
    stateMachineType: aws_native.stepfunctions.StateMachineType.Standard,
    definitionString: "{\"StartAt\": \"HelloWorld\",  \"States\": {\"HelloWorld\": {\"Type\": \"Task\", \"Resource\":  \"arn:aws:lambda:us-east-1:111122223333;:function:HelloFunction\", \"End\": true}}}",
    roleArn: "arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1;",
});

    Coming soon!

    Example

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AwsNative = Pulumi.AwsNative;

return await Deployment.RunAsync(() => 
{
    var myStateMachine = new AwsNative.StepFunctions.StateMachine("myStateMachine", new()
    {
        StateMachineName = "HelloWorld-StateMachine",
        StateMachineType = AwsNative.StepFunctions.StateMachineType.Standard,
        DefinitionString = @"{
    ""StartAt"": ""HelloWorld"",
    ""States"" : {
        ""HelloWorld"" : {
            ""Type"" : ""Task"", 
            ""Resource"" : ""arn:aws:lambda:us-east-1:111122223333:function:HelloFunction"",
            ""End"" : true
        }
    }
}",
        RoleArn = "arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1",
        Tags = new[]
        {
            new AwsNative.Inputs.TagArgs
            {
                Key = "keyname1",
                Value = "value1",
            },
            new AwsNative.Inputs.TagArgs
            {
                Key = "keyname2",
                Value = "value2",
            },
        },
    });

});

    package main

import (
	awsnative "github.com/pulumi/pulumi-aws-native/sdk/go/aws"
	"github.com/pulumi/pulumi-aws-native/sdk/go/aws/stepfunctions"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := stepfunctions.NewStateMachine(ctx, "myStateMachine", &stepfunctions.StateMachineArgs{
			StateMachineName: pulumi.String("HelloWorld-StateMachine"),
			StateMachineType: stepfunctions.StateMachineTypeStandard,
			DefinitionString: pulumi.String(`{
    "StartAt": "HelloWorld",
    "States" : {
        "HelloWorld" : {
            "Type" : "Task", 
            "Resource" : "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction",
            "End" : true
        }
    }
}`),
			RoleArn: pulumi.String("arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1"),
			Tags: aws.TagArray{
				&aws.TagArgs{
					Key:   pulumi.String("keyname1"),
					Value: pulumi.String("value1"),
				},
				&aws.TagArgs{
					Key:   pulumi.String("keyname2"),
					Value: pulumi.String("value2"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    Coming soon!

    import pulumi
import pulumi_aws_native as aws_native

my_state_machine = aws_native.stepfunctions.StateMachine("myStateMachine",
    state_machine_name="HelloWorld-StateMachine",
    state_machine_type=aws_native.stepfunctions.StateMachineType.STANDARD,
    definition_string="""{
    "StartAt": "HelloWorld",
    "States" : {
        "HelloWorld" : {
            "Type" : "Task", 
            "Resource" : "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction",
            "End" : true
        }
    }
}""",
    role_arn="arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1",
    tags=[
        aws_native.TagArgs(
            key="keyname1",
            value="value1",
        ),
        aws_native.TagArgs(
            key="keyname2",
            value="value2",
        ),
    ])

    import * as pulumi from "@pulumi/pulumi";
import * as aws_native from "@pulumi/aws-native";

const myStateMachine = new aws_native.stepfunctions.StateMachine("myStateMachine", {
    stateMachineName: "HelloWorld-StateMachine",
    stateMachineType: aws_native.stepfunctions.StateMachineType.Standard,
    definitionString: `{
    "StartAt": "HelloWorld",
    "States" : {
        "HelloWorld" : {
            "Type" : "Task", 
            "Resource" : "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction",
            "End" : true
        }
    }
}`,
    roleArn: "arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1",
    tags: [
        {
            key: "keyname1",
            value: "value1",
        },
        {
            key: "keyname2",
            value: "value2",
        },
    ],
});

    Coming soon!

    Example

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AwsNative = Pulumi.AwsNative;

return await Deployment.RunAsync(() => 
{
    var myStateMachine = new AwsNative.StepFunctions.StateMachine("myStateMachine", new()
    {
        StateMachineName = "HelloWorld-StateMachine",
        DefinitionString = @"{
  ""StartAt"": ""HelloWorld"",
  ""States"": {
    ""HelloWorld"": {
      ""Type"": ""Task"",
      ""Resource"": ""arn:aws:lambda:us-east-1:111122223333:function:HelloFunction"",
      ""End"": true
    }
  }
}",
        RoleArn = "arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1",
        Tags = new[]
        {
            new AwsNative.Inputs.TagArgs
            {
                Key = "keyname1",
                Value = "value1",
            },
            new AwsNative.Inputs.TagArgs
            {
                Key = "keyname2",
                Value = "value2",
            },
        },
    });

});

    package main

import (
	awsnative "github.com/pulumi/pulumi-aws-native/sdk/go/aws"
	"github.com/pulumi/pulumi-aws-native/sdk/go/aws/stepfunctions"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := stepfunctions.NewStateMachine(ctx, "myStateMachine", &stepfunctions.StateMachineArgs{
			StateMachineName: pulumi.String("HelloWorld-StateMachine"),
			DefinitionString: pulumi.String(`{
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction",
      "End": true
    }
  }
}`),
			RoleArn: pulumi.String("arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1"),
			Tags: aws.TagArray{
				&aws.TagArgs{
					Key:   pulumi.String("keyname1"),
					Value: pulumi.String("value1"),
				},
				&aws.TagArgs{
					Key:   pulumi.String("keyname2"),
					Value: pulumi.String("value2"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    Coming soon!

    import pulumi
import pulumi_aws_native as aws_native

my_state_machine = aws_native.stepfunctions.StateMachine("myStateMachine",
    state_machine_name="HelloWorld-StateMachine",
    definition_string="""{
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction",
      "End": true
    }
  }
}""",
    role_arn="arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1",
    tags=[
        aws_native.TagArgs(
            key="keyname1",
            value="value1",
        ),
        aws_native.TagArgs(
            key="keyname2",
            value="value2",
        ),
    ])

    import * as pulumi from "@pulumi/pulumi";
import * as aws_native from "@pulumi/aws-native";

const myStateMachine = new aws_native.stepfunctions.StateMachine("myStateMachine", {
    stateMachineName: "HelloWorld-StateMachine",
    definitionString: `{
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction",
      "End": true
    }
  }
}`,
    roleArn: "arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1",
    tags: [
        {
            key: "keyname1",
            value: "value1",
        },
        {
            key: "keyname2",
            value: "value2",
        },
    ],
});

    Coming soon!

    Example

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AwsNative = Pulumi.AwsNative;

return await Deployment.RunAsync(() => 
{
    var myStateMachine = new AwsNative.StepFunctions.StateMachine("myStateMachine", new()
    {
        StateMachineName = "HelloWorld-StateMachine",
        DefinitionS3Location = new AwsNative.StepFunctions.Inputs.StateMachineS3LocationArgs
        {
            Bucket = "example_bucket",
            Key = "hello_world.json",
        },
        DefinitionSubstitutions = 
        {
            { "helloFunction", "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction" },
        },
        RoleArn = "arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1",
    });

});

    package main

import (
	"github.com/pulumi/pulumi-aws-native/sdk/go/aws/stepfunctions"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := stepfunctions.NewStateMachine(ctx, "myStateMachine", &stepfunctions.StateMachineArgs{
			StateMachineName: pulumi.String("HelloWorld-StateMachine"),
			DefinitionS3Location: &stepfunctions.StateMachineS3LocationArgs{
				Bucket: pulumi.String("example_bucket"),
				Key:    pulumi.String("hello_world.json"),
			},
			DefinitionSubstitutions: pulumi.Map{
				"helloFunction": pulumi.Any("arn:aws:lambda:us-east-1:111122223333:function:HelloFunction"),
			},
			RoleArn: pulumi.String("arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    Coming soon!

    import pulumi
import pulumi_aws_native as aws_native

my_state_machine = aws_native.stepfunctions.StateMachine("myStateMachine",
    state_machine_name="HelloWorld-StateMachine",
    definition_s3_location=aws_native.stepfunctions.StateMachineS3LocationArgs(
        bucket="example_bucket",
        key="hello_world.json",
    ),
    definition_substitutions={
        "helloFunction": "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction",
    },
    role_arn="arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1")

    import * as pulumi from "@pulumi/pulumi";
import * as aws_native from "@pulumi/aws-native";

const myStateMachine = new aws_native.stepfunctions.StateMachine("myStateMachine", {
    stateMachineName: "HelloWorld-StateMachine",
    definitionS3Location: {
        bucket: "example_bucket",
        key: "hello_world.json",
    },
    definitionSubstitutions: {
        helloFunction: "arn:aws:lambda:us-east-1:111122223333:function:HelloFunction",
    },
    roleArn: "arn:aws:iam::111122223333:role/service-role/StatesExecutionRole-us-east-1",
});

    Coming soon!

    Create StateMachine Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new StateMachine(name: string, args: StateMachineArgs, opts?: CustomResourceOptions);
    @overload
def StateMachine(resource_name: str,
                 args: StateMachineArgs,
                 opts: Optional[ResourceOptions] = None)

@overload
def StateMachine(resource_name: str,
                 opts: Optional[ResourceOptions] = None,
                 role_arn: Optional[str] = None,
                 definition: Optional[StateMachineDefinitionArgs] = None,
                 definition_s3_location: Optional[StateMachineS3LocationArgs] = None,
                 definition_string: Optional[str] = None,
                 definition_substitutions: Optional[Mapping[str, Union[str, int, bool]]] = None,
                 logging_configuration: Optional[StateMachineLoggingConfigurationArgs] = None,
                 state_machine_name: Optional[str] = None,
                 state_machine_type: Optional[StateMachineType] = None,
                 tags: Optional[Sequence[_root_inputs.TagArgs]] = None,
                 tracing_configuration: Optional[StateMachineTracingConfigurationArgs] = None)
    func NewStateMachine(ctx *Context, name string, args StateMachineArgs, opts ...ResourceOption) (*StateMachine, error)
    public StateMachine(string name, StateMachineArgs args, CustomResourceOptions? opts = null)
    public StateMachine(String name, StateMachineArgs args)
public StateMachine(String name, StateMachineArgs args, CustomResourceOptions options)

    type: aws-native:stepfunctions:StateMachine
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 StateMachineArgs
    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 StateMachineArgs
    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 StateMachineArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args StateMachineArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args StateMachineArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    StateMachine Resource Properties

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

    Inputs

    The StateMachine resource accepts the following input properties:

    RoleArn string
    The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
    Definition Pulumi.AwsNative.StepFunctions.Inputs.StateMachineDefinition
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON or YAML, and the format of the object must match the format of your CloudFormation template file. See Amazon States Language .
    DefinitionS3Location Pulumi.AwsNative.StepFunctions.Inputs.StateMachineS3Location
    The name of the S3 bucket where the state machine definition is stored. The state machine definition must be a JSON or YAML file.
    DefinitionString string
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON. See Amazon States Language .
    DefinitionSubstitutions Dictionary<string, object>

    A map (string to string) that specifies the mappings for placeholder variables in the state machine definition. This enables the customer to inject values obtained at runtime, for example from intrinsic functions, in the state machine definition. Variables can be template parameter names, resource logical IDs, resource attributes, or a variable in a key-value map.

    Substitutions must follow the syntax: ${key_name} or ${variable_1,variable_2,...} .

    LoggingConfiguration Pulumi.AwsNative.StepFunctions.Inputs.StateMachineLoggingConfiguration

    Defines what execution history events are logged and where they are logged.

    By default, the level is set to OFF . For more information see Log Levels in the AWS Step Functions User Guide.

    StateMachineName string

    The name of the state machine.

    A name must not contain:

    • white space
    • brackets < > { } [ ]
    • wildcard characters ? *
    • special characters " # % \ ^ | ~ $ & , ; : /`
    • control characters ( U+0000-001F , U+007F-009F )

    If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.

    StateMachineType Pulumi.AwsNative.StepFunctions.StateMachineType
    Determines whether a STANDARD or EXPRESS state machine is created. The default is STANDARD . You cannot update the type of a state machine once it has been created. For more information on STANDARD and EXPRESS workflows, see Standard Versus Express Workflows in the AWS Step Functions Developer Guide.
    Tags List<Pulumi.AwsNative.Inputs.Tag>

    The list of tags to add to a resource.

    Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @ .

    TracingConfiguration Pulumi.AwsNative.StepFunctions.Inputs.StateMachineTracingConfiguration
    Selects whether or not the state machine's AWS X-Ray tracing is enabled.
    RoleArn string
    The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
    Definition StateMachineDefinitionArgs
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON or YAML, and the format of the object must match the format of your CloudFormation template file. See Amazon States Language .
    DefinitionS3Location StateMachineS3LocationArgs
    The name of the S3 bucket where the state machine definition is stored. The state machine definition must be a JSON or YAML file.
    DefinitionString string
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON. See Amazon States Language .
    DefinitionSubstitutions map[string]interface{}

    A map (string to string) that specifies the mappings for placeholder variables in the state machine definition. This enables the customer to inject values obtained at runtime, for example from intrinsic functions, in the state machine definition. Variables can be template parameter names, resource logical IDs, resource attributes, or a variable in a key-value map.

    Substitutions must follow the syntax: ${key_name} or ${variable_1,variable_2,...} .

    LoggingConfiguration StateMachineLoggingConfigurationArgs

    Defines what execution history events are logged and where they are logged.

    By default, the level is set to OFF . For more information see Log Levels in the AWS Step Functions User Guide.

    StateMachineName string

    The name of the state machine.

    A name must not contain:

    • white space
    • brackets < > { } [ ]
    • wildcard characters ? *
    • special characters " # % \ ^ | ~ $ & , ; : /`
    • control characters ( U+0000-001F , U+007F-009F )

    If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.

    StateMachineType StateMachineType
    Determines whether a STANDARD or EXPRESS state machine is created. The default is STANDARD . You cannot update the type of a state machine once it has been created. For more information on STANDARD and EXPRESS workflows, see Standard Versus Express Workflows in the AWS Step Functions Developer Guide.
    Tags TagArgs

    The list of tags to add to a resource.

    Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @ .

    TracingConfiguration StateMachineTracingConfigurationArgs
    Selects whether or not the state machine's AWS X-Ray tracing is enabled.
    roleArn String
    The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
    definition StateMachineDefinition
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON or YAML, and the format of the object must match the format of your CloudFormation template file. See Amazon States Language .
    definitionS3Location StateMachineS3Location
    The name of the S3 bucket where the state machine definition is stored. The state machine definition must be a JSON or YAML file.
    definitionString String
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON. See Amazon States Language .
    definitionSubstitutions Map<String,Object>

    A map (string to string) that specifies the mappings for placeholder variables in the state machine definition. This enables the customer to inject values obtained at runtime, for example from intrinsic functions, in the state machine definition. Variables can be template parameter names, resource logical IDs, resource attributes, or a variable in a key-value map.

    Substitutions must follow the syntax: ${key_name} or ${variable_1,variable_2,...} .

    loggingConfiguration StateMachineLoggingConfiguration

    Defines what execution history events are logged and where they are logged.

    By default, the level is set to OFF . For more information see Log Levels in the AWS Step Functions User Guide.

    stateMachineName String

    The name of the state machine.

    A name must not contain:

    • white space
    • brackets < > { } [ ]
    • wildcard characters ? *
    • special characters " # % \ ^ | ~ $ & , ; : /`
    • control characters ( U+0000-001F , U+007F-009F )

    If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.

    stateMachineType StateMachineType
    Determines whether a STANDARD or EXPRESS state machine is created. The default is STANDARD . You cannot update the type of a state machine once it has been created. For more information on STANDARD and EXPRESS workflows, see Standard Versus Express Workflows in the AWS Step Functions Developer Guide.
    tags List<Tag>

    The list of tags to add to a resource.

    Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @ .

    tracingConfiguration StateMachineTracingConfiguration
    Selects whether or not the state machine's AWS X-Ray tracing is enabled.
    roleArn string
    The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
    definition StateMachineDefinition
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON or YAML, and the format of the object must match the format of your CloudFormation template file. See Amazon States Language .
    definitionS3Location StateMachineS3Location
    The name of the S3 bucket where the state machine definition is stored. The state machine definition must be a JSON or YAML file.
    definitionString string
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON. See Amazon States Language .
    definitionSubstitutions {[key: string]: string | number | boolean}

    A map (string to string) that specifies the mappings for placeholder variables in the state machine definition. This enables the customer to inject values obtained at runtime, for example from intrinsic functions, in the state machine definition. Variables can be template parameter names, resource logical IDs, resource attributes, or a variable in a key-value map.

    Substitutions must follow the syntax: ${key_name} or ${variable_1,variable_2,...} .

    loggingConfiguration StateMachineLoggingConfiguration

    Defines what execution history events are logged and where they are logged.

    By default, the level is set to OFF . For more information see Log Levels in the AWS Step Functions User Guide.

    stateMachineName string

    The name of the state machine.

    A name must not contain:

    • white space
    • brackets < > { } [ ]
    • wildcard characters ? *
    • special characters " # % \ ^ | ~ $ & , ; : /`
    • control characters ( U+0000-001F , U+007F-009F )

    If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.

    stateMachineType StateMachineType
    Determines whether a STANDARD or EXPRESS state machine is created. The default is STANDARD . You cannot update the type of a state machine once it has been created. For more information on STANDARD and EXPRESS workflows, see Standard Versus Express Workflows in the AWS Step Functions Developer Guide.
    tags Tag[]

    The list of tags to add to a resource.

    Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @ .

    tracingConfiguration StateMachineTracingConfiguration
    Selects whether or not the state machine's AWS X-Ray tracing is enabled.
    role_arn str
    The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
    definition StateMachineDefinitionArgs
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON or YAML, and the format of the object must match the format of your CloudFormation template file. See Amazon States Language .
    definition_s3_location StateMachineS3LocationArgs
    The name of the S3 bucket where the state machine definition is stored. The state machine definition must be a JSON or YAML file.
    definition_string str
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON. See Amazon States Language .
    definition_substitutions Mapping[str, Union[str, int, bool]]

    A map (string to string) that specifies the mappings for placeholder variables in the state machine definition. This enables the customer to inject values obtained at runtime, for example from intrinsic functions, in the state machine definition. Variables can be template parameter names, resource logical IDs, resource attributes, or a variable in a key-value map.

    Substitutions must follow the syntax: ${key_name} or ${variable_1,variable_2,...} .

    logging_configuration StateMachineLoggingConfigurationArgs

    Defines what execution history events are logged and where they are logged.

    By default, the level is set to OFF . For more information see Log Levels in the AWS Step Functions User Guide.

    state_machine_name str

    The name of the state machine.

    A name must not contain:

    • white space
    • brackets < > { } [ ]
    • wildcard characters ? *
    • special characters " # % \ ^ | ~ $ & , ; : /`
    • control characters ( U+0000-001F , U+007F-009F )

    If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.

    state_machine_type StateMachineType
    Determines whether a STANDARD or EXPRESS state machine is created. The default is STANDARD . You cannot update the type of a state machine once it has been created. For more information on STANDARD and EXPRESS workflows, see Standard Versus Express Workflows in the AWS Step Functions Developer Guide.
    tags Sequence[TagArgs]

    The list of tags to add to a resource.

    Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @ .

    tracing_configuration StateMachineTracingConfigurationArgs
    Selects whether or not the state machine's AWS X-Ray tracing is enabled.
    roleArn String
    The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
    definition Property Map
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON or YAML, and the format of the object must match the format of your CloudFormation template file. See Amazon States Language .
    definitionS3Location Property Map
    The name of the S3 bucket where the state machine definition is stored. The state machine definition must be a JSON or YAML file.
    definitionString String
    The Amazon States Language definition of the state machine. The state machine definition must be in JSON. See Amazon States Language .
    definitionSubstitutions Map<String | Number | Boolean>

    A map (string to string) that specifies the mappings for placeholder variables in the state machine definition. This enables the customer to inject values obtained at runtime, for example from intrinsic functions, in the state machine definition. Variables can be template parameter names, resource logical IDs, resource attributes, or a variable in a key-value map.

    Substitutions must follow the syntax: ${key_name} or ${variable_1,variable_2,...} .

    loggingConfiguration Property Map

    Defines what execution history events are logged and where they are logged.

    By default, the level is set to OFF . For more information see Log Levels in the AWS Step Functions User Guide.

    stateMachineName String

    The name of the state machine.

    A name must not contain:

    • white space
    • brackets < > { } [ ]
    • wildcard characters ? *
    • special characters " # % \ ^ | ~ $ & , ; : /`
    • control characters ( U+0000-001F , U+007F-009F )

    If you specify a name, you cannot perform updates that require replacement of this resource. You can perform updates that require no or some interruption. If you must replace the resource, specify a new name.

    stateMachineType "STANDARD" | "EXPRESS"
    Determines whether a STANDARD or EXPRESS state machine is created. The default is STANDARD . You cannot update the type of a state machine once it has been created. For more information on STANDARD and EXPRESS workflows, see Standard Versus Express Workflows in the AWS Step Functions Developer Guide.
    tags List<Property Map>

    The list of tags to add to a resource.

    Tags may only contain Unicode letters, digits, white space, or these symbols: _ . : / = + - @ .

    tracingConfiguration Property Map
    Selects whether or not the state machine's AWS X-Ray tracing is enabled.

    Outputs

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

    Arn string
    Returns the ARN of the resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string

    Returns the name of the state machine. For example:

    { "Fn::GetAtt": ["MyStateMachine", "Name"] }

    Returns the name of your state machine:

    HelloWorld-StateMachine

    If you did not specify the name it will be similar to the following:

    MyStateMachine-1234abcdefgh

    For more information about using Fn::GetAtt , see Fn::GetAtt .

    StateMachineRevisionId string
    Identifier for a state machine revision, which is an immutable, read-only snapshot of a state machine’s definition and configuration.
    Arn string
    Returns the ARN of the resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string

    Returns the name of the state machine. For example:

    { "Fn::GetAtt": ["MyStateMachine", "Name"] }

    Returns the name of your state machine:

    HelloWorld-StateMachine

    If you did not specify the name it will be similar to the following:

    MyStateMachine-1234abcdefgh

    For more information about using Fn::GetAtt , see Fn::GetAtt .

    StateMachineRevisionId string
    Identifier for a state machine revision, which is an immutable, read-only snapshot of a state machine’s definition and configuration.
    arn String
    Returns the ARN of the resource.
    id String
    The provider-assigned unique ID for this managed resource.
    name String

    Returns the name of the state machine. For example:

    { "Fn::GetAtt": ["MyStateMachine", "Name"] }

    Returns the name of your state machine:

    HelloWorld-StateMachine

    If you did not specify the name it will be similar to the following:

    MyStateMachine-1234abcdefgh

    For more information about using Fn::GetAtt , see Fn::GetAtt .

    stateMachineRevisionId String
    Identifier for a state machine revision, which is an immutable, read-only snapshot of a state machine’s definition and configuration.
    arn string
    Returns the ARN of the resource.
    id string
    The provider-assigned unique ID for this managed resource.
    name string

    Returns the name of the state machine. For example:

    { "Fn::GetAtt": ["MyStateMachine", "Name"] }

    Returns the name of your state machine:

    HelloWorld-StateMachine

    If you did not specify the name it will be similar to the following:

    MyStateMachine-1234abcdefgh

    For more information about using Fn::GetAtt , see Fn::GetAtt .

    stateMachineRevisionId string
    Identifier for a state machine revision, which is an immutable, read-only snapshot of a state machine’s definition and configuration.
    arn str
    Returns the ARN of the resource.
    id str
    The provider-assigned unique ID for this managed resource.
    name str

    Returns the name of the state machine. For example:

    { "Fn::GetAtt": ["MyStateMachine", "Name"] }

    Returns the name of your state machine:

    HelloWorld-StateMachine

    If you did not specify the name it will be similar to the following:

    MyStateMachine-1234abcdefgh

    For more information about using Fn::GetAtt , see Fn::GetAtt .

    state_machine_revision_id str
    Identifier for a state machine revision, which is an immutable, read-only snapshot of a state machine’s definition and configuration.
    arn String
    Returns the ARN of the resource.
    id String
    The provider-assigned unique ID for this managed resource.
    name String

    Returns the name of the state machine. For example:

    { "Fn::GetAtt": ["MyStateMachine", "Name"] }

    Returns the name of your state machine:

    HelloWorld-StateMachine

    If you did not specify the name it will be similar to the following:

    MyStateMachine-1234abcdefgh

    For more information about using Fn::GetAtt , see Fn::GetAtt .

    stateMachineRevisionId String
    Identifier for a state machine revision, which is an immutable, read-only snapshot of a state machine’s definition and configuration.

    Supporting Types

    StateMachineCloudWatchLogsLogGroup, StateMachineCloudWatchLogsLogGroupArgs

    LogGroupArn string
    The ARN of the the CloudWatch log group to which you want your logs emitted to. The ARN must end with :*
    LogGroupArn string
    The ARN of the the CloudWatch log group to which you want your logs emitted to. The ARN must end with :*
    logGroupArn String
    The ARN of the the CloudWatch log group to which you want your logs emitted to. The ARN must end with :*
    logGroupArn string
    The ARN of the the CloudWatch log group to which you want your logs emitted to. The ARN must end with :*
    log_group_arn str
    The ARN of the the CloudWatch log group to which you want your logs emitted to. The ARN must end with :*
    logGroupArn String
    The ARN of the the CloudWatch log group to which you want your logs emitted to. The ARN must end with :*

    StateMachineLogDestination, StateMachineLogDestinationArgs

    CloudWatchLogsLogGroup Pulumi.AwsNative.StepFunctions.Inputs.StateMachineCloudWatchLogsLogGroup
    An object describing a CloudWatch log group. For more information, see AWS::Logs::LogGroup in the AWS CloudFormation User Guide.
    CloudWatchLogsLogGroup StateMachineCloudWatchLogsLogGroup
    An object describing a CloudWatch log group. For more information, see AWS::Logs::LogGroup in the AWS CloudFormation User Guide.
    cloudWatchLogsLogGroup StateMachineCloudWatchLogsLogGroup
    An object describing a CloudWatch log group. For more information, see AWS::Logs::LogGroup in the AWS CloudFormation User Guide.
    cloudWatchLogsLogGroup StateMachineCloudWatchLogsLogGroup
    An object describing a CloudWatch log group. For more information, see AWS::Logs::LogGroup in the AWS CloudFormation User Guide.
    cloud_watch_logs_log_group StateMachineCloudWatchLogsLogGroup
    An object describing a CloudWatch log group. For more information, see AWS::Logs::LogGroup in the AWS CloudFormation User Guide.
    cloudWatchLogsLogGroup Property Map
    An object describing a CloudWatch log group. For more information, see AWS::Logs::LogGroup in the AWS CloudFormation User Guide.

    StateMachineLoggingConfiguration, StateMachineLoggingConfigurationArgs

    Destinations List<Pulumi.AwsNative.StepFunctions.Inputs.StateMachineLogDestination>
    An array of objects that describes where your execution history events will be logged. Limited to size 1. Required, if your log level is not set to OFF .
    IncludeExecutionData bool
    Determines whether execution data is included in your log. When set to false , data is excluded.
    Level Pulumi.AwsNative.StepFunctions.StateMachineLoggingConfigurationLevel
    Defines which category of execution history events are logged.
    Destinations []StateMachineLogDestination
    An array of objects that describes where your execution history events will be logged. Limited to size 1. Required, if your log level is not set to OFF .
    IncludeExecutionData bool
    Determines whether execution data is included in your log. When set to false , data is excluded.
    Level StateMachineLoggingConfigurationLevel
    Defines which category of execution history events are logged.
    destinations List<StateMachineLogDestination>
    An array of objects that describes where your execution history events will be logged. Limited to size 1. Required, if your log level is not set to OFF .
    includeExecutionData Boolean
    Determines whether execution data is included in your log. When set to false , data is excluded.
    level StateMachineLoggingConfigurationLevel
    Defines which category of execution history events are logged.
    destinations StateMachineLogDestination[]
    An array of objects that describes where your execution history events will be logged. Limited to size 1. Required, if your log level is not set to OFF .
    includeExecutionData boolean
    Determines whether execution data is included in your log. When set to false , data is excluded.
    level StateMachineLoggingConfigurationLevel
    Defines which category of execution history events are logged.
    destinations Sequence[StateMachineLogDestination]
    An array of objects that describes where your execution history events will be logged. Limited to size 1. Required, if your log level is not set to OFF .
    include_execution_data bool
    Determines whether execution data is included in your log. When set to false , data is excluded.
    level StateMachineLoggingConfigurationLevel
    Defines which category of execution history events are logged.
    destinations List<Property Map>
    An array of objects that describes where your execution history events will be logged. Limited to size 1. Required, if your log level is not set to OFF .
    includeExecutionData Boolean
    Determines whether execution data is included in your log. When set to false , data is excluded.
    level "ALL" | "ERROR" | "FATAL" | "OFF"
    Defines which category of execution history events are logged.

    StateMachineLoggingConfigurationLevel, StateMachineLoggingConfigurationLevelArgs

    All
    ALL
    Error
    ERROR
    Fatal
    FATAL
    Off
    OFF
    StateMachineLoggingConfigurationLevelAll
    ALL
    StateMachineLoggingConfigurationLevelError
    ERROR
    StateMachineLoggingConfigurationLevelFatal
    FATAL
    StateMachineLoggingConfigurationLevelOff
    OFF
    All
    ALL
    Error
    ERROR
    Fatal
    FATAL
    Off
    OFF
    All
    ALL
    Error
    ERROR
    Fatal
    FATAL
    Off
    OFF
    ALL
    ALL
    ERROR
    ERROR
    FATAL
    FATAL
    OFF
    OFF
    "ALL"
    ALL
    "ERROR"
    ERROR
    "FATAL"
    FATAL
    "OFF"
    OFF

    StateMachineS3Location, StateMachineS3LocationArgs

    Bucket string
    The name of the S3 bucket where the state machine definition JSON or YAML file is stored.
    Key string
    The name of the state machine definition file (Amazon S3 object name).
    Version string
    For versioning-enabled buckets, a specific version of the state machine definition.
    Bucket string
    The name of the S3 bucket where the state machine definition JSON or YAML file is stored.
    Key string
    The name of the state machine definition file (Amazon S3 object name).
    Version string
    For versioning-enabled buckets, a specific version of the state machine definition.
    bucket String
    The name of the S3 bucket where the state machine definition JSON or YAML file is stored.
    key String
    The name of the state machine definition file (Amazon S3 object name).
    version String
    For versioning-enabled buckets, a specific version of the state machine definition.
    bucket string
    The name of the S3 bucket where the state machine definition JSON or YAML file is stored.
    key string
    The name of the state machine definition file (Amazon S3 object name).
    version string
    For versioning-enabled buckets, a specific version of the state machine definition.
    bucket str
    The name of the S3 bucket where the state machine definition JSON or YAML file is stored.
    key str
    The name of the state machine definition file (Amazon S3 object name).
    version str
    For versioning-enabled buckets, a specific version of the state machine definition.
    bucket String
    The name of the S3 bucket where the state machine definition JSON or YAML file is stored.
    key String
    The name of the state machine definition file (Amazon S3 object name).
    version String
    For versioning-enabled buckets, a specific version of the state machine definition.

    StateMachineTracingConfiguration, StateMachineTracingConfigurationArgs

    Enabled bool
    When set to true , X-Ray tracing is enabled.
    Enabled bool
    When set to true , X-Ray tracing is enabled.
    enabled Boolean
    When set to true , X-Ray tracing is enabled.
    enabled boolean
    When set to true , X-Ray tracing is enabled.
    enabled bool
    When set to true , X-Ray tracing is enabled.
    enabled Boolean
    When set to true , X-Ray tracing is enabled.

    StateMachineType, StateMachineTypeArgs

    Standard
    STANDARD
    Express
    EXPRESS
    StateMachineTypeStandard
    STANDARD
    StateMachineTypeExpress
    EXPRESS
    Standard
    STANDARD
    Express
    EXPRESS
    Standard
    STANDARD
    Express
    EXPRESS
    STANDARD
    STANDARD
    EXPRESS
    EXPRESS
    "STANDARD"
    STANDARD
    "EXPRESS"
    EXPRESS

    Tag, TagArgs

    Key string
    The key name of the tag
    Value string
    The value of the tag
    Key string
    The key name of the tag
    Value string
    The value of the tag
    key String
    The key name of the tag
    value String
    The value of the tag
    key string
    The key name of the tag
    value string
    The value of the tag
    key str
    The key name of the tag
    value str
    The value of the tag
    key String
    The key name of the tag
    value String
    The value of the tag

    Package Details

    Repository
    AWS Native pulumi/pulumi-aws-native
    License
    Apache-2.0
    aws-native logo

    AWS Native is in preview. AWS Classic is fully supported.

    AWS Native v0.109.0 published on Wednesday, Jun 26, 2024 by Pulumi
    pulumi/pulumi-aws-native