sfn

package
v4.36.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 24, 2022 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Activity 

type Activity struct {
	pulumi.CustomResourceState

	// The date the activity was created.
	CreationDate pulumi.StringOutput `pulumi:"creationDate"`
	// The name of the activity to create.
	Name pulumi.StringOutput `pulumi:"name"`
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
}

Provides a Step Function Activity resource

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sfn.NewActivity(ctx, "sfnActivity", nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Activities can be imported using the `arn`, e.g.,

```sh 

$ pulumi import aws:sfn/activity:Activity foo arn:aws:states:eu-west-1:123456789098:activity:bar

```

func GetActivity 

func GetActivity(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ActivityState, opts ...pulumi.ResourceOption) (*Activity, error)

GetActivity gets an existing Activity resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewActivity 

func NewActivity(ctx *pulumi.Context,
	name string, args *ActivityArgs, opts ...pulumi.ResourceOption) (*Activity, error)

NewActivity registers a new resource with the given unique name, arguments, and options.

func (*Activity) ElementType 

func (*Activity) ElementType() reflect.Type

func (*Activity) ToActivityOutput 

func (i *Activity) ToActivityOutput() ActivityOutput

func (*Activity) ToActivityOutputWithContext 

func (i *Activity) ToActivityOutputWithContext(ctx context.Context) ActivityOutput

func (*Activity) ToActivityPtrOutput 

func (i *Activity) ToActivityPtrOutput() ActivityPtrOutput

func (*Activity) ToActivityPtrOutputWithContext 

func (i *Activity) ToActivityPtrOutputWithContext(ctx context.Context) ActivityPtrOutput

type ActivityArgs 

type ActivityArgs struct {
	// The name of the activity to create.
	Name pulumi.StringPtrInput
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Activity resource.

func (ActivityArgs) ElementType 

func (ActivityArgs) ElementType() reflect.Type

type ActivityArray 

type ActivityArray []ActivityInput

func (ActivityArray) ElementType 

func (ActivityArray) ElementType() reflect.Type

func (ActivityArray) ToActivityArrayOutput 

func (i ActivityArray) ToActivityArrayOutput() ActivityArrayOutput

func (ActivityArray) ToActivityArrayOutputWithContext 

func (i ActivityArray) ToActivityArrayOutputWithContext(ctx context.Context) ActivityArrayOutput

type ActivityArrayInput 

type ActivityArrayInput interface {
	pulumi.Input

	ToActivityArrayOutput() ActivityArrayOutput
	ToActivityArrayOutputWithContext(context.Context) ActivityArrayOutput
}

ActivityArrayInput is an input type that accepts ActivityArray and ActivityArrayOutput values. You can construct a concrete instance of `ActivityArrayInput` via: 

ActivityArray{ ActivityArgs{...} }

type ActivityArrayOutput 

type ActivityArrayOutput struct{ *pulumi.OutputState }

func (ActivityArrayOutput) ElementType 

func (ActivityArrayOutput) ElementType() reflect.Type

func (ActivityArrayOutput) Index 

func (o ActivityArrayOutput) Index(i pulumi.IntInput) ActivityOutput

func (ActivityArrayOutput) ToActivityArrayOutput 

func (o ActivityArrayOutput) ToActivityArrayOutput() ActivityArrayOutput

func (ActivityArrayOutput) ToActivityArrayOutputWithContext 

func (o ActivityArrayOutput) ToActivityArrayOutputWithContext(ctx context.Context) ActivityArrayOutput

type ActivityInput 

type ActivityInput interface {
	pulumi.Input

	ToActivityOutput() ActivityOutput
	ToActivityOutputWithContext(ctx context.Context) ActivityOutput
}

type ActivityMap 

type ActivityMap map[string]ActivityInput

func (ActivityMap) ElementType 

func (ActivityMap) ElementType() reflect.Type

func (ActivityMap) ToActivityMapOutput 

func (i ActivityMap) ToActivityMapOutput() ActivityMapOutput

func (ActivityMap) ToActivityMapOutputWithContext 

func (i ActivityMap) ToActivityMapOutputWithContext(ctx context.Context) ActivityMapOutput

type ActivityMapInput 

type ActivityMapInput interface {
	pulumi.Input

	ToActivityMapOutput() ActivityMapOutput
	ToActivityMapOutputWithContext(context.Context) ActivityMapOutput
}

ActivityMapInput is an input type that accepts ActivityMap and ActivityMapOutput values. You can construct a concrete instance of `ActivityMapInput` via: 

ActivityMap{ "key": ActivityArgs{...} }

type ActivityMapOutput 

type ActivityMapOutput struct{ *pulumi.OutputState }

func (ActivityMapOutput) ElementType 

func (ActivityMapOutput) ElementType() reflect.Type

func (ActivityMapOutput) MapIndex 

func (o ActivityMapOutput) MapIndex(k pulumi.StringInput) ActivityOutput

func (ActivityMapOutput) ToActivityMapOutput 

func (o ActivityMapOutput) ToActivityMapOutput() ActivityMapOutput

func (ActivityMapOutput) ToActivityMapOutputWithContext 

func (o ActivityMapOutput) ToActivityMapOutputWithContext(ctx context.Context) ActivityMapOutput

type ActivityOutput 

type ActivityOutput struct{ *pulumi.OutputState }

func (ActivityOutput) ElementType 

func (ActivityOutput) ElementType() reflect.Type

func (ActivityOutput) ToActivityOutput 

func (o ActivityOutput) ToActivityOutput() ActivityOutput

func (ActivityOutput) ToActivityOutputWithContext 

func (o ActivityOutput) ToActivityOutputWithContext(ctx context.Context) ActivityOutput

func (ActivityOutput) ToActivityPtrOutput 

func (o ActivityOutput) ToActivityPtrOutput() ActivityPtrOutput

func (ActivityOutput) ToActivityPtrOutputWithContext 

func (o ActivityOutput) ToActivityPtrOutputWithContext(ctx context.Context) ActivityPtrOutput

type ActivityPtrInput 

type ActivityPtrInput interface {
	pulumi.Input

	ToActivityPtrOutput() ActivityPtrOutput
	ToActivityPtrOutputWithContext(ctx context.Context) ActivityPtrOutput
}

type ActivityPtrOutput 

type ActivityPtrOutput struct{ *pulumi.OutputState }

func (ActivityPtrOutput) Elem added in v4.15.0 

func (o ActivityPtrOutput) Elem() ActivityOutput

func (ActivityPtrOutput) ElementType 

func (ActivityPtrOutput) ElementType() reflect.Type

func (ActivityPtrOutput) ToActivityPtrOutput 

func (o ActivityPtrOutput) ToActivityPtrOutput() ActivityPtrOutput

func (ActivityPtrOutput) ToActivityPtrOutputWithContext 

func (o ActivityPtrOutput) ToActivityPtrOutputWithContext(ctx context.Context) ActivityPtrOutput

type ActivityState 

type ActivityState struct {
	// The date the activity was created.
	CreationDate pulumi.StringPtrInput
	// The name of the activity to create.
	Name pulumi.StringPtrInput
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider .
	TagsAll pulumi.StringMapInput
}

func (ActivityState) ElementType 

func (ActivityState) ElementType() reflect.Type

type LookupActivityArgs 

type LookupActivityArgs struct {
	// The Amazon Resource Name (ARN) that identifies the activity.
	Arn *string `pulumi:"arn"`
	// The name that identifies the activity.
	Name *string `pulumi:"name"`
}

A collection of arguments for invoking getActivity.

type LookupActivityOutputArgs added in v4.21.0 

type LookupActivityOutputArgs struct {
	// The Amazon Resource Name (ARN) that identifies the activity.
	Arn pulumi.StringPtrInput `pulumi:"arn"`
	// The name that identifies the activity.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

A collection of arguments for invoking getActivity.

func (LookupActivityOutputArgs) ElementType added in v4.21.0 

func (LookupActivityOutputArgs) ElementType() reflect.Type

type LookupActivityResult 

type LookupActivityResult struct {
	Arn string `pulumi:"arn"`
	// The date the activity was created.
	CreationDate string `pulumi:"creationDate"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
}

A collection of values returned by getActivity.

func LookupActivity 

func LookupActivity(ctx *pulumi.Context, args *LookupActivityArgs, opts ...pulumi.InvokeOption) (*LookupActivityResult, error)

Provides a Step Functions Activity data source

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		opt0 := "my-activity"
		_, err := sfn.LookupActivity(ctx, &sfn.LookupActivityArgs{
			Name: &opt0,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupActivityResultOutput added in v4.21.0 

type LookupActivityResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getActivity.

func LookupActivityOutput added in v4.21.0 

func LookupActivityOutput(ctx *pulumi.Context, args LookupActivityOutputArgs, opts ...pulumi.InvokeOption) LookupActivityResultOutput

func (LookupActivityResultOutput) Arn added in v4.21.0 

func (o LookupActivityResultOutput) Arn() pulumi.StringOutput

func (LookupActivityResultOutput) CreationDate added in v4.21.0 

func (o LookupActivityResultOutput) CreationDate() pulumi.StringOutput

The date the activity was created.

func (LookupActivityResultOutput) ElementType added in v4.21.0 

func (LookupActivityResultOutput) ElementType() reflect.Type

func (LookupActivityResultOutput) Id added in v4.21.0 

func (o LookupActivityResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupActivityResultOutput) Name added in v4.21.0 

func (o LookupActivityResultOutput) Name() pulumi.StringOutput

func (LookupActivityResultOutput) ToLookupActivityResultOutput added in v4.21.0 

func (o LookupActivityResultOutput) ToLookupActivityResultOutput() LookupActivityResultOutput

func (LookupActivityResultOutput) ToLookupActivityResultOutputWithContext added in v4.21.0 

func (o LookupActivityResultOutput) ToLookupActivityResultOutputWithContext(ctx context.Context) LookupActivityResultOutput

type LookupStateMachineArgs 

type LookupStateMachineArgs struct {
	// The friendly name of the state machine to match.
	Name string `pulumi:"name"`
}

A collection of arguments for invoking getStateMachine.

type LookupStateMachineOutputArgs added in v4.21.0 

type LookupStateMachineOutputArgs struct {
	// The friendly name of the state machine to match.
	Name pulumi.StringInput `pulumi:"name"`
}

A collection of arguments for invoking getStateMachine.

func (LookupStateMachineOutputArgs) ElementType added in v4.21.0 

func (LookupStateMachineOutputArgs) ElementType() reflect.Type

type LookupStateMachineResult 

type LookupStateMachineResult struct {
	// Set to the arn of the state function.
	Arn string `pulumi:"arn"`
	// The date the state machine was created.
	CreationDate string `pulumi:"creationDate"`
	// Set to the state machine definition.
	Definition string `pulumi:"definition"`
	// The provider-assigned unique ID for this managed resource.
	Id   string `pulumi:"id"`
	Name string `pulumi:"name"`
	// Set to the roleArn used by the state function.
	RoleArn string `pulumi:"roleArn"`
	// Set to the current status of the state machine.
	Status string `pulumi:"status"`
}

A collection of values returned by getStateMachine.

func LookupStateMachine 

func LookupStateMachine(ctx *pulumi.Context, args *LookupStateMachineArgs, opts ...pulumi.InvokeOption) (*LookupStateMachineResult, error)

Use this data source to get the ARN of a State Machine in AWS Step Function (SFN). By using this data source, you can reference a state machine without having to hard code the ARNs as input.

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sfn.LookupStateMachine(ctx, &sfn.LookupStateMachineArgs{
			Name: "an_example_sfn_name",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupStateMachineResultOutput added in v4.21.0 

type LookupStateMachineResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getStateMachine.

func LookupStateMachineOutput added in v4.21.0 

func LookupStateMachineOutput(ctx *pulumi.Context, args LookupStateMachineOutputArgs, opts ...pulumi.InvokeOption) LookupStateMachineResultOutput

func (LookupStateMachineResultOutput) Arn added in v4.21.0 

func (o LookupStateMachineResultOutput) Arn() pulumi.StringOutput

Set to the arn of the state function.

func (LookupStateMachineResultOutput) CreationDate added in v4.21.0 

func (o LookupStateMachineResultOutput) CreationDate() pulumi.StringOutput

The date the state machine was created.

func (LookupStateMachineResultOutput) Definition added in v4.21.0 

func (o LookupStateMachineResultOutput) Definition() pulumi.StringOutput

Set to the state machine definition.

func (LookupStateMachineResultOutput) ElementType added in v4.21.0 

func (LookupStateMachineResultOutput) ElementType() reflect.Type

func (LookupStateMachineResultOutput) Id added in v4.21.0 

func (o LookupStateMachineResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupStateMachineResultOutput) Name added in v4.21.0 

func (o LookupStateMachineResultOutput) Name() pulumi.StringOutput

func (LookupStateMachineResultOutput) RoleArn added in v4.21.0 

func (o LookupStateMachineResultOutput) RoleArn() pulumi.StringOutput

Set to the roleArn used by the state function.

func (LookupStateMachineResultOutput) Status added in v4.21.0 

func (o LookupStateMachineResultOutput) Status() pulumi.StringOutput

Set to the current status of the state machine.

func (LookupStateMachineResultOutput) ToLookupStateMachineResultOutput added in v4.21.0 

func (o LookupStateMachineResultOutput) ToLookupStateMachineResultOutput() LookupStateMachineResultOutput

func (LookupStateMachineResultOutput) ToLookupStateMachineResultOutputWithContext added in v4.21.0 

func (o LookupStateMachineResultOutput) ToLookupStateMachineResultOutputWithContext(ctx context.Context) LookupStateMachineResultOutput

type StateMachine 

type StateMachine struct {
	pulumi.CustomResourceState

	// The ARN of the state machine.
	Arn pulumi.StringOutput `pulumi:"arn"`
	// The date the state machine was created.
	CreationDate pulumi.StringOutput `pulumi:"creationDate"`
	// The [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) definition of the state machine.
	Definition pulumi.StringOutput `pulumi:"definition"`
	// Defines what execution history events are logged and where they are logged. The `loggingConfiguration` parameter is only valid when `type` is set to `EXPRESS`. Defaults to `OFF`. For more information see [Logging Express Workflows](https://docs.aws.amazon.com/step-functions/latest/dg/cw-logs.html) and [Log Levels](https://docs.aws.amazon.com/step-functions/latest/dg/cloudwatch-log-level.html) in the AWS Step Functions User Guide.
	LoggingConfiguration StateMachineLoggingConfigurationOutput `pulumi:"loggingConfiguration"`
	// The name of the state machine. To enable logging with CloudWatch Logs, the name should only contain `0`-`9`, `A`-`Z`, `a`-`z`, `-` and `_`.
	Name pulumi.StringOutput `pulumi:"name"`
	// The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
	RoleArn pulumi.StringOutput `pulumi:"roleArn"`
	// The current status of the state machine. Either `ACTIVE` or `DELETING`.
	Status pulumi.StringOutput `pulumi:"status"`
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// A map of tags assigned to the resource, including those inherited from the provider.
	TagsAll pulumi.StringMapOutput `pulumi:"tagsAll"`
	// Selects whether AWS X-Ray tracing is enabled.
	TracingConfiguration StateMachineTracingConfigurationOutput `pulumi:"tracingConfiguration"`
	// 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`.
	Type pulumi.StringPtrOutput `pulumi:"type"`
}

Provides a Step Function State Machine resource

## Example Usage ### Basic (Standard Workflow)

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sfn.NewStateMachine(ctx, "sfnStateMachine", &sfn.StateMachineArgs{
			RoleArn:    pulumi.Any(aws_iam_role.Iam_for_sfn.Arn),
			Definition: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Comment\": \"A Hello World example of the Amazon States Language using an AWS Lambda Function\",\n", "  \"StartAt\": \"HelloWorld\",\n", "  \"States\": {\n", "    \"HelloWorld\": {\n", "      \"Type\": \"Task\",\n", "      \"Resource\": \"", aws_lambda_function.Lambda.Arn, "\",\n", "      \"End\": true\n", "    }\n", "  }\n", "}\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Basic (Express Workflow)

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sfn.NewStateMachine(ctx, "sfnStateMachine", &sfn.StateMachineArgs{
			RoleArn:    pulumi.Any(aws_iam_role.Iam_for_sfn.Arn),
			Type:       pulumi.String("EXPRESS"),
			Definition: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Comment\": \"A Hello World example of the Amazon States Language using an AWS Lambda Function\",\n", "  \"StartAt\": \"HelloWorld\",\n", "  \"States\": {\n", "    \"HelloWorld\": {\n", "      \"Type\": \"Task\",\n", "      \"Resource\": \"", aws_lambda_function.Lambda.Arn, "\",\n", "      \"End\": true\n", "    }\n", "  }\n", "}\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Logging

> *NOTE:* See the [AWS Step Functions Developer Guide](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) for more information about enabling Step Function logging.

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-aws/sdk/v4/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := sfn.NewStateMachine(ctx, "sfnStateMachine", &sfn.StateMachineArgs{
			RoleArn:    pulumi.Any(aws_iam_role.Iam_for_sfn.Arn),
			Definition: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"Comment\": \"A Hello World example of the Amazon States Language using an AWS Lambda Function\",\n", "  \"StartAt\": \"HelloWorld\",\n", "  \"States\": {\n", "    \"HelloWorld\": {\n", "      \"Type\": \"Task\",\n", "      \"Resource\": \"", aws_lambda_function.Lambda.Arn, "\",\n", "      \"End\": true\n", "    }\n", "  }\n", "}\n")),
			LoggingConfiguration: &sfn.StateMachineLoggingConfigurationArgs{
				LogDestination:       pulumi.String(fmt.Sprintf("%v%v", aws_cloudwatch_log_group.Log_group_for_sfn.Arn, ":*")),
				IncludeExecutionData: pulumi.Bool(true),
				Level:                pulumi.String("ERROR"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

State Machines can be imported using the `arn`, e.g.,

```sh 

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

```

func GetStateMachine 

func GetStateMachine(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *StateMachineState, opts ...pulumi.ResourceOption) (*StateMachine, error)

GetStateMachine gets an existing StateMachine resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewStateMachine 

func NewStateMachine(ctx *pulumi.Context,
	name string, args *StateMachineArgs, opts ...pulumi.ResourceOption) (*StateMachine, error)

NewStateMachine registers a new resource with the given unique name, arguments, and options.

func (*StateMachine) ElementType 

func (*StateMachine) ElementType() reflect.Type

func (*StateMachine) ToStateMachineOutput 

func (i *StateMachine) ToStateMachineOutput() StateMachineOutput

func (*StateMachine) ToStateMachineOutputWithContext 

func (i *StateMachine) ToStateMachineOutputWithContext(ctx context.Context) StateMachineOutput

func (*StateMachine) ToStateMachinePtrOutput 

func (i *StateMachine) ToStateMachinePtrOutput() StateMachinePtrOutput

func (*StateMachine) ToStateMachinePtrOutputWithContext 

func (i *StateMachine) ToStateMachinePtrOutputWithContext(ctx context.Context) StateMachinePtrOutput

type StateMachineArgs 

type StateMachineArgs struct {
	// The [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) definition of the state machine.
	Definition pulumi.StringInput
	// Defines what execution history events are logged and where they are logged. The `loggingConfiguration` parameter is only valid when `type` is set to `EXPRESS`. Defaults to `OFF`. For more information see [Logging Express Workflows](https://docs.aws.amazon.com/step-functions/latest/dg/cw-logs.html) and [Log Levels](https://docs.aws.amazon.com/step-functions/latest/dg/cloudwatch-log-level.html) in the AWS Step Functions User Guide.
	LoggingConfiguration StateMachineLoggingConfigurationPtrInput
	// The name of the state machine. To enable logging with CloudWatch Logs, the name should only contain `0`-`9`, `A`-`Z`, `a`-`z`, `-` and `_`.
	Name pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
	RoleArn pulumi.StringInput
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// Selects whether AWS X-Ray tracing is enabled.
	TracingConfiguration StateMachineTracingConfigurationPtrInput
	// 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`.
	Type pulumi.StringPtrInput
}

The set of arguments for constructing a StateMachine resource.

func (StateMachineArgs) ElementType 

func (StateMachineArgs) ElementType() reflect.Type

type StateMachineArray 

type StateMachineArray []StateMachineInput

func (StateMachineArray) ElementType 

func (StateMachineArray) ElementType() reflect.Type

func (StateMachineArray) ToStateMachineArrayOutput 

func (i StateMachineArray) ToStateMachineArrayOutput() StateMachineArrayOutput

func (StateMachineArray) ToStateMachineArrayOutputWithContext 

func (i StateMachineArray) ToStateMachineArrayOutputWithContext(ctx context.Context) StateMachineArrayOutput

type StateMachineArrayInput 

type StateMachineArrayInput interface {
	pulumi.Input

	ToStateMachineArrayOutput() StateMachineArrayOutput
	ToStateMachineArrayOutputWithContext(context.Context) StateMachineArrayOutput
}

StateMachineArrayInput is an input type that accepts StateMachineArray and StateMachineArrayOutput values. You can construct a concrete instance of `StateMachineArrayInput` via: 

StateMachineArray{ StateMachineArgs{...} }

type StateMachineArrayOutput 

type StateMachineArrayOutput struct{ *pulumi.OutputState }

func (StateMachineArrayOutput) ElementType 

func (StateMachineArrayOutput) ElementType() reflect.Type

func (StateMachineArrayOutput) Index 

func (o StateMachineArrayOutput) Index(i pulumi.IntInput) StateMachineOutput

func (StateMachineArrayOutput) ToStateMachineArrayOutput 

func (o StateMachineArrayOutput) ToStateMachineArrayOutput() StateMachineArrayOutput

func (StateMachineArrayOutput) ToStateMachineArrayOutputWithContext 

func (o StateMachineArrayOutput) ToStateMachineArrayOutputWithContext(ctx context.Context) StateMachineArrayOutput

type StateMachineInput 

type StateMachineInput interface {
	pulumi.Input

	ToStateMachineOutput() StateMachineOutput
	ToStateMachineOutputWithContext(ctx context.Context) StateMachineOutput
}

type StateMachineLoggingConfiguration 

type StateMachineLoggingConfiguration struct {
	// Determines whether execution data is included in your log. When set to `false`, data is excluded.
	IncludeExecutionData *bool `pulumi:"includeExecutionData"`
	// Defines which category of execution history events are logged. Valid values: `ALL`, `ERROR`, `FATAL`, `OFF`
	Level *string `pulumi:"level"`
	// Amazon Resource Name (ARN) of a CloudWatch log group. Make sure the State Machine has the correct IAM policies for logging. The ARN must end with `:*`
	LogDestination *string `pulumi:"logDestination"`
}

type StateMachineLoggingConfigurationArgs 

type StateMachineLoggingConfigurationArgs struct {
	// Determines whether execution data is included in your log. When set to `false`, data is excluded.
	IncludeExecutionData pulumi.BoolPtrInput `pulumi:"includeExecutionData"`
	// Defines which category of execution history events are logged. Valid values: `ALL`, `ERROR`, `FATAL`, `OFF`
	Level pulumi.StringPtrInput `pulumi:"level"`
	// Amazon Resource Name (ARN) of a CloudWatch log group. Make sure the State Machine has the correct IAM policies for logging. The ARN must end with `:*`
	LogDestination pulumi.StringPtrInput `pulumi:"logDestination"`
}

func (StateMachineLoggingConfigurationArgs) ElementType 

func (StateMachineLoggingConfigurationArgs) ElementType() reflect.Type

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutput 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutput() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutputWithContext 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutput 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutputWithContext 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationPtrOutput

type StateMachineLoggingConfigurationInput 

type StateMachineLoggingConfigurationInput interface {
	pulumi.Input

	ToStateMachineLoggingConfigurationOutput() StateMachineLoggingConfigurationOutput
	ToStateMachineLoggingConfigurationOutputWithContext(context.Context) StateMachineLoggingConfigurationOutput
}

StateMachineLoggingConfigurationInput is an input type that accepts StateMachineLoggingConfigurationArgs and StateMachineLoggingConfigurationOutput values. You can construct a concrete instance of `StateMachineLoggingConfigurationInput` via: 

StateMachineLoggingConfigurationArgs{...}

type StateMachineLoggingConfigurationOutput 

type StateMachineLoggingConfigurationOutput struct{ *pulumi.OutputState }

func (StateMachineLoggingConfigurationOutput) ElementType 

func (StateMachineLoggingConfigurationOutput) ElementType() reflect.Type

func (StateMachineLoggingConfigurationOutput) IncludeExecutionData 

func (o StateMachineLoggingConfigurationOutput) IncludeExecutionData() pulumi.BoolPtrOutput

Determines whether execution data is included in your log. When set to `false`, data is excluded.

func (StateMachineLoggingConfigurationOutput) Level 

func (o StateMachineLoggingConfigurationOutput) Level() pulumi.StringPtrOutput

Defines which category of execution history events are logged. Valid values: `ALL`, `ERROR`, `FATAL`, `OFF`

func (StateMachineLoggingConfigurationOutput) LogDestination 

func (o StateMachineLoggingConfigurationOutput) LogDestination() pulumi.StringPtrOutput

Amazon Resource Name (ARN) of a CloudWatch log group. Make sure the State Machine has the correct IAM policies for logging. The ARN must end with `:*`

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutput 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutput() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutputWithContext 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutput 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationPtrOutput

type StateMachineLoggingConfigurationPtrInput 

type StateMachineLoggingConfigurationPtrInput interface {
	pulumi.Input

	ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput
	ToStateMachineLoggingConfigurationPtrOutputWithContext(context.Context) StateMachineLoggingConfigurationPtrOutput
}

StateMachineLoggingConfigurationPtrInput is an input type that accepts StateMachineLoggingConfigurationArgs, StateMachineLoggingConfigurationPtr and StateMachineLoggingConfigurationPtrOutput values. You can construct a concrete instance of `StateMachineLoggingConfigurationPtrInput` via: 

        StateMachineLoggingConfigurationArgs{...}

or:

        nil

func StateMachineLoggingConfigurationPtr 

func StateMachineLoggingConfigurationPtr(v *StateMachineLoggingConfigurationArgs) StateMachineLoggingConfigurationPtrInput

type StateMachineLoggingConfigurationPtrOutput 

type StateMachineLoggingConfigurationPtrOutput struct{ *pulumi.OutputState }

func (StateMachineLoggingConfigurationPtrOutput) Elem 

func (o StateMachineLoggingConfigurationPtrOutput) Elem() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationPtrOutput) ElementType 

func (StateMachineLoggingConfigurationPtrOutput) ElementType() reflect.Type

func (StateMachineLoggingConfigurationPtrOutput) IncludeExecutionData 

func (o StateMachineLoggingConfigurationPtrOutput) IncludeExecutionData() pulumi.BoolPtrOutput

Determines whether execution data is included in your log. When set to `false`, data is excluded.

func (StateMachineLoggingConfigurationPtrOutput) Level 

func (o StateMachineLoggingConfigurationPtrOutput) Level() pulumi.StringPtrOutput

Defines which category of execution history events are logged. Valid values: `ALL`, `ERROR`, `FATAL`, `OFF`

func (StateMachineLoggingConfigurationPtrOutput) LogDestination 

func (o StateMachineLoggingConfigurationPtrOutput) LogDestination() pulumi.StringPtrOutput

Amazon Resource Name (ARN) of a CloudWatch log group. Make sure the State Machine has the correct IAM policies for logging. The ARN must end with `:*`

func (StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutput 

func (o StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext 

func (o StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineLoggingConfigurationPtrOutput

type StateMachineMap 

type StateMachineMap map[string]StateMachineInput

func (StateMachineMap) ElementType 

func (StateMachineMap) ElementType() reflect.Type

func (StateMachineMap) ToStateMachineMapOutput 

func (i StateMachineMap) ToStateMachineMapOutput() StateMachineMapOutput

func (StateMachineMap) ToStateMachineMapOutputWithContext 

func (i StateMachineMap) ToStateMachineMapOutputWithContext(ctx context.Context) StateMachineMapOutput

type StateMachineMapInput 

type StateMachineMapInput interface {
	pulumi.Input

	ToStateMachineMapOutput() StateMachineMapOutput
	ToStateMachineMapOutputWithContext(context.Context) StateMachineMapOutput
}

StateMachineMapInput is an input type that accepts StateMachineMap and StateMachineMapOutput values. You can construct a concrete instance of `StateMachineMapInput` via: 

StateMachineMap{ "key": StateMachineArgs{...} }

type StateMachineMapOutput 

type StateMachineMapOutput struct{ *pulumi.OutputState }

func (StateMachineMapOutput) ElementType 

func (StateMachineMapOutput) ElementType() reflect.Type

func (StateMachineMapOutput) MapIndex 

func (o StateMachineMapOutput) MapIndex(k pulumi.StringInput) StateMachineOutput

func (StateMachineMapOutput) ToStateMachineMapOutput 

func (o StateMachineMapOutput) ToStateMachineMapOutput() StateMachineMapOutput

func (StateMachineMapOutput) ToStateMachineMapOutputWithContext 

func (o StateMachineMapOutput) ToStateMachineMapOutputWithContext(ctx context.Context) StateMachineMapOutput

type StateMachineOutput 

type StateMachineOutput struct{ *pulumi.OutputState }

func (StateMachineOutput) ElementType 

func (StateMachineOutput) ElementType() reflect.Type

func (StateMachineOutput) ToStateMachineOutput 

func (o StateMachineOutput) ToStateMachineOutput() StateMachineOutput

func (StateMachineOutput) ToStateMachineOutputWithContext 

func (o StateMachineOutput) ToStateMachineOutputWithContext(ctx context.Context) StateMachineOutput

func (StateMachineOutput) ToStateMachinePtrOutput 

func (o StateMachineOutput) ToStateMachinePtrOutput() StateMachinePtrOutput

func (StateMachineOutput) ToStateMachinePtrOutputWithContext 

func (o StateMachineOutput) ToStateMachinePtrOutputWithContext(ctx context.Context) StateMachinePtrOutput

type StateMachinePtrInput 

type StateMachinePtrInput interface {
	pulumi.Input

	ToStateMachinePtrOutput() StateMachinePtrOutput
	ToStateMachinePtrOutputWithContext(ctx context.Context) StateMachinePtrOutput
}

type StateMachinePtrOutput 

type StateMachinePtrOutput struct{ *pulumi.OutputState }

func (StateMachinePtrOutput) Elem added in v4.15.0 

func (o StateMachinePtrOutput) Elem() StateMachineOutput

func (StateMachinePtrOutput) ElementType 

func (StateMachinePtrOutput) ElementType() reflect.Type

func (StateMachinePtrOutput) ToStateMachinePtrOutput 

func (o StateMachinePtrOutput) ToStateMachinePtrOutput() StateMachinePtrOutput

func (StateMachinePtrOutput) ToStateMachinePtrOutputWithContext 

func (o StateMachinePtrOutput) ToStateMachinePtrOutputWithContext(ctx context.Context) StateMachinePtrOutput

type StateMachineState 

type StateMachineState struct {
	// The ARN of the state machine.
	Arn pulumi.StringPtrInput
	// The date the state machine was created.
	CreationDate pulumi.StringPtrInput
	// The [Amazon States Language](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-amazon-states-language.html) definition of the state machine.
	Definition pulumi.StringPtrInput
	// Defines what execution history events are logged and where they are logged. The `loggingConfiguration` parameter is only valid when `type` is set to `EXPRESS`. Defaults to `OFF`. For more information see [Logging Express Workflows](https://docs.aws.amazon.com/step-functions/latest/dg/cw-logs.html) and [Log Levels](https://docs.aws.amazon.com/step-functions/latest/dg/cloudwatch-log-level.html) in the AWS Step Functions User Guide.
	LoggingConfiguration StateMachineLoggingConfigurationPtrInput
	// The name of the state machine. To enable logging with CloudWatch Logs, the name should only contain `0`-`9`, `A`-`Z`, `a`-`z`, `-` and `_`.
	Name pulumi.StringPtrInput
	// The Amazon Resource Name (ARN) of the IAM role to use for this state machine.
	RoleArn pulumi.StringPtrInput
	// The current status of the state machine. Either `ACTIVE` or `DELETING`.
	Status pulumi.StringPtrInput
	// Key-value map of resource tags. .If configured with a provider `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
	Tags pulumi.StringMapInput
	// A map of tags assigned to the resource, including those inherited from the provider.
	TagsAll pulumi.StringMapInput
	// Selects whether AWS X-Ray tracing is enabled.
	TracingConfiguration StateMachineTracingConfigurationPtrInput
	// 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`.
	Type pulumi.StringPtrInput
}

func (StateMachineState) ElementType 

func (StateMachineState) ElementType() reflect.Type

type StateMachineTracingConfiguration added in v4.3.0 

type StateMachineTracingConfiguration struct {
	// When set to `true`, AWS X-Ray tracing is enabled. Make sure the State Machine has the correct IAM policies for logging. See the [AWS Step Functions Developer Guide](https://docs.aws.amazon.com/step-functions/latest/dg/xray-iam.html) for details.
	Enabled *bool `pulumi:"enabled"`
}

type StateMachineTracingConfigurationArgs added in v4.3.0 

type StateMachineTracingConfigurationArgs struct {
	// When set to `true`, AWS X-Ray tracing is enabled. Make sure the State Machine has the correct IAM policies for logging. See the [AWS Step Functions Developer Guide](https://docs.aws.amazon.com/step-functions/latest/dg/xray-iam.html) for details.
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
}

func (StateMachineTracingConfigurationArgs) ElementType added in v4.3.0 

func (StateMachineTracingConfigurationArgs) ElementType() reflect.Type

func (StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationOutput added in v4.3.0 

func (i StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationOutput() StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationOutputWithContext added in v4.3.0 

func (i StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationOutputWithContext(ctx context.Context) StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationPtrOutput added in v4.3.0 

func (i StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationPtrOutput() StateMachineTracingConfigurationPtrOutput

func (StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationPtrOutputWithContext added in v4.3.0 

func (i StateMachineTracingConfigurationArgs) ToStateMachineTracingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineTracingConfigurationPtrOutput

type StateMachineTracingConfigurationInput added in v4.3.0 

type StateMachineTracingConfigurationInput interface {
	pulumi.Input

	ToStateMachineTracingConfigurationOutput() StateMachineTracingConfigurationOutput
	ToStateMachineTracingConfigurationOutputWithContext(context.Context) StateMachineTracingConfigurationOutput
}

StateMachineTracingConfigurationInput is an input type that accepts StateMachineTracingConfigurationArgs and StateMachineTracingConfigurationOutput values. You can construct a concrete instance of `StateMachineTracingConfigurationInput` via: 

StateMachineTracingConfigurationArgs{...}

type StateMachineTracingConfigurationOutput added in v4.3.0 

type StateMachineTracingConfigurationOutput struct{ *pulumi.OutputState }

func (StateMachineTracingConfigurationOutput) ElementType added in v4.3.0 

func (StateMachineTracingConfigurationOutput) ElementType() reflect.Type

func (StateMachineTracingConfigurationOutput) Enabled added in v4.3.0 

func (o StateMachineTracingConfigurationOutput) Enabled() pulumi.BoolPtrOutput

When set to `true`, AWS X-Ray tracing is enabled. Make sure the State Machine has the correct IAM policies for logging. See the [AWS Step Functions Developer Guide](https://docs.aws.amazon.com/step-functions/latest/dg/xray-iam.html) for details.

func (StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationOutput added in v4.3.0 

func (o StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationOutput() StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationOutputWithContext added in v4.3.0 

func (o StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationOutputWithContext(ctx context.Context) StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationPtrOutput added in v4.3.0 

func (o StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationPtrOutput() StateMachineTracingConfigurationPtrOutput

func (StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationPtrOutputWithContext added in v4.3.0 

func (o StateMachineTracingConfigurationOutput) ToStateMachineTracingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineTracingConfigurationPtrOutput

type StateMachineTracingConfigurationPtrInput added in v4.3.0 

type StateMachineTracingConfigurationPtrInput interface {
	pulumi.Input

	ToStateMachineTracingConfigurationPtrOutput() StateMachineTracingConfigurationPtrOutput
	ToStateMachineTracingConfigurationPtrOutputWithContext(context.Context) StateMachineTracingConfigurationPtrOutput
}

StateMachineTracingConfigurationPtrInput is an input type that accepts StateMachineTracingConfigurationArgs, StateMachineTracingConfigurationPtr and StateMachineTracingConfigurationPtrOutput values. You can construct a concrete instance of `StateMachineTracingConfigurationPtrInput` via: 

        StateMachineTracingConfigurationArgs{...}

or:

        nil

func StateMachineTracingConfigurationPtr added in v4.3.0 

func StateMachineTracingConfigurationPtr(v *StateMachineTracingConfigurationArgs) StateMachineTracingConfigurationPtrInput

type StateMachineTracingConfigurationPtrOutput added in v4.3.0 

type StateMachineTracingConfigurationPtrOutput struct{ *pulumi.OutputState }

func (StateMachineTracingConfigurationPtrOutput) Elem added in v4.3.0 

func (o StateMachineTracingConfigurationPtrOutput) Elem() StateMachineTracingConfigurationOutput

func (StateMachineTracingConfigurationPtrOutput) ElementType added in v4.3.0 

func (StateMachineTracingConfigurationPtrOutput) ElementType() reflect.Type

func (StateMachineTracingConfigurationPtrOutput) Enabled added in v4.3.0 

func (o StateMachineTracingConfigurationPtrOutput) Enabled() pulumi.BoolPtrOutput

When set to `true`, AWS X-Ray tracing is enabled. Make sure the State Machine has the correct IAM policies for logging. See the [AWS Step Functions Developer Guide](https://docs.aws.amazon.com/step-functions/latest/dg/xray-iam.html) for details.

func (StateMachineTracingConfigurationPtrOutput) ToStateMachineTracingConfigurationPtrOutput added in v4.3.0 

func (o StateMachineTracingConfigurationPtrOutput) ToStateMachineTracingConfigurationPtrOutput() StateMachineTracingConfigurationPtrOutput

func (StateMachineTracingConfigurationPtrOutput) ToStateMachineTracingConfigurationPtrOutputWithContext added in v4.3.0 

func (o StateMachineTracingConfigurationPtrOutput) ToStateMachineTracingConfigurationPtrOutputWithContext(ctx context.Context) StateMachineTracingConfigurationPtrOutput

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.