pulumi-aws-kotlin/com.pulumi.aws.sfn.kotlin/StateMachine

StateMachine

class StateMachine : KotlinCustomResource

Provides a Step Function State Machine resource

Example Usage

Basic (Standard Workflow)

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// ...
const sfnStateMachine = new aws.sfn.StateMachine("sfn_state_machine", {
    name: "my-state-machine",
    roleArn: iamForSfn.arn,
    definition: `{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "${lambda.arn}",
      "End": true
    }
  }
}
`,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
# ...
sfn_state_machine = aws.sfn.StateMachine("sfn_state_machine",
    name="my-state-machine",
    role_arn=iam_for_sfn["arn"],
    definition=f"""{{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {{
    "HelloWorld": {{
      "Type": "Task",
      "Resource": "{lambda_["arn"]}",
      "End": true
    }}
  }}
}}
""")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // ...
    var sfnStateMachine = new Aws.Sfn.StateMachine("sfn_state_machine", new()
    {
        Name = "my-state-machine",
        RoleArn = iamForSfn.Arn,
        Definition = @$"{{
  ""Comment"": ""A Hello World example of the Amazon States Language using an AWS Lambda Function"",
  ""StartAt"": ""HelloWorld"",
  ""States"": {{
    ""HelloWorld"": {{
      ""Type"": ""Task"",
      ""Resource"": ""{lambda.Arn}"",
      ""End"": true
    }}
  }}
}}
",
    });
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sfn"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ...
		_, err := sfn.NewStateMachine(ctx, "sfn_state_machine", &sfn.StateMachineArgs{
			Name:    pulumi.String("my-state-machine"),
			RoleArn: pulumi.Any(iamForSfn.Arn),
			Definition: pulumi.Sprintf(`{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%v",
      "End": true
    }
  }
}
`, lambda.Arn),
		})
		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.sfn.StateMachine;
import com.pulumi.aws.sfn.StateMachineArgs;
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 sfnStateMachine = new StateMachine("sfnStateMachine", StateMachineArgs.builder()
            .name("my-state-machine")
            .roleArn(iamForSfn.arn())
            .definition("""
{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%s",
      "End": true
    }
  }
}
", lambda.arn()))
            .build());
    }
}
Content copied to clipboard
resources:
  # ...
  sfnStateMachine:
    type: aws:sfn:StateMachine
    name: sfn_state_machine
    properties:
      name: my-state-machine
      roleArn: ${iamForSfn.arn}
      definition: |
        {
          "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
          "StartAt": "HelloWorld",
          "States": {
            "HelloWorld": {
              "Type": "Task",
              "Resource": "${lambda.arn}",
              "End": true
            }
          }
        }
Content copied to clipboard

Basic (Express Workflow)

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// ...
const sfnStateMachine = new aws.sfn.StateMachine("sfn_state_machine", {
    name: "my-state-machine",
    roleArn: iamForSfn.arn,
    type: "EXPRESS",
    definition: `{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "${lambda.arn}",
      "End": true
    }
  }
}
`,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
# ...
sfn_state_machine = aws.sfn.StateMachine("sfn_state_machine",
    name="my-state-machine",
    role_arn=iam_for_sfn["arn"],
    type="EXPRESS",
    definition=f"""{{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {{
    "HelloWorld": {{
      "Type": "Task",
      "Resource": "{lambda_["arn"]}",
      "End": true
    }}
  }}
}}
""")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // ...
    var sfnStateMachine = new Aws.Sfn.StateMachine("sfn_state_machine", new()
    {
        Name = "my-state-machine",
        RoleArn = iamForSfn.Arn,
        Type = "EXPRESS",
        Definition = @$"{{
  ""Comment"": ""A Hello World example of the Amazon States Language using an AWS Lambda Function"",
  ""StartAt"": ""HelloWorld"",
  ""States"": {{
    ""HelloWorld"": {{
      ""Type"": ""Task"",
      ""Resource"": ""{lambda.Arn}"",
      ""End"": true
    }}
  }}
}}
",
    });
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sfn"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ...
		_, err := sfn.NewStateMachine(ctx, "sfn_state_machine", &sfn.StateMachineArgs{
			Name:    pulumi.String("my-state-machine"),
			RoleArn: pulumi.Any(iamForSfn.Arn),
			Type:    pulumi.String("EXPRESS"),
			Definition: pulumi.Sprintf(`{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%v",
      "End": true
    }
  }
}
`, lambda.Arn),
		})
		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.sfn.StateMachine;
import com.pulumi.aws.sfn.StateMachineArgs;
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 sfnStateMachine = new StateMachine("sfnStateMachine", StateMachineArgs.builder()
            .name("my-state-machine")
            .roleArn(iamForSfn.arn())
            .type("EXPRESS")
            .definition("""
{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%s",
      "End": true
    }
  }
}
", lambda.arn()))
            .build());
    }
}
Content copied to clipboard
resources:
  # ...
  sfnStateMachine:
    type: aws:sfn:StateMachine
    name: sfn_state_machine
    properties:
      name: my-state-machine
      roleArn: ${iamForSfn.arn}
      type: EXPRESS
      definition: |
        {
          "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
          "StartAt": "HelloWorld",
          "States": {
            "HelloWorld": {
              "Type": "Task",
              "Resource": "${lambda.arn}",
              "End": true
            }
          }
        }
