Namespace Amazon.CDK.AWS.StepFunctions
AWS Step Functions Construct Library
---AWS CDK v1 has reached End-of-Support on 2023-06-01.
This package is no longer being updated, and users should migrate to AWS CDK v2.
For more information on how to migrate, see the Migrating to AWS CDK v2 guide.
The @aws-cdk/aws-stepfunctions
package contains constructs for building
serverless workflows using objects. Use this in conjunction with the
@aws-cdk/aws-stepfunctions-tasks
package, which contains classes used
to call other AWS services.
Defining a workflow looks like this (for the Step Functions Job Poller example):
Example
using Amazon.CDK.AWS.Lambda;
Function submitLambda;
Function getStatusLambda;
var submitJob = new LambdaInvoke(this, "Submit Job", new LambdaInvokeProps {
LambdaFunction = submitLambda,
// Lambda's result is in the attribute `Payload`
OutputPath = "$.Payload"
});
var waitX = new Wait(this, "Wait X Seconds", new WaitProps {
Time = WaitTime.SecondsPath("$.waitSeconds")
});
var getStatus = new LambdaInvoke(this, "Get Job Status", new LambdaInvokeProps {
LambdaFunction = getStatusLambda,
// Pass just the field named "guid" into the Lambda, put the
// Lambda's result in a field called "status" in the response
InputPath = "$.guid",
OutputPath = "$.Payload"
});
var jobFailed = new Fail(this, "Job Failed", new FailProps {
Cause = "AWS Batch Job Failed",
Error = "DescribeJob returned FAILED"
});
var finalStatus = new LambdaInvoke(this, "Get Final Job Status", new LambdaInvokeProps {
LambdaFunction = getStatusLambda,
// Use "guid" field as input
InputPath = "$.guid",
OutputPath = "$.Payload"
});
var definition = submitJob.Next(waitX).Next(getStatus).Next(new Choice(this, "Job Complete?").When(Condition.StringEquals("$.status", "FAILED"), jobFailed).When(Condition.StringEquals("$.status", "SUCCEEDED"), finalStatus).Otherwise(waitX));
new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = definition,
Timeout = Duration.Minutes(5)
});
You can find more sample snippets and learn more about the service integrations
in the @aws-cdk/aws-stepfunctions-tasks
package.
State Machine
A stepfunctions.StateMachine
is a resource that takes a state machine
definition. The definition is specified by its start state, and encompasses
all states reachable from the start state:
var startState = new Pass(this, "StartState");
new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = startState
});
State machines execute using an IAM Role, which will automatically have all permissions added that are required to make all state machine tasks execute properly (for example, permissions to invoke any Lambda functions you add to your workflow). A role will be created by default, but you can supply an existing one as well.
Accessing State (the JsonPath class)
Every State Machine execution has State Machine Data: a JSON document containing keys and values that is fed into the state machine, gets modified as the state machine progresses, and finally is produced as output.
You can pass fragments of this State Machine Data into Tasks of the state machine.
To do so, use the static methods on the JsonPath
class. For example, to pass
the value that's in the data key of OrderId
to a Lambda function as you invoke
it, use JsonPath.stringAt('$.OrderId')
, like so:
using Amazon.CDK.AWS.Lambda;
Function orderFn;
var submitJob = new LambdaInvoke(this, "InvokeOrderProcessor", new LambdaInvokeProps {
LambdaFunction = orderFn,
Payload = TaskInput.FromObject(new Dictionary<string, object> {
{ "OrderId", JsonPath.StringAt("$.OrderId") }
})
});
The following methods are available:
Method | Purpose |
---|---|
JsonPath.stringAt('$.Field') |
reference a field, return the type as a string . |
JsonPath.listAt('$.Field') |
reference a field, return the type as a list of strings. |
JsonPath.numberAt('$.Field') |
reference a field, return the type as a number. Use this for functions that expect a number argument. |
JsonPath.objectAt('$.Field') |
reference a field, return the type as an IResolvable . Use this for functions that expect an object argument. |
JsonPath.entirePayload |
reference the entire data object (equivalent to a path of $ ). |
JsonPath.taskToken |
reference the Task Token, used for integration patterns that need to run for a long time. |
You can also call intrinsic functions using the methods on JsonPath
:
Method | Purpose |
---|---|
JsonPath.array(JsonPath.stringAt('$.Field'), ...) |
make an array from other elements. |
JsonPath.format('The value is {}.', JsonPath.stringAt('$.Value')) |
insert elements into a format string. |
JsonPath.stringToJson(JsonPath.stringAt('$.ObjStr')) |
parse a JSON string to an object |
JsonPath.jsonToString(JsonPath.objectAt('$.Obj')) |
stringify an object to a JSON string |
Amazon States Language
This library comes with a set of classes that model the Amazon States Language. The following State classes are supported:
An arbitrary JSON object (specified at execution start) is passed from state to state and transformed during the execution of the workflow. For more information, see the States Language spec.
Task
A Task
represents some work that needs to be done. The exact work to be
done is determine by a class that implements IStepFunctionsTask
, a collection
of which can be found in the @aws-cdk/aws-stepfunctions-tasks
module.
The tasks in the @aws-cdk/aws-stepfunctions-tasks
module support the
service integration pattern that integrates Step Functions with services
directly in the Amazon States language.
Pass
A Pass
state passes its input to its output, without performing work.
Pass states are useful when constructing and debugging state machines.
The following example injects some fixed data into the state machine through
the result
field. The result
field will be added to the input and the result
will be passed as the state's output.
// Makes the current JSON state { ..., "subObject": { "hello": "world" } }
var pass = new Pass(this, "Add Hello World", new PassProps {
Result = Result.FromObject(new Dictionary<string, object> { { "hello", "world" } }),
ResultPath = "$.subObject"
});
// Set the next state
var nextState = new Pass(this, "NextState");
pass.Next(nextState);
The Pass
state also supports passing key-value pairs as input. Values can
be static, or selected from the input with a path.
The following example filters the greeting
field from the state input
and also injects a field called otherData
.
var pass = new Pass(this, "Filter input and inject data", new PassProps {
Parameters = new Dictionary<string, object> { // input to the pass state
{ "input", JsonPath.StringAt("$.input.greeting") },
{ "otherData", "some-extra-stuff" } }
});
The object specified in parameters
will be the input of the Pass
state.
Since neither Result
nor ResultPath
are supplied, the Pass
state copies
its input through to its output.
Learn more about the Pass state
Wait
A Wait
state waits for a given number of seconds, or until the current time
hits a particular time. The time to wait may be taken from the execution's JSON
state.
// Wait until it's the time mentioned in the the state object's "triggerTime"
// field.
var wait = new Wait(this, "Wait For Trigger Time", new WaitProps {
Time = WaitTime.TimestampPath("$.triggerTime")
});
// Set the next state
var startTheWork = new Pass(this, "StartTheWork");
wait.Next(startTheWork);
Choice
A Choice
state can take a different path through the workflow based on the
values in the execution's JSON state:
var choice = new Choice(this, "Did it work?");
// Add conditions with .when()
var successState = new Pass(this, "SuccessState");
var failureState = new Pass(this, "FailureState");
choice.When(Condition.StringEquals("$.status", "SUCCESS"), successState);
choice.When(Condition.NumberGreaterThan("$.attempts", 5), failureState);
// Use .otherwise() to indicate what should be done if none of the conditions match
var tryAgainState = new Pass(this, "TryAgainState");
choice.Otherwise(tryAgainState);
If you want to temporarily branch your workflow based on a condition, but have
all branches come together and continuing as one (similar to how an if ... then ... else
works in a programming language), use the .afterwards()
method:
var choice = new Choice(this, "What color is it?");
var handleBlueItem = new Pass(this, "HandleBlueItem");
var handleRedItem = new Pass(this, "HandleRedItem");
var handleOtherItemColor = new Pass(this, "HanldeOtherItemColor");
choice.When(Condition.StringEquals("$.color", "BLUE"), handleBlueItem);
choice.When(Condition.StringEquals("$.color", "RED"), handleRedItem);
choice.Otherwise(handleOtherItemColor);
// Use .afterwards() to join all possible paths back together and continue
var shipTheItem = new Pass(this, "ShipTheItem");
choice.Afterwards().Next(shipTheItem);
If your Choice
doesn't have an otherwise()
and none of the conditions match
the JSON state, a NoChoiceMatched
error will be thrown. Wrap the state machine
in a Parallel
state if you want to catch and recover from this.
Available Conditions
see step function comparison operators
Parallel
A Parallel
state executes one or more subworkflows in parallel. It can also
be used to catch and recover from errors in subworkflows.
var parallel = new Parallel(this, "Do the work in parallel");
// Add branches to be executed in parallel
var shipItem = new Pass(this, "ShipItem");
var sendInvoice = new Pass(this, "SendInvoice");
var restock = new Pass(this, "Restock");
parallel.Branch(shipItem);
parallel.Branch(sendInvoice);
parallel.Branch(restock);
// Retry the whole workflow if something goes wrong
parallel.AddRetry(new RetryProps { MaxAttempts = 1 });
// How to recover from errors
var sendFailureNotification = new Pass(this, "SendFailureNotification");
parallel.AddCatch(sendFailureNotification);
// What to do in case everything succeeded
var closeOrder = new Pass(this, "CloseOrder");
parallel.Next(closeOrder);
Succeed
Reaching a Succeed
state terminates the state machine execution with a
successful status.
var success = new Succeed(this, "We did it!");
Fail
Reaching a Fail
state terminates the state machine execution with a
failure status. The fail state should report the reason for the failure.
Failures can be caught by encompassing Parallel
states.
var success = new Fail(this, "Fail", new FailProps {
Error = "WorkflowFailure",
Cause = "Something went wrong"
});
Map
A Map
state can be used to run a set of steps for each element of an input array.
A Map
state will execute the same steps for multiple entries of an array in the state input.
While the Parallel
state executes multiple branches of steps using the same input, a Map
state will
execute the same steps for multiple entries of an array in the state input.
var map = new Map(this, "Map State", new MapProps {
MaxConcurrency = 1,
ItemsPath = JsonPath.StringAt("$.inputForMap")
});
map.Iterator(new Pass(this, "Pass State"));
Custom State
It's possible that the high-level constructs for the states or stepfunctions-tasks
do not have
the states or service integrations you are looking for. The primary reasons for this lack of
functionality are:
If a feature is not available, a CustomState
can be used to supply any Amazon States Language
JSON-based object as the state definition.
Code Snippets are available and can be plugged in as the state definition.
Custom states can be chained together with any of the other states to create your state machine
definition. You will also need to provide any permissions that are required to the role
that
the State Machine uses.
The following example uses the DynamoDB
service integration to insert data into a DynamoDB table.
using Amazon.CDK.AWS.DynamoDB;
// create a table
var table = new Table(this, "montable", new TableProps {
PartitionKey = new Attribute {
Name = "id",
Type = AttributeType.STRING
}
});
var finalStatus = new Pass(this, "final step");
// States language JSON to put an item into DynamoDB
// snippet generated from https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-code-snippet.html#tutorial-code-snippet-1
IDictionary<string, object> stateJson = new Dictionary<string, object> {
{ "Type", "Task" },
{ "Resource", "arn:aws:states:::dynamodb:putItem" },
{ "Parameters", new Dictionary<string, object> {
{ "TableName", table.TableName },
{ "Item", new Dictionary<string, IDictionary<string, string>> {
{ "id", new Dictionary<string, string> {
{ "S", "MyEntry" }
} }
} }
} },
{ "ResultPath", null }
};
// custom state which represents a task to insert data into DynamoDB
var custom = new CustomState(this, "my custom task", new CustomStateProps {
StateJson = stateJson
});
var chain = Chain.Start(custom).Next(finalStatus);
var sm = new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = chain,
Timeout = Duration.Seconds(30)
});
// don't forget permissions. You need to assign them
table.GrantWriteData(sm);
Task Chaining
To make defining work flows as convenient (and readable in a top-to-bottom way)
as writing regular programs, it is possible to chain most methods invocations.
In particular, the .next()
method can be repeated. The result of a series of
.next()
calls is called a Chain, and can be used when defining the jump
targets of Choice.on
or Parallel.branch
:
var step1 = new Pass(this, "Step1");
var step2 = new Pass(this, "Step2");
var step3 = new Pass(this, "Step3");
var step4 = new Pass(this, "Step4");
var step5 = new Pass(this, "Step5");
var step6 = new Pass(this, "Step6");
var step7 = new Pass(this, "Step7");
var step8 = new Pass(this, "Step8");
var step9 = new Pass(this, "Step9");
var step10 = new Pass(this, "Step10");
var choice = new Choice(this, "Choice");
var condition1 = Condition.StringEquals("$.status", "SUCCESS");
var parallel = new Parallel(this, "Parallel");
var finish = new Pass(this, "Finish");
var definition = step1.Next(step2).Next(choice.When(condition1, step3.Next(step4).Next(step5)).Otherwise(step6).Afterwards()).Next(parallel.Branch(step7.Next(step8)).Branch(step9.Next(step10))).Next(finish);
new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = definition
});
If you don't like the visual look of starting a chain directly off the first
step, you can use Chain.start
:
var step1 = new Pass(this, "Step1");
var step2 = new Pass(this, "Step2");
var step3 = new Pass(this, "Step3");
var definition = Chain.Start(step1).Next(step2).Next(step3);
State Machine Fragments
It is possible to define reusable (or abstracted) mini-state machines by
defining a construct that implements IChainable
, which requires you to define
two fields:
Since states will be named after their construct IDs, you may need to prefix the IDs of states if you plan to instantiate the same state machine fragment multiples times (otherwise all states in every instantiation would have the same name).
The class StateMachineFragment
contains some helper functions (like
prefixStates()
) to make it easier for you to do this. If you define your state
machine as a subclass of this, it will be convenient to use:
using Amazon.CDK;
using Constructs;
using Amazon.CDK.AWS.StepFunctions;
class MyJobProps
{
public string JobFlavor { get; set; }
}
class MyJob : StateMachineFragment
{
public State StartState { get; }
public INextable[] EndStates { get; }
public MyJob(Construct parent, string id, MyJobProps props) : base(parent, id)
{
var choice = new Choice(this, "Choice").When(Condition.StringEquals("$.branch", "left"), new Pass(this, "Left Branch")).When(Condition.StringEquals("$.branch", "right"), new Pass(this, "Right Branch"));
// ...
StartState = choice;
EndStates = choice.Afterwards().EndStates;
}
}
class MyStack : Stack
{
public MyStack(Construct scope, string id) : base(scope, id)
{
// Do 3 different variants of MyJob in parallel
var parallel = new Parallel(this, "All jobs").Branch(new MyJob(this, "Quick", new MyJobProps { JobFlavor = "quick" }).PrefixStates()).Branch(new MyJob(this, "Medium", new MyJobProps { JobFlavor = "medium" }).PrefixStates()).Branch(new MyJob(this, "Slow", new MyJobProps { JobFlavor = "slow" }).PrefixStates());
new StateMachine(this, "MyStateMachine", new StateMachineProps {
Definition = parallel
});
}
}
A few utility functions are available to parse state machine fragments.
Activity
Activities represent work that is done on some non-Lambda worker pool. The Step Functions workflow will submit work to this Activity, and a worker pool that you run yourself, probably on EC2, will pull jobs from the Activity and submit the results of individual jobs back.
You need the ARN to do so, so if you use Activities be sure to pass the Activity ARN into your worker pool:
var activity = new Activity(this, "Activity");
// Read this CloudFormation Output from your application and use it to poll for work on
// the activity.
// Read this CloudFormation Output from your application and use it to poll for work on
// the activity.
new CfnOutput(this, "ActivityArn", new CfnOutputProps { Value = activity.ActivityArn });
Activity-Level Permissions
Granting IAM permissions to an activity can be achieved by calling the grant(principal, actions)
API:
var activity = new Activity(this, "Activity");
var role = new Role(this, "Role", new RoleProps {
AssumedBy = new ServicePrincipal("lambda.amazonaws.com")
});
activity.Grant(role, "states:SendTaskSuccess");
This will grant the IAM principal the specified actions onto the activity.
Metrics
Task
object expose various metrics on the execution of that particular task. For example,
to create an alarm on a particular task failing:
Task task;
new Alarm(this, "TaskAlarm", new AlarmProps {
Metric = task.MetricFailed(),
Threshold = 1,
EvaluationPeriods = 1
});
There are also metrics on the complete state machine:
StateMachine stateMachine;
new Alarm(this, "StateMachineAlarm", new AlarmProps {
Metric = stateMachine.MetricFailed(),
Threshold = 1,
EvaluationPeriods = 1
});
And there are metrics on the capacity of all state machines in your account:
new Alarm(this, "ThrottledAlarm", new AlarmProps {
Metric = StateTransitionMetric.MetricThrottledEvents(),
Threshold = 10,
EvaluationPeriods = 2
});
Error names
Step Functions identifies errors in the Amazon States Language using case-sensitive strings, known as error names.
The Amazon States Language defines a set of built-in strings that name well-known errors, all beginning with the States.
prefix.
Logging
Enable logging to CloudWatch by passing a logging configuration with a destination LogGroup:
using Amazon.CDK.AWS.Logs;
var logGroup = new LogGroup(this, "MyLogGroup");
new StateMachine(this, "MyStateMachine", new StateMachineProps {
Definition = Chain.Start(new Pass(this, "Pass")),
Logs = new LogOptions {
Destination = logGroup,
Level = LogLevel.ALL
}
});
X-Ray tracing
Enable X-Ray tracing for StateMachine:
new StateMachine(this, "MyStateMachine", new StateMachineProps {
Definition = Chain.Start(new Pass(this, "Pass")),
TracingEnabled = true
});
See the AWS documentation to learn more about AWS Step Functions's X-Ray support.
State Machine Permission Grants
IAM roles, users, or groups which need to be able to work with a State Machine should be granted IAM permissions.
Any object that implements the IGrantable
interface (has an associated principal) can be granted permissions by calling:
Start Execution Permission
Grant permission to start an execution of a state machine by calling the grantStartExecution()
API.
IChainable definition;
var role = new Role(this, "Role", new RoleProps {
AssumedBy = new ServicePrincipal("lambda.amazonaws.com")
});
var stateMachine = new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = definition
});
// Give role permission to start execution of state machine
stateMachine.GrantStartExecution(role);
The following permission is provided to a service principal by the grantStartExecution()
API:
Read Permissions
Grant read
access to a state machine by calling the grantRead()
API.
IChainable definition;
var role = new Role(this, "Role", new RoleProps {
AssumedBy = new ServicePrincipal("lambda.amazonaws.com")
});
var stateMachine = new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = definition
});
// Give role read access to state machine
stateMachine.GrantRead(role);
The following read permissions are provided to a service principal by the grantRead()
API:
Task Response Permissions
Grant permission to allow task responses to a state machine by calling the grantTaskResponse()
API:
IChainable definition;
var role = new Role(this, "Role", new RoleProps {
AssumedBy = new ServicePrincipal("lambda.amazonaws.com")
});
var stateMachine = new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = definition
});
// Give role task response permissions to the state machine
stateMachine.GrantTaskResponse(role);
The following read permissions are provided to a service principal by the grantRead()
API:
Execution-level Permissions
Grant execution-level permissions to a state machine by calling the grantExecution()
API:
IChainable definition;
var role = new Role(this, "Role", new RoleProps {
AssumedBy = new ServicePrincipal("lambda.amazonaws.com")
});
var stateMachine = new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = definition
});
// Give role permission to get execution history of ALL executions for the state machine
stateMachine.GrantExecution(role, "states:GetExecutionHistory");
Custom Permissions
You can add any set of permissions to a state machine by calling the grant()
API.
IChainable definition;
var user = new User(this, "MyUser");
var stateMachine = new StateMachine(this, "StateMachine", new StateMachineProps {
Definition = definition
});
//give user permission to send task success to the state machine
stateMachine.Grant(user, "states:SendTaskSuccess");
Import
Any Step Functions state machine that has been created outside the stack can be imported into your CDK stack.
State machines can be imported by their ARN via the StateMachine.fromStateMachineArn()
API
var app = new App();
var stack = new Stack(app, "MyStack");
StateMachine.FromStateMachineArn(stack, "ImportedStateMachine", "arn:aws:states:us-east-1:123456789012:stateMachine:StateMachine2E01A3A5-N5TJppzoevKQ");
Classes
Activity | Define a new Step Functions Activity. |
ActivityProps | Properties for defining a new Step Functions Activity. |
AfterwardsOptions | Options for selecting the choice paths. |
CatchProps | Error handler details. |
CfnActivity | A CloudFormation |
CfnActivity.TagsEntryProperty | The |
CfnActivityProps | Properties for defining a |
CfnStateMachine | A CloudFormation |
CfnStateMachine.CloudWatchLogsLogGroupProperty | Defines a CloudWatch log group. |
CfnStateMachine.LogDestinationProperty | Defines a destination for |
CfnStateMachine.LoggingConfigurationProperty | Defines what execution history events are logged and where they are logged. |
CfnStateMachine.S3LocationProperty | Defines the S3 bucket location where a state machine definition is stored. |
CfnStateMachine.TagsEntryProperty | The |
CfnStateMachine.TracingConfigurationProperty | Selects whether or not the state machine's AWS X-Ray tracing is enabled. |
CfnStateMachineProps | Properties for defining a |
Chain | A collection of states to chain onto. |
Choice | Define a Choice in the state machine. |
ChoiceProps | Properties for defining a Choice state. |
Condition | A Condition for use in a Choice state branch. |
Context | (deprecated) Extract a field from the State Machine Context data. |
CustomState | State defined by supplying Amazon States Language (ASL) in the state machine. |
CustomStateProps | Properties for defining a custom state definition. |
Data | (deprecated) Extract a field from the State Machine data that gets passed around between states. |
Errors | Predefined error strings Error names in Amazon States Language - https://states-language.net/spec.html#appendix-a Error handling in Step Functions - https://docs.aws.amazon.com/step-functions/latest/dg/concepts-error-handling.html. |
Fail | Define a Fail state in the state machine. |
FailProps | Properties for defining a Fail state. |
FieldUtils | Helper functions to work with structures containing fields. |
FindStateOptions | Options for finding reachable states. |
InputType | The type of task input. |
IntegrationPattern | AWS Step Functions integrates with services directly in the Amazon States Language. |
JsonPath | Extract a field from the State Machine data or context that gets passed around between states. |
LogLevel | Defines which category of execution history events are logged. |
LogOptions | Defines what execution history events are logged and where they are logged. |
Map | Define a Map state in the state machine. |
MapProps | Properties for defining a Map state. |
Parallel | Define a Parallel state in the state machine. |
ParallelProps | Properties for defining a Parallel state. |
Pass | Define a Pass in the state machine. |
PassProps | Properties for defining a Pass state. |
Result | The result of a Pass operation. |
RetryProps | Retry details. |
ServiceIntegrationPattern | Three ways to call an integrated service: Request Response, Run a Job and Wait for a Callback with Task Token. |
SingleStateOptions | Options for creating a single state. |
State | Base class for all other state classes. |
StateGraph | A collection of connected states. |
StateMachine | Define a StepFunctions State Machine. |
StateMachineFragment | Base class for reusable state machine fragments. |
StateMachineProps | Properties for defining a State Machine. |
StateMachineType | Two types of state machines are available in AWS Step Functions: EXPRESS AND STANDARD. |
StateProps | Properties shared by all states. |
StateTransitionMetric | Metrics on the rate limiting performed on state machine execution. |
StepFunctionsTaskConfig | (deprecated) Properties that define what kind of task should be created. |
Succeed | Define a Succeed state in the state machine. |
SucceedProps | Properties for defining a Succeed state. |
Task | (deprecated) Define a Task state in the state machine. |
TaskInput | Type union for task classes that accept multiple types of payload. |
TaskMetricsConfig | Task Metrics. |
TaskProps | (deprecated) Props that are common to all tasks. |
TaskStateBase | Define a Task state in the state machine. |
TaskStateBaseProps | Props that are common to all tasks. |
Wait | Define a Wait state in the state machine. |
WaitProps | Properties for defining a Wait state. |
WaitTime | Represents the Wait state which delays a state machine from continuing for a specified time. |
Interfaces
CfnActivity.ITagsEntryProperty | The |
CfnStateMachine.ICloudWatchLogsLogGroupProperty | Defines a CloudWatch log group. |
CfnStateMachine.ILogDestinationProperty | Defines a destination for |
CfnStateMachine.ILoggingConfigurationProperty | Defines what execution history events are logged and where they are logged. |
CfnStateMachine.IS3LocationProperty | Defines the S3 bucket location where a state machine definition is stored. |
CfnStateMachine.ITagsEntryProperty | The |
CfnStateMachine.ITracingConfigurationProperty | Selects whether or not the state machine's AWS X-Ray tracing is enabled. |
IActivity | Represents a Step Functions Activity https://docs.aws.amazon.com/step-functions/latest/dg/concepts-activities.html. |
IActivityProps | Properties for defining a new Step Functions Activity. |
IAfterwardsOptions | Options for selecting the choice paths. |
ICatchProps | Error handler details. |
ICfnActivityProps | Properties for defining a |
ICfnStateMachineProps | Properties for defining a |
IChainable | Interface for objects that can be used in a Chain. |
IChoiceProps | Properties for defining a Choice state. |
ICustomStateProps | Properties for defining a custom state definition. |
IFailProps | Properties for defining a Fail state. |
IFindStateOptions | Options for finding reachable states. |
ILogOptions | Defines what execution history events are logged and where they are logged. |
IMapProps | Properties for defining a Map state. |
INextable | Interface for states that can have 'next' states. |
IParallelProps | Properties for defining a Parallel state. |
IPassProps | Properties for defining a Pass state. |
IRetryProps | Retry details. |
ISingleStateOptions | Options for creating a single state. |
IStateMachine | A State Machine. |
IStateMachineProps | Properties for defining a State Machine. |
IStateProps | Properties shared by all states. |
IStepFunctionsTask | (deprecated) Interface for resources that can be used as tasks. |
IStepFunctionsTaskConfig | (deprecated) Properties that define what kind of task should be created. |
ISucceedProps | Properties for defining a Succeed state. |
ITaskMetricsConfig | Task Metrics. |
ITaskProps | (deprecated) Props that are common to all tasks. |
ITaskStateBaseProps | Props that are common to all tasks. |
IWaitProps | Properties for defining a Wait state. |