PyPI 官网下载 | aws-cdk.aws-stepfunctions-1.64.0.tar.gz

## AWS Step Functions Construct Library <!--BEGIN STABILITY BANNER-->---   --- <!--END STABILITY BANNER--> 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](https://docs.aws.amazon.com/step-functions/latest/dg/job-status-poller-sample.html)): ### Example ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 import aws_cdk.aws_stepfunctions as sfn import aws_cdk.aws_stepfunctions_tasks as tasks import aws_cdk.aws_lambda as lambda_ submit_lambda = lambda_.Function(self, "SubmitLambda", ...) get_status_lambda = lambda_.Function(self, "CheckLambda", ...) submit_job = tasks.LambdaInvoke(self, "Submit Job", lambda_function=submit_lambda, # Lambda's result is in the attribute `Payload` output_path="$.Payload" ) wait_x = sfn.Wait(self, "Wait X Seconds", time=sfn.WaitTime.seconds_path("$.waitSeconds") ) get_status = tasks.LambdaInvoke(self, "Get Job Status", lambda_function=get_status_lambda, # Pass just the field named "guid" into the Lambda, put the # Lambda's result in a field called "status" in the response input_path="$.guid", output_path="$.Payload" ) job_failed = sfn.Fail(self, "Job Failed", cause="AWS Batch Job Failed", error="DescribeJob returned FAILED" ) final_status = tasks.LambdaInvoke(self, "Get Final Job Status", lambda_function=get_status_lambda, # Use "guid" field as input input_path="$.guid", output_path="$.Payload" ) definition = submit_job.next(wait_x).next(get_status).next(sfn.Choice(self, "Job Complete?").when(sfn.Condition.string_equals("$.status", "FAILED"), job_failed).when(sfn.Condition.string_equals("$.status", "SUCCEEDED"), final_status).otherwise(wait_x)) sfn.StateMachine(self, "StateMachine", 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: ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 start_state = stepfunctions.Pass(self, "StartState") stepfunctions.StateMachine(self, "StateMachine", definition=start_state ) ``` 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. ## Amazon States Language This library comes with a set of classes that model the [Amazon States Language](https://states-language.net/spec.html). The following State classes are supported: * [`Task`](#task) * [`Pass`](#pass) * [`Wait`](#wait) * [`Choice`](#choice) * [`Parallel`](#parallel) * [`Succeed`](#succeed) * [`Fail`](#fail) * [`Map`](#map) * [`Custom State`](#custom-state) 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](https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html) 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. ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 # Makes the current JSON state { ..., "subObject": { "hello": "world" } } pass = stepfunctions.Pass(self, "Add Hello World", result=stepfunctions.Result.from_object(hello="world"), result_path="$.subObject" ) # Set the next state pass.next(next_state) ``` 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`. ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 pass = stepfunctions.Pass(self, "Filter input and inject data", parameters={# input to the pass state "input": stepfunctions.JsonPath.string_at("$.input.greeting"), "other_data": "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](https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-pass-state.html) ### 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. ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 # Wait until it's the time mentioned in the the state object's "triggerTime" # field. wait = stepfunctions.Wait(self, "Wait For Trigger Time", time=stepfunctions.WaitTime.timestamp_path("$.triggerTime") ) # Set the next state wait.next(start_the_work) ``` ### Choice A `Choice` state can take a different path through the workflow based on the values in the execution's JSON state: ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 choice = stepfunctions.Choice(self, "Did it work?") # Add conditions with .when() choice.when(stepfunctions.Condition.string_equal("$.status", "SUCCESS"), success_state) choice.when(stepfunctions.Condition.number_greater_than("$.attempts", 5), failure_state) # Use .otherwise() to indicate what should be done if none of the conditions match choice.otherwise(try_again_state) ``` 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: ```python # Example automatically generated without compilation. See https://github.com/aws/jsii/issues/826 choice = stepfunctions.Choice(self, "What color is it?") choice.when(stepfunctions.Condition.string_equal("$.color", "BLUE"), handle_blue_item) choice.when(stepfunctions.Condition.string_equal("$.color", "RED"), handle_red_item) choice.otherwise(handle_other_item_color) # Use .afterwards() to join all possible paths back together and continue choice.afterwards().next(ship_the_item) ``` 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 m