Content copied to clipboard

Publish (Publish SFN version)

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// ...
const sfnStateMachine = new aws.sfn.StateMachine("sfn_state_machine", {
    name: "my-state-machine",
    roleArn: iamForSfn.arn,
    publish: true,
    type: "EXPRESS",
    definition: `{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "${lambda.arn}",
      "End": true
    }
  }
}
`,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
# ...
sfn_state_machine = aws.sfn.StateMachine("sfn_state_machine",
    name="my-state-machine",
    role_arn=iam_for_sfn["arn"],
    publish=True,
    type="EXPRESS",
    definition=f"""{{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {{
    "HelloWorld": {{
      "Type": "Task",
      "Resource": "{lambda_["arn"]}",
      "End": true
    }}
  }}
}}
""")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // ...
    var sfnStateMachine = new Aws.Sfn.StateMachine("sfn_state_machine", new()
    {
        Name = "my-state-machine",
        RoleArn = iamForSfn.Arn,
        Publish = true,
        Type = "EXPRESS",
        Definition = @$"{{
  ""Comment"": ""A Hello World example of the Amazon States Language using an AWS Lambda Function"",
  ""StartAt"": ""HelloWorld"",
  ""States"": {{
    ""HelloWorld"": {{
      ""Type"": ""Task"",
      ""Resource"": ""{lambda.Arn}"",
      ""End"": true
    }}
  }}
}}
",
    });
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sfn"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ...
		_, err := sfn.NewStateMachine(ctx, "sfn_state_machine", &sfn.StateMachineArgs{
			Name:    pulumi.String("my-state-machine"),
			RoleArn: pulumi.Any(iamForSfn.Arn),
			Publish: pulumi.Bool(true),
			Type:    pulumi.String("EXPRESS"),
			Definition: pulumi.Sprintf(`{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%v",
      "End": true
    }
  }
}
`, lambda.Arn),
		})
		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.sfn.StateMachine;
