sfn

package
v3.38.1 Latest Latest
Warning

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

 Go to latest Published: Apr 13, 2021 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
	Tags pulumi.StringMapOutput `pulumi:"tags"`
}

Provides a Step Function Activity resource

## Example Usage

```go package main

import ( 

"github.com/pulumi/pulumi-aws/sdk/v3/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.13.0 

func (*Activity) ElementType() reflect.Type

func (*Activity) ToActivityOutput added in v3.13.0 

func (i *Activity) ToActivityOutput() ActivityOutput

func (*Activity) ToActivityOutputWithContext added in v3.13.0 

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

func (*Activity) ToActivityPtrOutput added in v3.25.0 

func (i *Activity) ToActivityPtrOutput() ActivityPtrOutput

func (*Activity) ToActivityPtrOutputWithContext added in v3.25.0 

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
	Tags pulumi.StringMapInput
}

The set of arguments for constructing a Activity resource.

func (ActivityArgs) ElementType 

func (ActivityArgs) ElementType() reflect.Type

type ActivityArray added in v3.25.0 

type ActivityArray []ActivityInput

func (ActivityArray) ElementType added in v3.25.0 

func (ActivityArray) ElementType() reflect.Type

func (ActivityArray) ToActivityArrayOutput added in v3.25.0 

func (i ActivityArray) ToActivityArrayOutput() ActivityArrayOutput

func (ActivityArray) ToActivityArrayOutputWithContext added in v3.25.0 

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

type ActivityArrayInput added in v3.25.0 

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 added in v3.25.0 

type ActivityArrayOutput struct{ *pulumi.OutputState }

func (ActivityArrayOutput) ElementType added in v3.25.0 

func (ActivityArrayOutput) ElementType() reflect.Type

func (ActivityArrayOutput) Index added in v3.25.0 

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

func (ActivityArrayOutput) ToActivityArrayOutput added in v3.25.0 

func (o ActivityArrayOutput) ToActivityArrayOutput() ActivityArrayOutput

func (ActivityArrayOutput) ToActivityArrayOutputWithContext added in v3.25.0 

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

type ActivityInput added in v3.13.0 

type ActivityInput interface {
	pulumi.Input

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

type ActivityMap added in v3.25.0 

type ActivityMap map[string]ActivityInput

func (ActivityMap) ElementType added in v3.25.0 

func (ActivityMap) ElementType() reflect.Type

func (ActivityMap) ToActivityMapOutput added in v3.25.0 

func (i ActivityMap) ToActivityMapOutput() ActivityMapOutput

func (ActivityMap) ToActivityMapOutputWithContext added in v3.25.0 

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

type ActivityMapInput added in v3.25.0 

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 added in v3.25.0 

type ActivityMapOutput struct{ *pulumi.OutputState }

func (ActivityMapOutput) ElementType added in v3.25.0 

func (ActivityMapOutput) ElementType() reflect.Type

func (ActivityMapOutput) MapIndex added in v3.25.0 

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

func (ActivityMapOutput) ToActivityMapOutput added in v3.25.0 

func (o ActivityMapOutput) ToActivityMapOutput() ActivityMapOutput

func (ActivityMapOutput) ToActivityMapOutputWithContext added in v3.25.0 

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

type ActivityOutput added in v3.13.0 

type ActivityOutput struct {
	*pulumi.OutputState
}

func (ActivityOutput) ElementType added in v3.13.0 

func (ActivityOutput) ElementType() reflect.Type

func (ActivityOutput) ToActivityOutput added in v3.13.0 

func (o ActivityOutput) ToActivityOutput() ActivityOutput

func (ActivityOutput) ToActivityOutputWithContext added in v3.13.0 

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

func (ActivityOutput) ToActivityPtrOutput added in v3.25.0 

func (o ActivityOutput) ToActivityPtrOutput() ActivityPtrOutput

func (ActivityOutput) ToActivityPtrOutputWithContext added in v3.25.0 

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

type ActivityPtrInput added in v3.25.0 

type ActivityPtrInput interface {
	pulumi.Input

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

type ActivityPtrOutput added in v3.25.0 

type ActivityPtrOutput struct {
	*pulumi.OutputState
}

func (ActivityPtrOutput) ElementType added in v3.25.0 

func (ActivityPtrOutput) ElementType() reflect.Type

func (ActivityPtrOutput) ToActivityPtrOutput added in v3.25.0 

func (o ActivityPtrOutput) ToActivityPtrOutput() ActivityPtrOutput

func (ActivityPtrOutput) ToActivityPtrOutputWithContext added in v3.25.0 

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
	Tags 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 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/v3/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v2/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 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 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/v3/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v2/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 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 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.
	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
	Tags pulumi.StringMapOutput `pulumi:"tags"`
	// 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/v3/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v2/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/v3/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v2/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/v3/go/aws/sfn"
"github.com/pulumi/pulumi/sdk/v2/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 added in v3.13.0 

func (*StateMachine) ElementType() reflect.Type

func (*StateMachine) ToStateMachineOutput added in v3.13.0 

func (i *StateMachine) ToStateMachineOutput() StateMachineOutput

func (*StateMachine) ToStateMachineOutputWithContext added in v3.13.0 

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

func (*StateMachine) ToStateMachinePtrOutput added in v3.25.0 

func (i *StateMachine) ToStateMachinePtrOutput() StateMachinePtrOutput

func (*StateMachine) ToStateMachinePtrOutputWithContext added in v3.25.0 

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

type StateMachineArgs 

type StateMachineArgs struct {
	// The Amazon States Language 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.
	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
	Tags pulumi.StringMapInput
	// 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 added in v3.25.0 

type StateMachineArray []StateMachineInput

func (StateMachineArray) ElementType added in v3.25.0 

func (StateMachineArray) ElementType() reflect.Type

func (StateMachineArray) ToStateMachineArrayOutput added in v3.25.0 

func (i StateMachineArray) ToStateMachineArrayOutput() StateMachineArrayOutput

func (StateMachineArray) ToStateMachineArrayOutputWithContext added in v3.25.0 

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

type StateMachineArrayInput added in v3.25.0 

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 added in v3.25.0 

type StateMachineArrayOutput struct{ *pulumi.OutputState }

func (StateMachineArrayOutput) ElementType added in v3.25.0 

func (StateMachineArrayOutput) ElementType() reflect.Type

func (StateMachineArrayOutput) Index added in v3.25.0 

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

func (StateMachineArrayOutput) ToStateMachineArrayOutput added in v3.25.0 

func (o StateMachineArrayOutput) ToStateMachineArrayOutput() StateMachineArrayOutput

func (StateMachineArrayOutput) ToStateMachineArrayOutputWithContext added in v3.25.0 

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

type StateMachineInput added in v3.13.0 

type StateMachineInput interface {
	pulumi.Input

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

type StateMachineLoggingConfiguration added in v3.28.0 

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 CloudWatch log group. Make sure the State Machine does have the right IAM Policies for Logging. The ARN must end with `:*`
	LogDestination *string `pulumi:"logDestination"`
}

type StateMachineLoggingConfigurationArgs added in v3.28.0 

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 CloudWatch log group. Make sure the State Machine does have the right IAM Policies for Logging. The ARN must end with `:*`
	LogDestination pulumi.StringPtrInput `pulumi:"logDestination"`
}

func (StateMachineLoggingConfigurationArgs) ElementType added in v3.28.0 

func (StateMachineLoggingConfigurationArgs) ElementType() reflect.Type

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutput added in v3.28.0 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutput() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationOutputWithContext added in v3.28.0 

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

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutput added in v3.28.0 

func (i StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationArgs) ToStateMachineLoggingConfigurationPtrOutputWithContext added in v3.28.0 

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

type StateMachineLoggingConfigurationInput added in v3.28.0 

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 added in v3.28.0 

type StateMachineLoggingConfigurationOutput struct{ *pulumi.OutputState }

func (StateMachineLoggingConfigurationOutput) ElementType added in v3.28.0 

func (StateMachineLoggingConfigurationOutput) ElementType() reflect.Type

func (StateMachineLoggingConfigurationOutput) IncludeExecutionData added in v3.28.0 

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 added in v3.28.0 

func (o StateMachineLoggingConfigurationOutput) Level() pulumi.StringPtrOutput

Defines which category of execution history events are logged. Valid Values: ALL | ERROR | FATAL | OFF

func (StateMachineLoggingConfigurationOutput) LogDestination added in v3.28.0 

func (o StateMachineLoggingConfigurationOutput) LogDestination() pulumi.StringPtrOutput

Amazon Resource Name (ARN) of CloudWatch log group. Make sure the State Machine does have the right IAM Policies for Logging. The ARN must end with `:*`

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutput added in v3.28.0 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutput() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationOutputWithContext added in v3.28.0 

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

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutput added in v3.28.0 

func (o StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext added in v3.28.0 

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

type StateMachineLoggingConfigurationPtrInput added in v3.28.0 

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 added in v3.28.0 

func StateMachineLoggingConfigurationPtr(v *StateMachineLoggingConfigurationArgs) StateMachineLoggingConfigurationPtrInput

type StateMachineLoggingConfigurationPtrOutput added in v3.28.0 

type StateMachineLoggingConfigurationPtrOutput struct{ *pulumi.OutputState }

func (StateMachineLoggingConfigurationPtrOutput) Elem added in v3.28.0 

func (o StateMachineLoggingConfigurationPtrOutput) Elem() StateMachineLoggingConfigurationOutput

func (StateMachineLoggingConfigurationPtrOutput) ElementType added in v3.28.0 

func (StateMachineLoggingConfigurationPtrOutput) ElementType() reflect.Type

func (StateMachineLoggingConfigurationPtrOutput) IncludeExecutionData added in v3.28.0 

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 added in v3.28.0 

func (o StateMachineLoggingConfigurationPtrOutput) Level() pulumi.StringPtrOutput

Defines which category of execution history events are logged. Valid Values: ALL | ERROR | FATAL | OFF

func (StateMachineLoggingConfigurationPtrOutput) LogDestination added in v3.28.0 

func (o StateMachineLoggingConfigurationPtrOutput) LogDestination() pulumi.StringPtrOutput

Amazon Resource Name (ARN) of CloudWatch log group. Make sure the State Machine does have the right IAM Policies for Logging. The ARN must end with `:*`

func (StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutput added in v3.28.0 

func (o StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutput() StateMachineLoggingConfigurationPtrOutput

func (StateMachineLoggingConfigurationPtrOutput) ToStateMachineLoggingConfigurationPtrOutputWithContext added in v3.28.0 

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

type StateMachineMap added in v3.25.0 

type StateMachineMap map[string]StateMachineInput

func (StateMachineMap) ElementType added in v3.25.0 

func (StateMachineMap) ElementType() reflect.Type

func (StateMachineMap) ToStateMachineMapOutput added in v3.25.0 

func (i StateMachineMap) ToStateMachineMapOutput() StateMachineMapOutput

func (StateMachineMap) ToStateMachineMapOutputWithContext added in v3.25.0 

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

type StateMachineMapInput added in v3.25.0 

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 added in v3.25.0 

type StateMachineMapOutput struct{ *pulumi.OutputState }

func (StateMachineMapOutput) ElementType added in v3.25.0 

func (StateMachineMapOutput) ElementType() reflect.Type

func (StateMachineMapOutput) MapIndex added in v3.25.0 

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

func (StateMachineMapOutput) ToStateMachineMapOutput added in v3.25.0 

func (o StateMachineMapOutput) ToStateMachineMapOutput() StateMachineMapOutput

func (StateMachineMapOutput) ToStateMachineMapOutputWithContext added in v3.25.0 

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

type StateMachineOutput added in v3.13.0 

type StateMachineOutput struct {
	*pulumi.OutputState
}

func (StateMachineOutput) ElementType added in v3.13.0 

func (StateMachineOutput) ElementType() reflect.Type

func (StateMachineOutput) ToStateMachineOutput added in v3.13.0 

func (o StateMachineOutput) ToStateMachineOutput() StateMachineOutput

func (StateMachineOutput) ToStateMachineOutputWithContext added in v3.13.0 

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

func (StateMachineOutput) ToStateMachinePtrOutput added in v3.25.0 

func (o StateMachineOutput) ToStateMachinePtrOutput() StateMachinePtrOutput

func (StateMachineOutput) ToStateMachinePtrOutputWithContext added in v3.25.0 

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

type StateMachinePtrInput added in v3.25.0 

type StateMachinePtrInput interface {
	pulumi.Input

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

type StateMachinePtrOutput added in v3.25.0 

type StateMachinePtrOutput struct {
	*pulumi.OutputState
}

func (StateMachinePtrOutput) ElementType added in v3.25.0 

func (StateMachinePtrOutput) ElementType() reflect.Type

func (StateMachinePtrOutput) ToStateMachinePtrOutput added in v3.25.0 

func (o StateMachinePtrOutput) ToStateMachinePtrOutput() StateMachinePtrOutput

func (StateMachinePtrOutput) ToStateMachinePtrOutputWithContext added in v3.25.0 

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 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.
	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
	Tags pulumi.StringMapInput
	// 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

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.