import com.pulumi.aws.sfn.StateMachineArgs;
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 sfnStateMachine = new StateMachine("sfnStateMachine", StateMachineArgs.builder()
            .name("my-state-machine")
            .roleArn(iamForSfn.arn())
            .publish(true)
            .type("EXPRESS")
            .definition("""
{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%s",
      "End": true
    }
  }
}
", lambda.arn()))
            .build());
    }
}
Content copied to clipboard
resources:
  # ...
  sfnStateMachine:
    type: aws:sfn:StateMachine
    name: sfn_state_machine
    properties:
      name: my-state-machine
      roleArn: ${iamForSfn.arn}
      publish: true
      type: EXPRESS
      definition: |
        {
          "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
          "StartAt": "HelloWorld",
          "States": {
            "HelloWorld": {
              "Type": "Task",
              "Resource": "${lambda.arn}",
              "End": true
            }
          }
        }
Content copied to clipboard

Logging

NOTE: See the AWS Step Functions Developer Guide for more information about enabling Step Function logging.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// ...
const sfnStateMachine = new aws.sfn.StateMachine("sfn_state_machine", {
    name: "my-state-machine",
    roleArn: iamForSfn.arn,
    definition: `{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "${lambda.arn}",
      "End": true
    }
  }
}
`,
    loggingConfiguration: {
        logDestination: `${logGroupForSfn.arn}:*`,
        includeExecutionData: true,
        level: "ERROR",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
# ...
sfn_state_machine = aws.sfn.StateMachine("sfn_state_machine",
    name="my-state-machine",
    role_arn=iam_for_sfn["arn"],
    definition=f"""{{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {{
    "HelloWorld": {{
      "Type": "Task",
      "Resource": "{lambda_["arn"]}",
      "End": true
    }}
  }}
}}
""",
    logging_configuration={
        "log_destination": f"{log_group_for_sfn['arn']}:*",
        "include_execution_data": True,
        "level": "ERROR",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // ...
    var sfnStateMachine = new Aws.Sfn.StateMachine("sfn_state_machine", new()
    {
        Name = "my-state-machine",
        RoleArn = iamForSfn.Arn,
        Definition = @$"{{
  ""Comment"": ""A Hello World example of the Amazon States Language using an AWS Lambda Function"",
  ""StartAt"": ""HelloWorld"",
  ""States"": {{
    ""HelloWorld"": {{
      ""Type"": ""Task"",
      ""Resource"": ""{lambda.Arn}"",
      ""End"": true
    }}
  }}
}}
",
        LoggingConfiguration = new Aws.Sfn.Inputs.StateMachineLoggingConfigurationArgs
        {
            LogDestination = $"{logGroupForSfn.Arn}:*",
            IncludeExecutionData = true,
            Level = "ERROR",
        },
    });
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sfn"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ...
		_, err := sfn.NewStateMachine(ctx, "sfn_state_machine", &sfn.StateMachineArgs{
			Name:    pulumi.String("my-state-machine"),
			RoleArn: pulumi.Any(iamForSfn.Arn),
			Definition: pulumi.Sprintf(`{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%v",
      "End": true
    }
  }
}
`, lambda.Arn),
			LoggingConfiguration: &sfn.StateMachineLoggingConfigurationArgs{
				LogDestination:       pulumi.Sprintf("%v:*", logGroupForSfn.Arn),
				IncludeExecutionData: pulumi.Bool(true),
				Level:                pulumi.String("ERROR"),
			},
		})
		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.sfn.StateMachine;
import com.pulumi.aws.sfn.StateMachineArgs;
import com.pulumi.aws.sfn.inputs.StateMachineLoggingConfigurationArgs;
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 sfnStateMachine = new StateMachine("sfnStateMachine", StateMachineArgs.builder()
            .name("my-state-machine")
            .roleArn(iamForSfn.arn())
            .definition("""
{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%s",
      "End": true
    }
  }
}
", lambda.arn()))
            .loggingConfiguration(StateMachineLoggingConfigurationArgs.builder()
                .logDestination(String.format("%s:*", logGroupForSfn.arn()))
                .includeExecutionData(true)
                .level("ERROR")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  # ...
  sfnStateMachine:
    type: aws:sfn:StateMachine
    name: sfn_state_machine
    properties:
      name: my-state-machine
      roleArn: ${iamForSfn.arn}
      definition: |
        {
          "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
          "StartAt": "HelloWorld",
          "States": {
            "HelloWorld": {
              "Type": "Task",
              "Resource": "${lambda.arn}",
              "End": true
            }
          }
        }
      loggingConfiguration:
        logDestination: ${logGroupForSfn.arn}:*
        includeExecutionData: true
        level: ERROR
Content copied to clipboard

Encryption

NOTE: See the section Data at rest encyption in the AWS Step Functions Developer Guide for more information about enabling encryption of data using a customer-managed key for Step Functions State Machines data.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
// ...
const sfnStateMachine = new aws.sfn.StateMachine("sfn_state_machine", {
    name: "my-state-machine",
    roleArn: iamForSfn.arn,
    definition: `{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "${lambda.arn}",
      "End": true
    }
  }
}
`,
    encryptionConfiguration: {
        kmsKeyId: kmsKeyForSfn.arn,
        type: "CUSTOMER_MANAGED_KMS_KEY",
        kmsDataKeyReusePeriodSeconds: 900,
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
# ...
sfn_state_machine = aws.sfn.StateMachine("sfn_state_machine",
    name="my-state-machine",
    role_arn=iam_for_sfn["arn"],
    definition=f"""{{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {{
    "HelloWorld": {{
      "Type": "Task",
      "Resource": "{lambda_["arn"]}",
      "End": true
    }}
  }}
}}
""",
    encryption_configuration={
        "kms_key_id": kms_key_for_sfn["arn"],
        "type": "CUSTOMER_MANAGED_KMS_KEY",
        "kms_data_key_reuse_period_seconds": 900,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    // ...
    var sfnStateMachine = new Aws.Sfn.StateMachine("sfn_state_machine", new()
    {
        Name = "my-state-machine",
        RoleArn = iamForSfn.Arn,
        Definition = @$"{{
  ""Comment"": ""A Hello World example of the Amazon States Language using an AWS Lambda Function"",
  ""StartAt"": ""HelloWorld"",
  ""States"": {{
    ""HelloWorld"": {{
      ""Type"": ""Task"",
      ""Resource"": ""{lambda.Arn}"",
      ""End"": true
    }}
  }}
}}
",
        EncryptionConfiguration = new Aws.Sfn.Inputs.StateMachineEncryptionConfigurationArgs
        {
            KmsKeyId = kmsKeyForSfn.Arn,
            Type = "CUSTOMER_MANAGED_KMS_KEY",
            KmsDataKeyReusePeriodSeconds = 900,
        },
    });
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/sfn"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// ...
		_, err := sfn.NewStateMachine(ctx, "sfn_state_machine", &sfn.StateMachineArgs{
			Name:    pulumi.String("my-state-machine"),
			RoleArn: pulumi.Any(iamForSfn.Arn),
			Definition: pulumi.Sprintf(`{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%v",
      "End": true
    }
  }
}
`, lambda.Arn),
			EncryptionConfiguration: &sfn.StateMachineEncryptionConfigurationArgs{
				KmsKeyId:                     pulumi.Any(kmsKeyForSfn.Arn),
				Type:                         pulumi.String("CUSTOMER_MANAGED_KMS_KEY"),
				KmsDataKeyReusePeriodSeconds: pulumi.Int(900),
			},
		})
		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.sfn.StateMachine;
import com.pulumi.aws.sfn.StateMachineArgs;
import com.pulumi.aws.sfn.inputs.StateMachineEncryptionConfigurationArgs;
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 sfnStateMachine = new StateMachine("sfnStateMachine", StateMachineArgs.builder()
            .name("my-state-machine")
            .roleArn(iamForSfn.arn())
            .definition("""
{
  "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
  "StartAt": "HelloWorld",
  "States": {
    "HelloWorld": {
      "Type": "Task",
      "Resource": "%s",
      "End": true
    }
  }
}
", lambda.arn()))
            .encryptionConfiguration(StateMachineEncryptionConfigurationArgs.builder()
                .kmsKeyId(kmsKeyForSfn.arn())
                .type("CUSTOMER_MANAGED_KMS_KEY")
                .kmsDataKeyReusePeriodSeconds(900)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  # ...
  sfnStateMachine:
    type: aws:sfn:StateMachine
    name: sfn_state_machine
    properties:
      name: my-state-machine
      roleArn: ${iamForSfn.arn}
      definition: |
        {
          "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda Function",
          "StartAt": "HelloWorld",
          "States": {
            "HelloWorld": {
              "Type": "Task",
              "Resource": "${lambda.arn}",
              "End": true
            }
          }
        }
      encryptionConfiguration:
        kmsKeyId: ${kmsKeyForSfn.arn}
        type: CUSTOMER_MANAGED_KMS_KEY
        kmsDataKeyReusePeriodSeconds: 900
Content copied to clipboard

Import

Using pulumi import, import State Machines using the arn. For example:

$ pulumi import aws:sfn/stateMachine:StateMachine foo arn:aws:states:eu-west-1:123456789098:stateMachine:bar
Content copied to clipboard

Properties

Link copied to clipboard
val arn: Output<String>

The ARN of the state machine.

Link copied to clipboard
val creationDate: Output<String>

The date the state machine was created.

Link copied to clipboard
val definition: Output<String>

The Amazon States Language definition of the state machine.

Link copied to clipboard
val description: Output<String>
Link copied to clipboard
val encryptionConfiguration: Output<StateMachineEncryptionConfiguration>

Defines what encryption configuration is used to encrypt data in the State Machine. For more information see TBD in the AWS Step Functions User Guide.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val loggingConfiguration: Output<StateMachineLoggingConfiguration>

Defines what execution history events are logged and where they are logged. The logging_configuration parameter is valid when type is set to STANDARD or EXPRESS. Defaults to OFF. For more information see Logging Express Workflows, Log Levels and Logging Configuration in the AWS Step Functions User Guide.

Link copied to clipboard
val name: Output<String>

The name of the state machine. The name should only contain 0-9, A-Z, a-z, - and _. If omitted, the provider will assign a random, unique name.

Link copied to clipboard
val namePrefix: Output<String>

Creates a unique name beginning with the specified prefix. Conflicts with name.

Link copied to clipboard
val publish: Output<Boolean>?

Set to true to publish a version of the state machine during creation. Default: false.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val revisionId: Output<String>
Link copied to clipboard
val roleArn: Output<String>

The Amazon Resource Name (ARN) of the IAM role to use for this state machine.

Link copied to clipboard
val stateMachineVersionArn: Output<String>

The ARN of the state machine version.

Link copied to clipboard
val status: Output<String>

The current status of the state machine. Either ACTIVE or DELETING.

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

Key-value map of resource 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 tagsAll: Output<Map<String, String>>

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

Link copied to clipboard
val tracingConfiguration: Output<StateMachineTracingConfiguration>

Selects whether AWS X-Ray tracing is enabled.

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

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. Valid values: STANDARD, EXPRESS.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val versionDescription: Output<String>