ecs

package
v0.104.0 Latest Latest
Warning

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

 Go to latest Published: Apr 30, 2024 License: Apache-2.0 Imports: 8 Imported by: 2

Documentation

Index

Constants

View Source 
const (
	CapacityProviderAutoScalingGroupProviderManagedDrainingDisabled = CapacityProviderAutoScalingGroupProviderManagedDraining("DISABLED")
	CapacityProviderAutoScalingGroupProviderManagedDrainingEnabled  = CapacityProviderAutoScalingGroupProviderManagedDraining("ENABLED")
)
View Source 
const (
	CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionDisabled = CapacityProviderAutoScalingGroupProviderManagedTerminationProtection("DISABLED")
	CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionEnabled  = CapacityProviderAutoScalingGroupProviderManagedTerminationProtection("ENABLED")
)
View Source 
const (
	CapacityProviderManagedScalingStatusDisabled = CapacityProviderManagedScalingStatus("DISABLED")
	CapacityProviderManagedScalingStatusEnabled  = CapacityProviderManagedScalingStatus("ENABLED")
)
View Source 
const (
	ClusterCapacityProviderAssociationsCapacityProviderFargate     = ClusterCapacityProviderAssociationsCapacityProvider("FARGATE")
	ClusterCapacityProviderAssociationsCapacityProviderFargateSpot = ClusterCapacityProviderAssociationsCapacityProvider("FARGATE_SPOT")
)
View Source 
const (
	ClusterCapacityProviderAssociationsCapacityProvider0Fargate     = ClusterCapacityProviderAssociationsCapacityProvider0("FARGATE")
	ClusterCapacityProviderAssociationsCapacityProvider0FargateSpot = ClusterCapacityProviderAssociationsCapacityProvider0("FARGATE_SPOT")
)
View Source 
const (
	ServiceAwsVpcConfigurationAssignPublicIpDisabled = ServiceAwsVpcConfigurationAssignPublicIp("DISABLED")
	ServiceAwsVpcConfigurationAssignPublicIpEnabled  = ServiceAwsVpcConfigurationAssignPublicIp("ENABLED")
)
View Source 
const (
	ServiceDeploymentControllerTypeCodeDeploy = ServiceDeploymentControllerType("CODE_DEPLOY")
	ServiceDeploymentControllerTypeEcs        = ServiceDeploymentControllerType("ECS")
	ServiceDeploymentControllerTypeExternal   = ServiceDeploymentControllerType("EXTERNAL")
)
View Source 
const (
	ServiceEbsTagSpecificationPropagateTagsService        = ServiceEbsTagSpecificationPropagateTags("SERVICE")
	ServiceEbsTagSpecificationPropagateTagsTaskDefinition = ServiceEbsTagSpecificationPropagateTags("TASK_DEFINITION")
)
View Source 
const (
	ServiceLaunchTypeEc2      = ServiceLaunchType("EC2")
	ServiceLaunchTypeFargate  = ServiceLaunchType("FARGATE")
	ServiceLaunchTypeExternal = ServiceLaunchType("EXTERNAL")
)
View Source 
const (
	ServicePlacementConstraintTypeDistinctInstance = ServicePlacementConstraintType("distinctInstance")
	ServicePlacementConstraintTypeMemberOf         = ServicePlacementConstraintType("memberOf")
)
View Source 
const (
	ServicePlacementStrategyTypeBinpack = ServicePlacementStrategyType("binpack")
	ServicePlacementStrategyTypeRandom  = ServicePlacementStrategyType("random")
	ServicePlacementStrategyTypeSpread  = ServicePlacementStrategyType("spread")
)
View Source 
const (
	ServicePropagateTagsService        = ServicePropagateTags("SERVICE")
	ServicePropagateTagsTaskDefinition = ServicePropagateTags("TASK_DEFINITION")
)
View Source 
const (
	ServiceSchedulingStrategyDaemon  = ServiceSchedulingStrategy("DAEMON")
	ServiceSchedulingStrategyReplica = ServiceSchedulingStrategy("REPLICA")
)
View Source 
const (
	TaskDefinitionAuthorizationConfigIamEnabled  = TaskDefinitionAuthorizationConfigIam("ENABLED")
	TaskDefinitionAuthorizationConfigIamDisabled = TaskDefinitionAuthorizationConfigIam("DISABLED")
)
View Source 
const (
	TaskDefinitionEfsVolumeConfigurationTransitEncryptionEnabled  = TaskDefinitionEfsVolumeConfigurationTransitEncryption("ENABLED")
	TaskDefinitionEfsVolumeConfigurationTransitEncryptionDisabled = TaskDefinitionEfsVolumeConfigurationTransitEncryption("DISABLED")
)
View Source 
const (
	TaskDefinitionPortMappingAppProtocolHttp  = TaskDefinitionPortMappingAppProtocol("http")
	TaskDefinitionPortMappingAppProtocolHttp2 = TaskDefinitionPortMappingAppProtocol("http2")
	TaskDefinitionPortMappingAppProtocolGrpc  = TaskDefinitionPortMappingAppProtocol("grpc")
)
View Source 
const (
	TaskSetAwsVpcConfigurationAssignPublicIpDisabled = TaskSetAwsVpcConfigurationAssignPublicIp("DISABLED")
	TaskSetAwsVpcConfigurationAssignPublicIpEnabled  = TaskSetAwsVpcConfigurationAssignPublicIp("ENABLED")
)
View Source 
const (
	TaskSetLaunchTypeEc2     = TaskSetLaunchType("EC2")
	TaskSetLaunchTypeFargate = TaskSetLaunchType("FARGATE")
)
View Source 
const (
	TaskSetScaleUnitPercent = TaskSetScaleUnit("PERCENT")
)

Variables

This section is empty.

Functions

This section is empty.

Types

type CapacityProvider 

type CapacityProvider struct {
	pulumi.CustomResourceState

	AutoScalingGroupProvider CapacityProviderAutoScalingGroupProviderOutput `pulumi:"autoScalingGroupProvider"`
	Name                     pulumi.StringPtrOutput                         `pulumi:"name"`
	Tags                     aws.TagArrayOutput                             `pulumi:"tags"`
}

Resource Type definition for AWS::ECS::CapacityProvider.

## Example Usage ### Example

```go package main

import ( 

awsnative "github.com/pulumi/pulumi-aws-native/sdk/go/aws"
"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecs.NewCapacityProvider(ctx, "myCapacityProvider", &ecs.CapacityProviderArgs{
			AutoScalingGroupProvider: &ecs.CapacityProviderAutoScalingGroupProviderArgs{
				AutoScalingGroupArn: pulumi.String("arn:aws:autoscaling:us-west-2:123456789012:autoScalingGroup:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111:autoScalingGroupName/MyAutoScalingGroup"),
				ManagedScaling: &ecs.CapacityProviderManagedScalingArgs{
					MaximumScalingStepSize: pulumi.Int(10),
					MinimumScalingStepSize: pulumi.Int(1),
					Status:                 ecs.CapacityProviderManagedScalingStatusEnabled,
					TargetCapacity:         pulumi.Int(100),
				},
				ManagedTerminationProtection: ecs.CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionEnabled,
			},
			Tags: aws.TagArray{
				&aws.TagArgs{
					Key:   pulumi.String("environment"),
					Value: pulumi.String("production"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example

```go package main

import ( 

awsnative "github.com/pulumi/pulumi-aws-native/sdk/go/aws"
"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecs.NewCapacityProvider(ctx, "myCapacityProvider", &ecs.CapacityProviderArgs{
			AutoScalingGroupProvider: &ecs.CapacityProviderAutoScalingGroupProviderArgs{
				AutoScalingGroupArn: pulumi.String("arn:aws:autoscaling:us-west-2:123456789012:autoScalingGroup:a1b2c3d4-5678-90ab-cdef-EXAMPLE11111:autoScalingGroupName/MyAutoScalingGroup"),
				ManagedScaling: &ecs.CapacityProviderManagedScalingArgs{
					MaximumScalingStepSize: pulumi.Int(10),
					MinimumScalingStepSize: pulumi.Int(1),
					Status:                 ecs.CapacityProviderManagedScalingStatusEnabled,
					TargetCapacity:         pulumi.Int(100),
				},
				ManagedTerminationProtection: ecs.CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionEnabled,
			},
			Tags: aws.TagArray{
				&aws.TagArgs{
					Key:   pulumi.String("environment"),
					Value: pulumi.String("production"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		autoScalingGroupArn1 := cfg.Require("autoScalingGroupArn1")
		autoScalingGroupArn2 := cfg.Require("autoScalingGroupArn2")
		capacityProvider1, err := ecs.NewCapacityProvider(ctx, "capacityProvider1", &ecs.CapacityProviderArgs{
			AutoScalingGroupProvider: &ecs.CapacityProviderAutoScalingGroupProviderArgs{
				AutoScalingGroupArn: pulumi.String(autoScalingGroupArn1),
				ManagedScaling: &ecs.CapacityProviderManagedScalingArgs{
					Status: ecs.CapacityProviderManagedScalingStatusEnabled,
				},
				ManagedTerminationProtection: ecs.CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionDisabled,
			},
		})
		if err != nil {
			return err
		}
		capacityProvider2, err := ecs.NewCapacityProvider(ctx, "capacityProvider2", &ecs.CapacityProviderArgs{
			AutoScalingGroupProvider: &ecs.CapacityProviderAutoScalingGroupProviderArgs{
				AutoScalingGroupArn: pulumi.String(autoScalingGroupArn2),
				ManagedScaling: &ecs.CapacityProviderManagedScalingArgs{
					Status: ecs.CapacityProviderManagedScalingStatusEnabled,
				},
				ManagedTerminationProtection: ecs.CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionDisabled,
			},
		})
		if err != nil {
			return err
		}
		cluster, err := ecs.NewCluster(ctx, "cluster", nil)
		if err != nil {
			return err
		}
		_, err = ecs.NewClusterCapacityProviderAssociations(ctx, "clusterCPAssociation", &ecs.ClusterCapacityProviderAssociationsArgs{
			Cluster: cluster.ID(),
			CapacityProviders: pulumi.StringArray{
				capacityProvider1.ID(),
				capacityProvider2.ID(),
			},
			DefaultCapacityProviderStrategy: ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArray{
				&ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{
					Base:             pulumi.Int(2),
					Weight:           pulumi.Int(6),
					CapacityProvider: capacityProvider1.ID(),
				},
				&ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{
					Base:             pulumi.Int(0),
					Weight:           pulumi.Int(10),
					CapacityProvider: capacityProvider2.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		autoScalingGroupArn1 := cfg.Require("autoScalingGroupArn1")
		autoScalingGroupArn2 := cfg.Require("autoScalingGroupArn2")
		capacityProvider1, err := ecs.NewCapacityProvider(ctx, "capacityProvider1", &ecs.CapacityProviderArgs{
			AutoScalingGroupProvider: &ecs.CapacityProviderAutoScalingGroupProviderArgs{
				AutoScalingGroupArn: pulumi.String(autoScalingGroupArn1),
				ManagedScaling: &ecs.CapacityProviderManagedScalingArgs{
					Status: ecs.CapacityProviderManagedScalingStatusEnabled,
				},
				ManagedTerminationProtection: ecs.CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionDisabled,
			},
		})
		if err != nil {
			return err
		}
		capacityProvider2, err := ecs.NewCapacityProvider(ctx, "capacityProvider2", &ecs.CapacityProviderArgs{
			AutoScalingGroupProvider: &ecs.CapacityProviderAutoScalingGroupProviderArgs{
				AutoScalingGroupArn: pulumi.String(autoScalingGroupArn2),
				ManagedScaling: &ecs.CapacityProviderManagedScalingArgs{
					Status: ecs.CapacityProviderManagedScalingStatusEnabled,
				},
				ManagedTerminationProtection: ecs.CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionDisabled,
			},
		})
		if err != nil {
			return err
		}
		cluster, err := ecs.NewCluster(ctx, "cluster", nil)
		if err != nil {
			return err
		}
		_, err = ecs.NewClusterCapacityProviderAssociations(ctx, "clusterCPAssociation", &ecs.ClusterCapacityProviderAssociationsArgs{
			Cluster: cluster.ID(),
			CapacityProviders: pulumi.StringArray{
				capacityProvider1.ID(),
				capacityProvider2.ID(),
			},
			DefaultCapacityProviderStrategy: ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArray{
				&ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{
					Base:             pulumi.Int(2),
					Weight:           pulumi.Int(6),
					CapacityProvider: capacityProvider1.ID(),
				},
				&ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{
					Base:             pulumi.Int(0),
					Weight:           pulumi.Int(10),
					CapacityProvider: capacityProvider2.ID(),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetCapacityProvider 

func GetCapacityProvider(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *CapacityProviderState, opts ...pulumi.ResourceOption) (*CapacityProvider, error)

GetCapacityProvider gets an existing CapacityProvider 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 NewCapacityProvider 

func NewCapacityProvider(ctx *pulumi.Context,
	name string, args *CapacityProviderArgs, opts ...pulumi.ResourceOption) (*CapacityProvider, error)

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

func (*CapacityProvider) ElementType 

func (*CapacityProvider) ElementType() reflect.Type

func (*CapacityProvider) ToCapacityProviderOutput 

func (i *CapacityProvider) ToCapacityProviderOutput() CapacityProviderOutput

func (*CapacityProvider) ToCapacityProviderOutputWithContext 

func (i *CapacityProvider) ToCapacityProviderOutputWithContext(ctx context.Context) CapacityProviderOutput

type CapacityProviderArgs 

type CapacityProviderArgs struct {
	AutoScalingGroupProvider CapacityProviderAutoScalingGroupProviderInput
	Name                     pulumi.StringPtrInput
	Tags                     aws.TagArrayInput
}

The set of arguments for constructing a CapacityProvider resource.

func (CapacityProviderArgs) ElementType 

func (CapacityProviderArgs) ElementType() reflect.Type

type CapacityProviderAutoScalingGroupProvider 

type CapacityProviderAutoScalingGroupProvider struct {
	AutoScalingGroupArn          string                                                                `pulumi:"autoScalingGroupArn"`
	ManagedDraining              *CapacityProviderAutoScalingGroupProviderManagedDraining              `pulumi:"managedDraining"`
	ManagedScaling               *CapacityProviderManagedScaling                                       `pulumi:"managedScaling"`
	ManagedTerminationProtection *CapacityProviderAutoScalingGroupProviderManagedTerminationProtection `pulumi:"managedTerminationProtection"`
}

type CapacityProviderAutoScalingGroupProviderArgs 

type CapacityProviderAutoScalingGroupProviderArgs struct {
	AutoScalingGroupArn          pulumi.StringInput                                                           `pulumi:"autoScalingGroupArn"`
	ManagedDraining              CapacityProviderAutoScalingGroupProviderManagedDrainingPtrInput              `pulumi:"managedDraining"`
	ManagedScaling               CapacityProviderManagedScalingPtrInput                                       `pulumi:"managedScaling"`
	ManagedTerminationProtection CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrInput `pulumi:"managedTerminationProtection"`
}

func (CapacityProviderAutoScalingGroupProviderArgs) ElementType 

func (CapacityProviderAutoScalingGroupProviderArgs) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderArgs) ToCapacityProviderAutoScalingGroupProviderOutput 

func (i CapacityProviderAutoScalingGroupProviderArgs) ToCapacityProviderAutoScalingGroupProviderOutput() CapacityProviderAutoScalingGroupProviderOutput

func (CapacityProviderAutoScalingGroupProviderArgs) ToCapacityProviderAutoScalingGroupProviderOutputWithContext 

func (i CapacityProviderAutoScalingGroupProviderArgs) ToCapacityProviderAutoScalingGroupProviderOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderOutput

type CapacityProviderAutoScalingGroupProviderInput 

type CapacityProviderAutoScalingGroupProviderInput interface {
	pulumi.Input

	ToCapacityProviderAutoScalingGroupProviderOutput() CapacityProviderAutoScalingGroupProviderOutput
	ToCapacityProviderAutoScalingGroupProviderOutputWithContext(context.Context) CapacityProviderAutoScalingGroupProviderOutput
}

CapacityProviderAutoScalingGroupProviderInput is an input type that accepts CapacityProviderAutoScalingGroupProviderArgs and CapacityProviderAutoScalingGroupProviderOutput values. You can construct a concrete instance of `CapacityProviderAutoScalingGroupProviderInput` via: 

CapacityProviderAutoScalingGroupProviderArgs{...}

type CapacityProviderAutoScalingGroupProviderManagedDraining added in v0.91.0 

type CapacityProviderAutoScalingGroupProviderManagedDraining string

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ElementType added in v0.91.0 

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutput added in v0.91.0 

func (e CapacityProviderAutoScalingGroupProviderManagedDraining) ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutput() CapacityProviderAutoScalingGroupProviderManagedDrainingOutput

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutputWithContext added in v0.91.0 

func (e CapacityProviderAutoScalingGroupProviderManagedDraining) ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedDrainingOutput

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput added in v0.91.0 

func (e CapacityProviderAutoScalingGroupProviderManagedDraining) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput() CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutputWithContext added in v0.91.0 

func (e CapacityProviderAutoScalingGroupProviderManagedDraining) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ToStringOutput added in v0.91.0 

func (e CapacityProviderAutoScalingGroupProviderManagedDraining) ToStringOutput() pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ToStringOutputWithContext added in v0.91.0 

func (e CapacityProviderAutoScalingGroupProviderManagedDraining) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ToStringPtrOutput added in v0.91.0 

func (e CapacityProviderAutoScalingGroupProviderManagedDraining) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDraining) ToStringPtrOutputWithContext added in v0.91.0 

func (e CapacityProviderAutoScalingGroupProviderManagedDraining) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderAutoScalingGroupProviderManagedDrainingInput added in v0.91.0 

type CapacityProviderAutoScalingGroupProviderManagedDrainingInput interface {
	pulumi.Input

	ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutput() CapacityProviderAutoScalingGroupProviderManagedDrainingOutput
	ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutputWithContext(context.Context) CapacityProviderAutoScalingGroupProviderManagedDrainingOutput
}

CapacityProviderAutoScalingGroupProviderManagedDrainingInput is an input type that accepts values of the CapacityProviderAutoScalingGroupProviderManagedDraining enum A concrete instance of `CapacityProviderAutoScalingGroupProviderManagedDrainingInput` can be one of the following: 

CapacityProviderAutoScalingGroupProviderManagedDrainingDisabled
CapacityProviderAutoScalingGroupProviderManagedDrainingEnabled

type CapacityProviderAutoScalingGroupProviderManagedDrainingOutput added in v0.91.0 

type CapacityProviderAutoScalingGroupProviderManagedDrainingOutput struct{ *pulumi.OutputState }

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ElementType added in v0.91.0 

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutput added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutput() CapacityProviderAutoScalingGroupProviderManagedDrainingOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutputWithContext added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedDrainingOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput() CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutputWithContext added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToStringOutput added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToStringOutput() pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToStringOutputWithContext added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToStringPtrOutput added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToStringPtrOutputWithContext added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderAutoScalingGroupProviderManagedDrainingPtrInput added in v0.91.0 

type CapacityProviderAutoScalingGroupProviderManagedDrainingPtrInput interface {
	pulumi.Input

	ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput() CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput
	ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutputWithContext(context.Context) CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput
}

func CapacityProviderAutoScalingGroupProviderManagedDrainingPtr added in v0.91.0 

func CapacityProviderAutoScalingGroupProviderManagedDrainingPtr(v string) CapacityProviderAutoScalingGroupProviderManagedDrainingPtrInput

type CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput added in v0.91.0 

type CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput struct{ *pulumi.OutputState }

func (CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) Elem added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) Elem() CapacityProviderAutoScalingGroupProviderManagedDrainingOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ElementType added in v0.91.0 

func (CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput() CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutputWithContext added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ToCapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ToStringPtrOutput added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ToStringPtrOutputWithContext added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtection 

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtection string

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ElementType 

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput 

func (e CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutputWithContext 

func (e CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput 

func (e CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutputWithContext 

func (e CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToStringOutput 

func (e CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToStringOutput() pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToStringOutputWithContext 

func (e CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToStringPtrOutput 

func (e CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToStringPtrOutputWithContext 

func (e CapacityProviderAutoScalingGroupProviderManagedTerminationProtection) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionInput 

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionInput interface {
	pulumi.Input

	ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput
	ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutputWithContext(context.Context) CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput
}

CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionInput is an input type that accepts values of the CapacityProviderAutoScalingGroupProviderManagedTerminationProtection enum A concrete instance of `CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionInput` can be one of the following: 

CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionDisabled
CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionEnabled

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput 

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput struct{ *pulumi.OutputState }

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ElementType 

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutputWithContext 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutputWithContext 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToStringOutput 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToStringOutput() pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToStringOutputWithContext 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToStringPtrOutput 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToStringPtrOutputWithContext 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrInput 

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrInput interface {
	pulumi.Input

	ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput
	ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutputWithContext(context.Context) CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput
}

func CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtr 

func CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtr(v string) CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrInput

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput 

type CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput struct{ *pulumi.OutputState }

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) Elem 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) Elem() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ElementType 

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutputWithContext 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ToCapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ToStringPtrOutput 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ToStringPtrOutputWithContext 

func (o CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderAutoScalingGroupProviderOutput 

type CapacityProviderAutoScalingGroupProviderOutput struct{ *pulumi.OutputState }

func (CapacityProviderAutoScalingGroupProviderOutput) AutoScalingGroupArn 

func (o CapacityProviderAutoScalingGroupProviderOutput) AutoScalingGroupArn() pulumi.StringOutput

func (CapacityProviderAutoScalingGroupProviderOutput) ElementType 

func (CapacityProviderAutoScalingGroupProviderOutput) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderOutput) ManagedDraining added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderOutput) ManagedDraining() CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput

func (CapacityProviderAutoScalingGroupProviderOutput) ManagedScaling 

func (o CapacityProviderAutoScalingGroupProviderOutput) ManagedScaling() CapacityProviderManagedScalingPtrOutput

func (CapacityProviderAutoScalingGroupProviderOutput) ManagedTerminationProtection 

func (o CapacityProviderAutoScalingGroupProviderOutput) ManagedTerminationProtection() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput

func (CapacityProviderAutoScalingGroupProviderOutput) ToCapacityProviderAutoScalingGroupProviderOutput 

func (o CapacityProviderAutoScalingGroupProviderOutput) ToCapacityProviderAutoScalingGroupProviderOutput() CapacityProviderAutoScalingGroupProviderOutput

func (CapacityProviderAutoScalingGroupProviderOutput) ToCapacityProviderAutoScalingGroupProviderOutputWithContext 

func (o CapacityProviderAutoScalingGroupProviderOutput) ToCapacityProviderAutoScalingGroupProviderOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderOutput

type CapacityProviderAutoScalingGroupProviderPtrOutput 

type CapacityProviderAutoScalingGroupProviderPtrOutput struct{ *pulumi.OutputState }

func (CapacityProviderAutoScalingGroupProviderPtrOutput) AutoScalingGroupArn 

func (o CapacityProviderAutoScalingGroupProviderPtrOutput) AutoScalingGroupArn() pulumi.StringPtrOutput

func (CapacityProviderAutoScalingGroupProviderPtrOutput) Elem 

func (o CapacityProviderAutoScalingGroupProviderPtrOutput) Elem() CapacityProviderAutoScalingGroupProviderOutput

func (CapacityProviderAutoScalingGroupProviderPtrOutput) ElementType 

func (CapacityProviderAutoScalingGroupProviderPtrOutput) ElementType() reflect.Type

func (CapacityProviderAutoScalingGroupProviderPtrOutput) ManagedDraining added in v0.91.0 

func (o CapacityProviderAutoScalingGroupProviderPtrOutput) ManagedDraining() CapacityProviderAutoScalingGroupProviderManagedDrainingPtrOutput

func (CapacityProviderAutoScalingGroupProviderPtrOutput) ManagedScaling 

func (o CapacityProviderAutoScalingGroupProviderPtrOutput) ManagedScaling() CapacityProviderManagedScalingPtrOutput

func (CapacityProviderAutoScalingGroupProviderPtrOutput) ManagedTerminationProtection 

func (o CapacityProviderAutoScalingGroupProviderPtrOutput) ManagedTerminationProtection() CapacityProviderAutoScalingGroupProviderManagedTerminationProtectionPtrOutput

func (CapacityProviderAutoScalingGroupProviderPtrOutput) ToCapacityProviderAutoScalingGroupProviderPtrOutput 

func (o CapacityProviderAutoScalingGroupProviderPtrOutput) ToCapacityProviderAutoScalingGroupProviderPtrOutput() CapacityProviderAutoScalingGroupProviderPtrOutput

func (CapacityProviderAutoScalingGroupProviderPtrOutput) ToCapacityProviderAutoScalingGroupProviderPtrOutputWithContext 

func (o CapacityProviderAutoScalingGroupProviderPtrOutput) ToCapacityProviderAutoScalingGroupProviderPtrOutputWithContext(ctx context.Context) CapacityProviderAutoScalingGroupProviderPtrOutput

type CapacityProviderInput 

type CapacityProviderInput interface {
	pulumi.Input

	ToCapacityProviderOutput() CapacityProviderOutput
	ToCapacityProviderOutputWithContext(ctx context.Context) CapacityProviderOutput
}

type CapacityProviderManagedScaling 

type CapacityProviderManagedScaling struct {
	InstanceWarmupPeriod   *int                                  `pulumi:"instanceWarmupPeriod"`
	MaximumScalingStepSize *int                                  `pulumi:"maximumScalingStepSize"`
	MinimumScalingStepSize *int                                  `pulumi:"minimumScalingStepSize"`
	Status                 *CapacityProviderManagedScalingStatus `pulumi:"status"`
	TargetCapacity         *int                                  `pulumi:"targetCapacity"`
}

The managed scaling settings for the Auto Scaling group capacity provider.

type CapacityProviderManagedScalingArgs 

type CapacityProviderManagedScalingArgs struct {
	InstanceWarmupPeriod   pulumi.IntPtrInput                           `pulumi:"instanceWarmupPeriod"`
	MaximumScalingStepSize pulumi.IntPtrInput                           `pulumi:"maximumScalingStepSize"`
	MinimumScalingStepSize pulumi.IntPtrInput                           `pulumi:"minimumScalingStepSize"`
	Status                 CapacityProviderManagedScalingStatusPtrInput `pulumi:"status"`
	TargetCapacity         pulumi.IntPtrInput                           `pulumi:"targetCapacity"`
}

The managed scaling settings for the Auto Scaling group capacity provider.

func (CapacityProviderManagedScalingArgs) ElementType 

func (CapacityProviderManagedScalingArgs) ElementType() reflect.Type

func (CapacityProviderManagedScalingArgs) ToCapacityProviderManagedScalingOutput 

func (i CapacityProviderManagedScalingArgs) ToCapacityProviderManagedScalingOutput() CapacityProviderManagedScalingOutput

func (CapacityProviderManagedScalingArgs) ToCapacityProviderManagedScalingOutputWithContext 

func (i CapacityProviderManagedScalingArgs) ToCapacityProviderManagedScalingOutputWithContext(ctx context.Context) CapacityProviderManagedScalingOutput

func (CapacityProviderManagedScalingArgs) ToCapacityProviderManagedScalingPtrOutput 

func (i CapacityProviderManagedScalingArgs) ToCapacityProviderManagedScalingPtrOutput() CapacityProviderManagedScalingPtrOutput

func (CapacityProviderManagedScalingArgs) ToCapacityProviderManagedScalingPtrOutputWithContext 

func (i CapacityProviderManagedScalingArgs) ToCapacityProviderManagedScalingPtrOutputWithContext(ctx context.Context) CapacityProviderManagedScalingPtrOutput

type CapacityProviderManagedScalingInput 

type CapacityProviderManagedScalingInput interface {
	pulumi.Input

	ToCapacityProviderManagedScalingOutput() CapacityProviderManagedScalingOutput
	ToCapacityProviderManagedScalingOutputWithContext(context.Context) CapacityProviderManagedScalingOutput
}

CapacityProviderManagedScalingInput is an input type that accepts CapacityProviderManagedScalingArgs and CapacityProviderManagedScalingOutput values. You can construct a concrete instance of `CapacityProviderManagedScalingInput` via: 

CapacityProviderManagedScalingArgs{...}

type CapacityProviderManagedScalingOutput 

type CapacityProviderManagedScalingOutput struct{ *pulumi.OutputState }

The managed scaling settings for the Auto Scaling group capacity provider.

func (CapacityProviderManagedScalingOutput) ElementType 

func (CapacityProviderManagedScalingOutput) ElementType() reflect.Type

func (CapacityProviderManagedScalingOutput) InstanceWarmupPeriod 

func (o CapacityProviderManagedScalingOutput) InstanceWarmupPeriod() pulumi.IntPtrOutput

func (CapacityProviderManagedScalingOutput) MaximumScalingStepSize 

func (o CapacityProviderManagedScalingOutput) MaximumScalingStepSize() pulumi.IntPtrOutput

func (CapacityProviderManagedScalingOutput) MinimumScalingStepSize 

func (o CapacityProviderManagedScalingOutput) MinimumScalingStepSize() pulumi.IntPtrOutput

func (CapacityProviderManagedScalingOutput) Status 

func (o CapacityProviderManagedScalingOutput) Status() CapacityProviderManagedScalingStatusPtrOutput

func (CapacityProviderManagedScalingOutput) TargetCapacity 

func (o CapacityProviderManagedScalingOutput) TargetCapacity() pulumi.IntPtrOutput

func (CapacityProviderManagedScalingOutput) ToCapacityProviderManagedScalingOutput 

func (o CapacityProviderManagedScalingOutput) ToCapacityProviderManagedScalingOutput() CapacityProviderManagedScalingOutput

func (CapacityProviderManagedScalingOutput) ToCapacityProviderManagedScalingOutputWithContext 

func (o CapacityProviderManagedScalingOutput) ToCapacityProviderManagedScalingOutputWithContext(ctx context.Context) CapacityProviderManagedScalingOutput

func (CapacityProviderManagedScalingOutput) ToCapacityProviderManagedScalingPtrOutput 

func (o CapacityProviderManagedScalingOutput) ToCapacityProviderManagedScalingPtrOutput() CapacityProviderManagedScalingPtrOutput

func (CapacityProviderManagedScalingOutput) ToCapacityProviderManagedScalingPtrOutputWithContext 

func (o CapacityProviderManagedScalingOutput) ToCapacityProviderManagedScalingPtrOutputWithContext(ctx context.Context) CapacityProviderManagedScalingPtrOutput

type CapacityProviderManagedScalingPtrInput 

type CapacityProviderManagedScalingPtrInput interface {
	pulumi.Input

	ToCapacityProviderManagedScalingPtrOutput() CapacityProviderManagedScalingPtrOutput
	ToCapacityProviderManagedScalingPtrOutputWithContext(context.Context) CapacityProviderManagedScalingPtrOutput
}

CapacityProviderManagedScalingPtrInput is an input type that accepts CapacityProviderManagedScalingArgs, CapacityProviderManagedScalingPtr and CapacityProviderManagedScalingPtrOutput values. You can construct a concrete instance of `CapacityProviderManagedScalingPtrInput` via: 

        CapacityProviderManagedScalingArgs{...}

or:

        nil

func CapacityProviderManagedScalingPtr 

func CapacityProviderManagedScalingPtr(v *CapacityProviderManagedScalingArgs) CapacityProviderManagedScalingPtrInput

type CapacityProviderManagedScalingPtrOutput 

type CapacityProviderManagedScalingPtrOutput struct{ *pulumi.OutputState }

func (CapacityProviderManagedScalingPtrOutput) Elem 

func (o CapacityProviderManagedScalingPtrOutput) Elem() CapacityProviderManagedScalingOutput

func (CapacityProviderManagedScalingPtrOutput) ElementType 

func (CapacityProviderManagedScalingPtrOutput) ElementType() reflect.Type

func (CapacityProviderManagedScalingPtrOutput) InstanceWarmupPeriod 

func (o CapacityProviderManagedScalingPtrOutput) InstanceWarmupPeriod() pulumi.IntPtrOutput

func (CapacityProviderManagedScalingPtrOutput) MaximumScalingStepSize 

func (o CapacityProviderManagedScalingPtrOutput) MaximumScalingStepSize() pulumi.IntPtrOutput

func (CapacityProviderManagedScalingPtrOutput) MinimumScalingStepSize 

func (o CapacityProviderManagedScalingPtrOutput) MinimumScalingStepSize() pulumi.IntPtrOutput

func (CapacityProviderManagedScalingPtrOutput) Status 

func (o CapacityProviderManagedScalingPtrOutput) Status() CapacityProviderManagedScalingStatusPtrOutput

func (CapacityProviderManagedScalingPtrOutput) TargetCapacity 

func (o CapacityProviderManagedScalingPtrOutput) TargetCapacity() pulumi.IntPtrOutput

func (CapacityProviderManagedScalingPtrOutput) ToCapacityProviderManagedScalingPtrOutput 

func (o CapacityProviderManagedScalingPtrOutput) ToCapacityProviderManagedScalingPtrOutput() CapacityProviderManagedScalingPtrOutput

func (CapacityProviderManagedScalingPtrOutput) ToCapacityProviderManagedScalingPtrOutputWithContext 

func (o CapacityProviderManagedScalingPtrOutput) ToCapacityProviderManagedScalingPtrOutputWithContext(ctx context.Context) CapacityProviderManagedScalingPtrOutput

type CapacityProviderManagedScalingStatus 

type CapacityProviderManagedScalingStatus string

func (CapacityProviderManagedScalingStatus) ElementType 

func (CapacityProviderManagedScalingStatus) ElementType() reflect.Type

func (CapacityProviderManagedScalingStatus) ToCapacityProviderManagedScalingStatusOutput 

func (e CapacityProviderManagedScalingStatus) ToCapacityProviderManagedScalingStatusOutput() CapacityProviderManagedScalingStatusOutput

func (CapacityProviderManagedScalingStatus) ToCapacityProviderManagedScalingStatusOutputWithContext 

func (e CapacityProviderManagedScalingStatus) ToCapacityProviderManagedScalingStatusOutputWithContext(ctx context.Context) CapacityProviderManagedScalingStatusOutput

func (CapacityProviderManagedScalingStatus) ToCapacityProviderManagedScalingStatusPtrOutput 

func (e CapacityProviderManagedScalingStatus) ToCapacityProviderManagedScalingStatusPtrOutput() CapacityProviderManagedScalingStatusPtrOutput

func (CapacityProviderManagedScalingStatus) ToCapacityProviderManagedScalingStatusPtrOutputWithContext 

func (e CapacityProviderManagedScalingStatus) ToCapacityProviderManagedScalingStatusPtrOutputWithContext(ctx context.Context) CapacityProviderManagedScalingStatusPtrOutput

func (CapacityProviderManagedScalingStatus) ToStringOutput 

func (e CapacityProviderManagedScalingStatus) ToStringOutput() pulumi.StringOutput

func (CapacityProviderManagedScalingStatus) ToStringOutputWithContext 

func (e CapacityProviderManagedScalingStatus) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (CapacityProviderManagedScalingStatus) ToStringPtrOutput 

func (e CapacityProviderManagedScalingStatus) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderManagedScalingStatus) ToStringPtrOutputWithContext 

func (e CapacityProviderManagedScalingStatus) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderManagedScalingStatusInput 

type CapacityProviderManagedScalingStatusInput interface {
	pulumi.Input

	ToCapacityProviderManagedScalingStatusOutput() CapacityProviderManagedScalingStatusOutput
	ToCapacityProviderManagedScalingStatusOutputWithContext(context.Context) CapacityProviderManagedScalingStatusOutput
}

CapacityProviderManagedScalingStatusInput is an input type that accepts values of the CapacityProviderManagedScalingStatus enum A concrete instance of `CapacityProviderManagedScalingStatusInput` can be one of the following: 

CapacityProviderManagedScalingStatusDisabled
CapacityProviderManagedScalingStatusEnabled

type CapacityProviderManagedScalingStatusOutput 

type CapacityProviderManagedScalingStatusOutput struct{ *pulumi.OutputState }

func (CapacityProviderManagedScalingStatusOutput) ElementType 

func (CapacityProviderManagedScalingStatusOutput) ElementType() reflect.Type

func (CapacityProviderManagedScalingStatusOutput) ToCapacityProviderManagedScalingStatusOutput 

func (o CapacityProviderManagedScalingStatusOutput) ToCapacityProviderManagedScalingStatusOutput() CapacityProviderManagedScalingStatusOutput

func (CapacityProviderManagedScalingStatusOutput) ToCapacityProviderManagedScalingStatusOutputWithContext 

func (o CapacityProviderManagedScalingStatusOutput) ToCapacityProviderManagedScalingStatusOutputWithContext(ctx context.Context) CapacityProviderManagedScalingStatusOutput

func (CapacityProviderManagedScalingStatusOutput) ToCapacityProviderManagedScalingStatusPtrOutput 

func (o CapacityProviderManagedScalingStatusOutput) ToCapacityProviderManagedScalingStatusPtrOutput() CapacityProviderManagedScalingStatusPtrOutput

func (CapacityProviderManagedScalingStatusOutput) ToCapacityProviderManagedScalingStatusPtrOutputWithContext 

func (o CapacityProviderManagedScalingStatusOutput) ToCapacityProviderManagedScalingStatusPtrOutputWithContext(ctx context.Context) CapacityProviderManagedScalingStatusPtrOutput

func (CapacityProviderManagedScalingStatusOutput) ToStringOutput 

func (o CapacityProviderManagedScalingStatusOutput) ToStringOutput() pulumi.StringOutput

func (CapacityProviderManagedScalingStatusOutput) ToStringOutputWithContext 

func (o CapacityProviderManagedScalingStatusOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (CapacityProviderManagedScalingStatusOutput) ToStringPtrOutput 

func (o CapacityProviderManagedScalingStatusOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderManagedScalingStatusOutput) ToStringPtrOutputWithContext 

func (o CapacityProviderManagedScalingStatusOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderManagedScalingStatusPtrInput 

type CapacityProviderManagedScalingStatusPtrInput interface {
	pulumi.Input

	ToCapacityProviderManagedScalingStatusPtrOutput() CapacityProviderManagedScalingStatusPtrOutput
	ToCapacityProviderManagedScalingStatusPtrOutputWithContext(context.Context) CapacityProviderManagedScalingStatusPtrOutput
}

func CapacityProviderManagedScalingStatusPtr 

func CapacityProviderManagedScalingStatusPtr(v string) CapacityProviderManagedScalingStatusPtrInput

type CapacityProviderManagedScalingStatusPtrOutput 

type CapacityProviderManagedScalingStatusPtrOutput struct{ *pulumi.OutputState }

func (CapacityProviderManagedScalingStatusPtrOutput) Elem 

func (o CapacityProviderManagedScalingStatusPtrOutput) Elem() CapacityProviderManagedScalingStatusOutput

func (CapacityProviderManagedScalingStatusPtrOutput) ElementType 

func (CapacityProviderManagedScalingStatusPtrOutput) ElementType() reflect.Type

func (CapacityProviderManagedScalingStatusPtrOutput) ToCapacityProviderManagedScalingStatusPtrOutput 

func (o CapacityProviderManagedScalingStatusPtrOutput) ToCapacityProviderManagedScalingStatusPtrOutput() CapacityProviderManagedScalingStatusPtrOutput

func (CapacityProviderManagedScalingStatusPtrOutput) ToCapacityProviderManagedScalingStatusPtrOutputWithContext 

func (o CapacityProviderManagedScalingStatusPtrOutput) ToCapacityProviderManagedScalingStatusPtrOutputWithContext(ctx context.Context) CapacityProviderManagedScalingStatusPtrOutput

func (CapacityProviderManagedScalingStatusPtrOutput) ToStringPtrOutput 

func (o CapacityProviderManagedScalingStatusPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (CapacityProviderManagedScalingStatusPtrOutput) ToStringPtrOutputWithContext 

func (o CapacityProviderManagedScalingStatusPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type CapacityProviderOutput 

type CapacityProviderOutput struct{ *pulumi.OutputState }

func (CapacityProviderOutput) AutoScalingGroupProvider added in v0.17.0 

func (o CapacityProviderOutput) AutoScalingGroupProvider() CapacityProviderAutoScalingGroupProviderOutput

func (CapacityProviderOutput) ElementType 

func (CapacityProviderOutput) ElementType() reflect.Type

func (CapacityProviderOutput) Name added in v0.17.0 

func (o CapacityProviderOutput) Name() pulumi.StringPtrOutput

func (CapacityProviderOutput) Tags added in v0.17.0 

func (o CapacityProviderOutput) Tags() aws.TagArrayOutput

func (CapacityProviderOutput) ToCapacityProviderOutput 

func (o CapacityProviderOutput) ToCapacityProviderOutput() CapacityProviderOutput

func (CapacityProviderOutput) ToCapacityProviderOutputWithContext 

func (o CapacityProviderOutput) ToCapacityProviderOutputWithContext(ctx context.Context) CapacityProviderOutput

type CapacityProviderState 

type CapacityProviderState struct {
}

func (CapacityProviderState) ElementType 

func (CapacityProviderState) ElementType() reflect.Type

type CapacityProviderTag 

type CapacityProviderTag struct {
	Key   *string `pulumi:"key"`
	Value *string `pulumi:"value"`
}

type Cluster 

type Cluster struct {
	pulumi.CustomResourceState

	Arn pulumi.StringOutput `pulumi:"arn"`
	// The short name of one or more capacity providers to associate with the cluster. A capacity provider must be associated with a cluster before it can be included as part of the default capacity provider strategy of the cluster or used in a capacity provider strategy when calling the [CreateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html) or [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html) actions.
	//  If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must be created but not associated with another cluster. New Auto Scaling group capacity providers can be created with the [CreateCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCapacityProvider.html) API operation.
	//  To use a FARGATElong capacity provider, specify either the “FARGATE“ or “FARGATE_SPOT“ capacity providers. The FARGATElong capacity providers are available to all accounts and only need to be associated with a cluster to be used.
	//  The [PutCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutCapacityProvider.html) API operation is used to update the list of available capacity providers for a cluster after the cluster is created.
	CapacityProviders pulumi.StringArrayOutput `pulumi:"capacityProviders"`
	// A user-generated string that you use to identify your cluster. If you don't specify a name, CFNlong generates a unique physical ID for the name.
	ClusterName pulumi.StringPtrOutput `pulumi:"clusterName"`
	// The settings to use when creating a cluster. This parameter is used to turn on CloudWatch Container Insights for a cluster.
	ClusterSettings ClusterSettingsArrayOutput `pulumi:"clusterSettings"`
	// The execute command configuration for the cluster.
	Configuration ClusterConfigurationPtrOutput `pulumi:"configuration"`
	// The default capacity provider strategy for the cluster. When services or tasks are run in the cluster with no launch type or capacity provider strategy specified, the default capacity provider strategy is used.
	DefaultCapacityProviderStrategy ClusterCapacityProviderStrategyItemArrayOutput `pulumi:"defaultCapacityProviderStrategy"`
	// Use this parameter to set a default Service Connect namespace. After you set a default Service Connect namespace, any new services with Service Connect turned on that are created in the cluster are added as client services in the namespace. This setting only applies to new services that set the “enabled“ parameter to “true“ in the “ServiceConnectConfiguration“. You can set the namespace of each service individually in the “ServiceConnectConfiguration“ to override this default parameter.
	//  Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	ServiceConnectDefaults ClusterServiceConnectDefaultsPtrOutput `pulumi:"serviceConnectDefaults"`
	// The metadata that you apply to the cluster to help you categorize and organize them. Each tag consists of a key and an optional value. You define both.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags aws.TagArrayOutput `pulumi:"tags"`
}

The “AWS::ECS::Cluster“ resource creates an Amazon Elastic Container Service (Amazon ECS) cluster.

func GetCluster 

func GetCluster(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ClusterState, opts ...pulumi.ResourceOption) (*Cluster, error)

GetCluster gets an existing Cluster 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 NewCluster 

func NewCluster(ctx *pulumi.Context,
	name string, args *ClusterArgs, opts ...pulumi.ResourceOption) (*Cluster, error)

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

func (*Cluster) ElementType 

func (*Cluster) ElementType() reflect.Type

func (*Cluster) ToClusterOutput 

func (i *Cluster) ToClusterOutput() ClusterOutput

func (*Cluster) ToClusterOutputWithContext 

func (i *Cluster) ToClusterOutputWithContext(ctx context.Context) ClusterOutput

type ClusterArgs 

type ClusterArgs struct {
	// The short name of one or more capacity providers to associate with the cluster. A capacity provider must be associated with a cluster before it can be included as part of the default capacity provider strategy of the cluster or used in a capacity provider strategy when calling the [CreateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html) or [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html) actions.
	//  If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must be created but not associated with another cluster. New Auto Scaling group capacity providers can be created with the [CreateCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCapacityProvider.html) API operation.
	//  To use a FARGATElong capacity provider, specify either the “FARGATE“ or “FARGATE_SPOT“ capacity providers. The FARGATElong capacity providers are available to all accounts and only need to be associated with a cluster to be used.
	//  The [PutCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutCapacityProvider.html) API operation is used to update the list of available capacity providers for a cluster after the cluster is created.
	CapacityProviders pulumi.StringArrayInput
	// A user-generated string that you use to identify your cluster. If you don't specify a name, CFNlong generates a unique physical ID for the name.
	ClusterName pulumi.StringPtrInput
	// The settings to use when creating a cluster. This parameter is used to turn on CloudWatch Container Insights for a cluster.
	ClusterSettings ClusterSettingsArrayInput
	// The execute command configuration for the cluster.
	Configuration ClusterConfigurationPtrInput
	// The default capacity provider strategy for the cluster. When services or tasks are run in the cluster with no launch type or capacity provider strategy specified, the default capacity provider strategy is used.
	DefaultCapacityProviderStrategy ClusterCapacityProviderStrategyItemArrayInput
	// Use this parameter to set a default Service Connect namespace. After you set a default Service Connect namespace, any new services with Service Connect turned on that are created in the cluster are added as client services in the namespace. This setting only applies to new services that set the “enabled“ parameter to “true“ in the “ServiceConnectConfiguration“. You can set the namespace of each service individually in the “ServiceConnectConfiguration“ to override this default parameter.
	//  Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	ServiceConnectDefaults ClusterServiceConnectDefaultsPtrInput
	// The metadata that you apply to the cluster to help you categorize and organize them. Each tag consists of a key and an optional value. You define both.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags aws.TagArrayInput
}

The set of arguments for constructing a Cluster resource.

func (ClusterArgs) ElementType 

func (ClusterArgs) ElementType() reflect.Type

type ClusterCapacityProviderAssociations 

type ClusterCapacityProviderAssociations struct {
	pulumi.CustomResourceState

	CapacityProviders               pulumi.StringArrayOutput                                               `pulumi:"capacityProviders"`
	Cluster                         pulumi.StringOutput                                                    `pulumi:"cluster"`
	DefaultCapacityProviderStrategy ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput `pulumi:"defaultCapacityProviderStrategy"`
}

Associate a set of ECS Capacity Providers with a specified ECS Cluster

## Example Usage ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		clusterName := cfg.Require("clusterName")
		_, err := ecs.NewClusterCapacityProviderAssociations(ctx, "clusterCPAssociation", &ecs.ClusterCapacityProviderAssociationsArgs{
			Cluster: pulumi.String(clusterName),
			CapacityProviders: pulumi.StringArray{
				pulumi.String(ecs.ClusterCapacityProviderAssociationsCapacityProviderFargate),
				pulumi.String(ecs.ClusterCapacityProviderAssociationsCapacityProviderFargateSpot),
			},
			DefaultCapacityProviderStrategy: ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArray{
				&ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{
					Base:             pulumi.Int(2),
					Weight:           pulumi.Int(1),
					CapacityProvider: pulumi.String(ecs.ClusterCapacityProviderAssociationsCapacityProviderFargate),
				},
				&ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{
					Base:             pulumi.Int(0),
					Weight:           pulumi.Int(1),
					CapacityProvider: pulumi.String(ecs.ClusterCapacityProviderAssociationsCapacityProviderFargateSpot),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		clusterName := cfg.Require("clusterName")
		_, err := ecs.NewClusterCapacityProviderAssociations(ctx, "clusterCPAssociation", &ecs.ClusterCapacityProviderAssociationsArgs{
			Cluster: pulumi.String(clusterName),
			CapacityProviders: pulumi.StringArray{
				pulumi.String(ecs.ClusterCapacityProviderAssociationsCapacityProviderFargate),
				pulumi.String(ecs.ClusterCapacityProviderAssociationsCapacityProviderFargateSpot),
			},
			DefaultCapacityProviderStrategy: ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArray{
				&ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{
					Base:             pulumi.Int(2),
					Weight:           pulumi.Int(1),
					CapacityProvider: pulumi.String(ecs.ClusterCapacityProviderAssociationsCapacityProviderFargate),
				},
				&ecs.ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{
					Base:             pulumi.Int(0),
					Weight:           pulumi.Int(1),
					CapacityProvider: pulumi.String(ecs.ClusterCapacityProviderAssociationsCapacityProviderFargateSpot),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

func GetClusterCapacityProviderAssociations 

func GetClusterCapacityProviderAssociations(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ClusterCapacityProviderAssociationsState, opts ...pulumi.ResourceOption) (*ClusterCapacityProviderAssociations, error)

GetClusterCapacityProviderAssociations gets an existing ClusterCapacityProviderAssociations 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 NewClusterCapacityProviderAssociations 

func NewClusterCapacityProviderAssociations(ctx *pulumi.Context,
	name string, args *ClusterCapacityProviderAssociationsArgs, opts ...pulumi.ResourceOption) (*ClusterCapacityProviderAssociations, error)

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

func (*ClusterCapacityProviderAssociations) ElementType 

func (*ClusterCapacityProviderAssociations) ElementType() reflect.Type

func (*ClusterCapacityProviderAssociations) ToClusterCapacityProviderAssociationsOutput 

func (i *ClusterCapacityProviderAssociations) ToClusterCapacityProviderAssociationsOutput() ClusterCapacityProviderAssociationsOutput

func (*ClusterCapacityProviderAssociations) ToClusterCapacityProviderAssociationsOutputWithContext 

func (i *ClusterCapacityProviderAssociations) ToClusterCapacityProviderAssociationsOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsOutput

type ClusterCapacityProviderAssociationsArgs 

type ClusterCapacityProviderAssociationsArgs struct {
	CapacityProviders               pulumi.StringArrayInput
	Cluster                         pulumi.StringInput
	DefaultCapacityProviderStrategy ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayInput
}

The set of arguments for constructing a ClusterCapacityProviderAssociations resource.

func (ClusterCapacityProviderAssociationsArgs) ElementType 

func (ClusterCapacityProviderAssociationsArgs) ElementType() reflect.Type

type ClusterCapacityProviderAssociationsCapacityProvider 

type ClusterCapacityProviderAssociationsCapacityProvider string

If using ec2 auto-scaling, the name of the associated capacity provider. Otherwise FARGATE, FARGATE_SPOT.

func (ClusterCapacityProviderAssociationsCapacityProvider) ElementType 

func (ClusterCapacityProviderAssociationsCapacityProvider) ElementType() reflect.Type

func (ClusterCapacityProviderAssociationsCapacityProvider) ToClusterCapacityProviderAssociationsCapacityProviderOutput 

func (e ClusterCapacityProviderAssociationsCapacityProvider) ToClusterCapacityProviderAssociationsCapacityProviderOutput() ClusterCapacityProviderAssociationsCapacityProviderOutput

func (ClusterCapacityProviderAssociationsCapacityProvider) ToClusterCapacityProviderAssociationsCapacityProviderOutputWithContext 

func (e ClusterCapacityProviderAssociationsCapacityProvider) ToClusterCapacityProviderAssociationsCapacityProviderOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderOutput

func (ClusterCapacityProviderAssociationsCapacityProvider) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutput 

func (e ClusterCapacityProviderAssociationsCapacityProvider) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutput() ClusterCapacityProviderAssociationsCapacityProviderPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProvider) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutputWithContext 

func (e ClusterCapacityProviderAssociationsCapacityProvider) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProvider) ToStringOutput 

func (e ClusterCapacityProviderAssociationsCapacityProvider) ToStringOutput() pulumi.StringOutput

func (ClusterCapacityProviderAssociationsCapacityProvider) ToStringOutputWithContext 

func (e ClusterCapacityProviderAssociationsCapacityProvider) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ClusterCapacityProviderAssociationsCapacityProvider) ToStringPtrOutput 

func (e ClusterCapacityProviderAssociationsCapacityProvider) ToStringPtrOutput() pulumi.StringPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProvider) ToStringPtrOutputWithContext 

func (e ClusterCapacityProviderAssociationsCapacityProvider) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ClusterCapacityProviderAssociationsCapacityProvider0 added in v0.70.0 

type ClusterCapacityProviderAssociationsCapacityProvider0 string

If using ec2 auto-scaling, the name of the associated capacity provider. Otherwise FARGATE, FARGATE_SPOT.

type ClusterCapacityProviderAssociationsCapacityProviderInput 

type ClusterCapacityProviderAssociationsCapacityProviderInput interface {
	pulumi.Input

	ToClusterCapacityProviderAssociationsCapacityProviderOutput() ClusterCapacityProviderAssociationsCapacityProviderOutput
	ToClusterCapacityProviderAssociationsCapacityProviderOutputWithContext(context.Context) ClusterCapacityProviderAssociationsCapacityProviderOutput
}

ClusterCapacityProviderAssociationsCapacityProviderInput is an input type that accepts values of the ClusterCapacityProviderAssociationsCapacityProvider enum A concrete instance of `ClusterCapacityProviderAssociationsCapacityProviderInput` can be one of the following: 

ClusterCapacityProviderAssociationsCapacityProviderFargate
ClusterCapacityProviderAssociationsCapacityProviderFargateSpot

type ClusterCapacityProviderAssociationsCapacityProviderOutput 

type ClusterCapacityProviderAssociationsCapacityProviderOutput struct{ *pulumi.OutputState }

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ElementType 

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ElementType() reflect.Type

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ToClusterCapacityProviderAssociationsCapacityProviderOutput 

func (o ClusterCapacityProviderAssociationsCapacityProviderOutput) ToClusterCapacityProviderAssociationsCapacityProviderOutput() ClusterCapacityProviderAssociationsCapacityProviderOutput

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ToClusterCapacityProviderAssociationsCapacityProviderOutputWithContext 

func (o ClusterCapacityProviderAssociationsCapacityProviderOutput) ToClusterCapacityProviderAssociationsCapacityProviderOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderOutput

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutput 

func (o ClusterCapacityProviderAssociationsCapacityProviderOutput) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutput() ClusterCapacityProviderAssociationsCapacityProviderPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutputWithContext 

func (o ClusterCapacityProviderAssociationsCapacityProviderOutput) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ToStringOutput 

func (o ClusterCapacityProviderAssociationsCapacityProviderOutput) ToStringOutput() pulumi.StringOutput

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ToStringOutputWithContext 

func (o ClusterCapacityProviderAssociationsCapacityProviderOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ToStringPtrOutput 

func (o ClusterCapacityProviderAssociationsCapacityProviderOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProviderOutput) ToStringPtrOutputWithContext 

func (o ClusterCapacityProviderAssociationsCapacityProviderOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ClusterCapacityProviderAssociationsCapacityProviderPtrInput 

type ClusterCapacityProviderAssociationsCapacityProviderPtrInput interface {
	pulumi.Input

	ToClusterCapacityProviderAssociationsCapacityProviderPtrOutput() ClusterCapacityProviderAssociationsCapacityProviderPtrOutput
	ToClusterCapacityProviderAssociationsCapacityProviderPtrOutputWithContext(context.Context) ClusterCapacityProviderAssociationsCapacityProviderPtrOutput
}

func ClusterCapacityProviderAssociationsCapacityProviderPtr 

func ClusterCapacityProviderAssociationsCapacityProviderPtr(v string) ClusterCapacityProviderAssociationsCapacityProviderPtrInput

type ClusterCapacityProviderAssociationsCapacityProviderPtrOutput 

type ClusterCapacityProviderAssociationsCapacityProviderPtrOutput struct{ *pulumi.OutputState }

func (ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) Elem 

func (o ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) Elem() ClusterCapacityProviderAssociationsCapacityProviderOutput

func (ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ElementType 

func (ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ElementType() reflect.Type

func (ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutput 

func (o ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutput() ClusterCapacityProviderAssociationsCapacityProviderPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutputWithContext 

func (o ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ToClusterCapacityProviderAssociationsCapacityProviderPtrOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ToStringPtrOutput 

func (o ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ToStringPtrOutputWithContext 

func (o ClusterCapacityProviderAssociationsCapacityProviderPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ClusterCapacityProviderAssociationsCapacityProviderStrategy 

type ClusterCapacityProviderAssociationsCapacityProviderStrategy struct {
	Base             *int   `pulumi:"base"`
	CapacityProvider string `pulumi:"capacityProvider"`
	Weight           *int   `pulumi:"weight"`
}

type ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs 

type ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs struct {
	Base             pulumi.IntPtrInput `pulumi:"base"`
	CapacityProvider pulumi.StringInput `pulumi:"capacityProvider"`
	Weight           pulumi.IntPtrInput `pulumi:"weight"`
}

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs) ElementType 

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs) ElementType() reflect.Type

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs) ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutput 

func (i ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs) ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutput() ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs) ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutputWithContext 

func (i ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs) ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput

type ClusterCapacityProviderAssociationsCapacityProviderStrategyArray 

type ClusterCapacityProviderAssociationsCapacityProviderStrategyArray []ClusterCapacityProviderAssociationsCapacityProviderStrategyInput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArray) ElementType 

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArray) ElementType() reflect.Type

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArray) ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput 

func (i ClusterCapacityProviderAssociationsCapacityProviderStrategyArray) ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput() ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArray) ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutputWithContext 

func (i ClusterCapacityProviderAssociationsCapacityProviderStrategyArray) ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput

type ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayInput 

type ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayInput interface {
	pulumi.Input

	ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput() ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput
	ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutputWithContext(context.Context) ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput
}

ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayInput is an input type that accepts ClusterCapacityProviderAssociationsCapacityProviderStrategyArray and ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput values. You can construct a concrete instance of `ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayInput` via: 

ClusterCapacityProviderAssociationsCapacityProviderStrategyArray{ ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{...} }

type ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput 

type ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput struct{ *pulumi.OutputState }

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput) ElementType 

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput) ElementType() reflect.Type

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput) Index 

func (o ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput) Index(i pulumi.IntInput) ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput) ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput 

func (o ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput) ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput() ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput) ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutputWithContext 

func (o ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput) ToClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput

type ClusterCapacityProviderAssociationsCapacityProviderStrategyInput 

type ClusterCapacityProviderAssociationsCapacityProviderStrategyInput interface {
	pulumi.Input

	ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutput() ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput
	ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutputWithContext(context.Context) ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput
}

ClusterCapacityProviderAssociationsCapacityProviderStrategyInput is an input type that accepts ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs and ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput values. You can construct a concrete instance of `ClusterCapacityProviderAssociationsCapacityProviderStrategyInput` via: 

ClusterCapacityProviderAssociationsCapacityProviderStrategyArgs{...}

type ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput 

type ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput struct{ *pulumi.OutputState }

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) Base 

func (o ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) Base() pulumi.IntPtrOutput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) CapacityProvider 

func (o ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) CapacityProvider() pulumi.StringOutput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) ElementType 

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) ElementType() reflect.Type

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutput 

func (o ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutput() ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutputWithContext 

func (o ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) ToClusterCapacityProviderAssociationsCapacityProviderStrategyOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput

func (ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) Weight 

func (o ClusterCapacityProviderAssociationsCapacityProviderStrategyOutput) Weight() pulumi.IntPtrOutput

type ClusterCapacityProviderAssociationsInput 

type ClusterCapacityProviderAssociationsInput interface {
	pulumi.Input

	ToClusterCapacityProviderAssociationsOutput() ClusterCapacityProviderAssociationsOutput
	ToClusterCapacityProviderAssociationsOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsOutput
}

type ClusterCapacityProviderAssociationsOutput 

type ClusterCapacityProviderAssociationsOutput struct{ *pulumi.OutputState }

func (ClusterCapacityProviderAssociationsOutput) CapacityProviders added in v0.17.0 

func (o ClusterCapacityProviderAssociationsOutput) CapacityProviders() pulumi.StringArrayOutput

func (ClusterCapacityProviderAssociationsOutput) Cluster added in v0.17.0 

func (o ClusterCapacityProviderAssociationsOutput) Cluster() pulumi.StringOutput

func (ClusterCapacityProviderAssociationsOutput) DefaultCapacityProviderStrategy added in v0.17.0 

func (o ClusterCapacityProviderAssociationsOutput) DefaultCapacityProviderStrategy() ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput

func (ClusterCapacityProviderAssociationsOutput) ElementType 

func (ClusterCapacityProviderAssociationsOutput) ElementType() reflect.Type

func (ClusterCapacityProviderAssociationsOutput) ToClusterCapacityProviderAssociationsOutput 

func (o ClusterCapacityProviderAssociationsOutput) ToClusterCapacityProviderAssociationsOutput() ClusterCapacityProviderAssociationsOutput

func (ClusterCapacityProviderAssociationsOutput) ToClusterCapacityProviderAssociationsOutputWithContext 

func (o ClusterCapacityProviderAssociationsOutput) ToClusterCapacityProviderAssociationsOutputWithContext(ctx context.Context) ClusterCapacityProviderAssociationsOutput

type ClusterCapacityProviderAssociationsState 

type ClusterCapacityProviderAssociationsState struct {
}

func (ClusterCapacityProviderAssociationsState) ElementType 

func (ClusterCapacityProviderAssociationsState) ElementType() reflect.Type

type ClusterCapacityProviderStrategyItem 

type ClusterCapacityProviderStrategyItem struct {
	// The *base* value designates how many tasks, at a minimum, to run on the specified capacity provider. Only one capacity provider in a capacity provider strategy can have a *base* defined. If no value is specified, the default value of “0“ is used.
	Base *int `pulumi:"base"`
	// The short name of the capacity provider.
	CapacityProvider *string `pulumi:"capacityProvider"`
	// The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The “weight“ value is taken into consideration after the “base“ value, if defined, is satisfied.
	//  If no “weight“ value is specified, the default value of “0“ is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of “0“ can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of “0“, any “RunTask“ or “CreateService“ actions using the capacity provider strategy will fail.
	//  An example scenario for using weights is defining a strategy that contains two capacity providers and both have a weight of “1“, then when the “base“ is satisfied, the tasks will be split evenly across the two capacity providers. Using that same logic, if you specify a weight of “1“ for *capacityProviderA* and a weight of “4“ for *capacityProviderB*, then for every one task that's run using *capacityProviderA*, four tasks would use *capacityProviderB*.
	Weight *int `pulumi:"weight"`
}

The “CapacityProviderStrategyItem“ property specifies the details of the default capacity provider strategy for the cluster. When services or tasks are run in the cluster with no launch type or capacity provider strategy specified, the default capacity provider strategy is used.

type ClusterCapacityProviderStrategyItemArgs 

type ClusterCapacityProviderStrategyItemArgs struct {
	// The *base* value designates how many tasks, at a minimum, to run on the specified capacity provider. Only one capacity provider in a capacity provider strategy can have a *base* defined. If no value is specified, the default value of “0“ is used.
	Base pulumi.IntPtrInput `pulumi:"base"`
	// The short name of the capacity provider.
	CapacityProvider pulumi.StringPtrInput `pulumi:"capacityProvider"`
	// The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The “weight“ value is taken into consideration after the “base“ value, if defined, is satisfied.
	//  If no “weight“ value is specified, the default value of “0“ is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of “0“ can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of “0“, any “RunTask“ or “CreateService“ actions using the capacity provider strategy will fail.
	//  An example scenario for using weights is defining a strategy that contains two capacity providers and both have a weight of “1“, then when the “base“ is satisfied, the tasks will be split evenly across the two capacity providers. Using that same logic, if you specify a weight of “1“ for *capacityProviderA* and a weight of “4“ for *capacityProviderB*, then for every one task that's run using *capacityProviderA*, four tasks would use *capacityProviderB*.
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

The “CapacityProviderStrategyItem“ property specifies the details of the default capacity provider strategy for the cluster. When services or tasks are run in the cluster with no launch type or capacity provider strategy specified, the default capacity provider strategy is used.

func (ClusterCapacityProviderStrategyItemArgs) ElementType 

func (ClusterCapacityProviderStrategyItemArgs) ElementType() reflect.Type

func (ClusterCapacityProviderStrategyItemArgs) ToClusterCapacityProviderStrategyItemOutput 

func (i ClusterCapacityProviderStrategyItemArgs) ToClusterCapacityProviderStrategyItemOutput() ClusterCapacityProviderStrategyItemOutput

func (ClusterCapacityProviderStrategyItemArgs) ToClusterCapacityProviderStrategyItemOutputWithContext 

func (i ClusterCapacityProviderStrategyItemArgs) ToClusterCapacityProviderStrategyItemOutputWithContext(ctx context.Context) ClusterCapacityProviderStrategyItemOutput

type ClusterCapacityProviderStrategyItemArray 

type ClusterCapacityProviderStrategyItemArray []ClusterCapacityProviderStrategyItemInput

func (ClusterCapacityProviderStrategyItemArray) ElementType 

func (ClusterCapacityProviderStrategyItemArray) ElementType() reflect.Type

func (ClusterCapacityProviderStrategyItemArray) ToClusterCapacityProviderStrategyItemArrayOutput 

func (i ClusterCapacityProviderStrategyItemArray) ToClusterCapacityProviderStrategyItemArrayOutput() ClusterCapacityProviderStrategyItemArrayOutput

func (ClusterCapacityProviderStrategyItemArray) ToClusterCapacityProviderStrategyItemArrayOutputWithContext 

func (i ClusterCapacityProviderStrategyItemArray) ToClusterCapacityProviderStrategyItemArrayOutputWithContext(ctx context.Context) ClusterCapacityProviderStrategyItemArrayOutput

type ClusterCapacityProviderStrategyItemArrayInput 

type ClusterCapacityProviderStrategyItemArrayInput interface {
	pulumi.Input

	ToClusterCapacityProviderStrategyItemArrayOutput() ClusterCapacityProviderStrategyItemArrayOutput
	ToClusterCapacityProviderStrategyItemArrayOutputWithContext(context.Context) ClusterCapacityProviderStrategyItemArrayOutput
}

ClusterCapacityProviderStrategyItemArrayInput is an input type that accepts ClusterCapacityProviderStrategyItemArray and ClusterCapacityProviderStrategyItemArrayOutput values. You can construct a concrete instance of `ClusterCapacityProviderStrategyItemArrayInput` via: 

ClusterCapacityProviderStrategyItemArray{ ClusterCapacityProviderStrategyItemArgs{...} }

type ClusterCapacityProviderStrategyItemArrayOutput 

type ClusterCapacityProviderStrategyItemArrayOutput struct{ *pulumi.OutputState }

func (ClusterCapacityProviderStrategyItemArrayOutput) ElementType 

func (ClusterCapacityProviderStrategyItemArrayOutput) ElementType() reflect.Type

func (ClusterCapacityProviderStrategyItemArrayOutput) Index 

func (o ClusterCapacityProviderStrategyItemArrayOutput) Index(i pulumi.IntInput) ClusterCapacityProviderStrategyItemOutput

func (ClusterCapacityProviderStrategyItemArrayOutput) ToClusterCapacityProviderStrategyItemArrayOutput 

func (o ClusterCapacityProviderStrategyItemArrayOutput) ToClusterCapacityProviderStrategyItemArrayOutput() ClusterCapacityProviderStrategyItemArrayOutput

func (ClusterCapacityProviderStrategyItemArrayOutput) ToClusterCapacityProviderStrategyItemArrayOutputWithContext 

func (o ClusterCapacityProviderStrategyItemArrayOutput) ToClusterCapacityProviderStrategyItemArrayOutputWithContext(ctx context.Context) ClusterCapacityProviderStrategyItemArrayOutput

type ClusterCapacityProviderStrategyItemInput 

type ClusterCapacityProviderStrategyItemInput interface {
	pulumi.Input

	ToClusterCapacityProviderStrategyItemOutput() ClusterCapacityProviderStrategyItemOutput
	ToClusterCapacityProviderStrategyItemOutputWithContext(context.Context) ClusterCapacityProviderStrategyItemOutput
}

ClusterCapacityProviderStrategyItemInput is an input type that accepts ClusterCapacityProviderStrategyItemArgs and ClusterCapacityProviderStrategyItemOutput values. You can construct a concrete instance of `ClusterCapacityProviderStrategyItemInput` via: 

ClusterCapacityProviderStrategyItemArgs{...}

type ClusterCapacityProviderStrategyItemOutput 

type ClusterCapacityProviderStrategyItemOutput struct{ *pulumi.OutputState }

The “CapacityProviderStrategyItem“ property specifies the details of the default capacity provider strategy for the cluster. When services or tasks are run in the cluster with no launch type or capacity provider strategy specified, the default capacity provider strategy is used.

func (ClusterCapacityProviderStrategyItemOutput) Base 

func (o ClusterCapacityProviderStrategyItemOutput) Base() pulumi.IntPtrOutput

The *base* value designates how many tasks, at a minimum, to run on the specified capacity provider. Only one capacity provider in a capacity provider strategy can have a *base* defined. If no value is specified, the default value of “0“ is used.

func (ClusterCapacityProviderStrategyItemOutput) CapacityProvider 

func (o ClusterCapacityProviderStrategyItemOutput) CapacityProvider() pulumi.StringPtrOutput

The short name of the capacity provider.

func (ClusterCapacityProviderStrategyItemOutput) ElementType 

func (ClusterCapacityProviderStrategyItemOutput) ElementType() reflect.Type

func (ClusterCapacityProviderStrategyItemOutput) ToClusterCapacityProviderStrategyItemOutput 

func (o ClusterCapacityProviderStrategyItemOutput) ToClusterCapacityProviderStrategyItemOutput() ClusterCapacityProviderStrategyItemOutput

func (ClusterCapacityProviderStrategyItemOutput) ToClusterCapacityProviderStrategyItemOutputWithContext 

func (o ClusterCapacityProviderStrategyItemOutput) ToClusterCapacityProviderStrategyItemOutputWithContext(ctx context.Context) ClusterCapacityProviderStrategyItemOutput

func (ClusterCapacityProviderStrategyItemOutput) Weight 

func (o ClusterCapacityProviderStrategyItemOutput) Weight() pulumi.IntPtrOutput

The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The “weight“ value is taken into consideration after the “base“ value, if defined, is satisfied. 

If no ``weight`` value is specified, the default value of ``0`` is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of ``0`` can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of ``0``, any ``RunTask`` or ``CreateService`` actions using the capacity provider strategy will fail.
An example scenario for using weights is defining a strategy that contains two capacity providers and both have a weight of ``1``, then when the ``base`` is satisfied, the tasks will be split evenly across the two capacity providers. Using that same logic, if you specify a weight of ``1`` for *capacityProviderA* and a weight of ``4`` for *capacityProviderB*, then for every one task that's run using *capacityProviderA*, four tasks would use *capacityProviderB*.

type ClusterConfiguration added in v0.2.0 

type ClusterConfiguration struct {
	// The details of the execute command configuration.
	ExecuteCommandConfiguration *ClusterExecuteCommandConfiguration `pulumi:"executeCommandConfiguration"`
}

The execute command configuration for the cluster.

type ClusterConfigurationArgs added in v0.2.0 

type ClusterConfigurationArgs struct {
	// The details of the execute command configuration.
	ExecuteCommandConfiguration ClusterExecuteCommandConfigurationPtrInput `pulumi:"executeCommandConfiguration"`
}

The execute command configuration for the cluster.

func (ClusterConfigurationArgs) ElementType added in v0.2.0 

func (ClusterConfigurationArgs) ElementType() reflect.Type

func (ClusterConfigurationArgs) ToClusterConfigurationOutput added in v0.2.0 

func (i ClusterConfigurationArgs) ToClusterConfigurationOutput() ClusterConfigurationOutput

func (ClusterConfigurationArgs) ToClusterConfigurationOutputWithContext added in v0.2.0 

func (i ClusterConfigurationArgs) ToClusterConfigurationOutputWithContext(ctx context.Context) ClusterConfigurationOutput

func (ClusterConfigurationArgs) ToClusterConfigurationPtrOutput added in v0.2.0 

func (i ClusterConfigurationArgs) ToClusterConfigurationPtrOutput() ClusterConfigurationPtrOutput

func (ClusterConfigurationArgs) ToClusterConfigurationPtrOutputWithContext added in v0.2.0 

func (i ClusterConfigurationArgs) ToClusterConfigurationPtrOutputWithContext(ctx context.Context) ClusterConfigurationPtrOutput

type ClusterConfigurationInput added in v0.2.0 

type ClusterConfigurationInput interface {
	pulumi.Input

	ToClusterConfigurationOutput() ClusterConfigurationOutput
	ToClusterConfigurationOutputWithContext(context.Context) ClusterConfigurationOutput
}

ClusterConfigurationInput is an input type that accepts ClusterConfigurationArgs and ClusterConfigurationOutput values. You can construct a concrete instance of `ClusterConfigurationInput` via: 

ClusterConfigurationArgs{...}

type ClusterConfigurationOutput added in v0.2.0 

type ClusterConfigurationOutput struct{ *pulumi.OutputState }

The execute command configuration for the cluster.

func (ClusterConfigurationOutput) ElementType added in v0.2.0 

func (ClusterConfigurationOutput) ElementType() reflect.Type

func (ClusterConfigurationOutput) ExecuteCommandConfiguration added in v0.2.0 

func (o ClusterConfigurationOutput) ExecuteCommandConfiguration() ClusterExecuteCommandConfigurationPtrOutput

The details of the execute command configuration.

func (ClusterConfigurationOutput) ToClusterConfigurationOutput added in v0.2.0 

func (o ClusterConfigurationOutput) ToClusterConfigurationOutput() ClusterConfigurationOutput

func (ClusterConfigurationOutput) ToClusterConfigurationOutputWithContext added in v0.2.0 

func (o ClusterConfigurationOutput) ToClusterConfigurationOutputWithContext(ctx context.Context) ClusterConfigurationOutput

func (ClusterConfigurationOutput) ToClusterConfigurationPtrOutput added in v0.2.0 

func (o ClusterConfigurationOutput) ToClusterConfigurationPtrOutput() ClusterConfigurationPtrOutput

func (ClusterConfigurationOutput) ToClusterConfigurationPtrOutputWithContext added in v0.2.0 

func (o ClusterConfigurationOutput) ToClusterConfigurationPtrOutputWithContext(ctx context.Context) ClusterConfigurationPtrOutput

type ClusterConfigurationPtrInput added in v0.2.0 

type ClusterConfigurationPtrInput interface {
	pulumi.Input

	ToClusterConfigurationPtrOutput() ClusterConfigurationPtrOutput
	ToClusterConfigurationPtrOutputWithContext(context.Context) ClusterConfigurationPtrOutput
}

ClusterConfigurationPtrInput is an input type that accepts ClusterConfigurationArgs, ClusterConfigurationPtr and ClusterConfigurationPtrOutput values. You can construct a concrete instance of `ClusterConfigurationPtrInput` via: 

        ClusterConfigurationArgs{...}

or:

        nil

func ClusterConfigurationPtr added in v0.2.0 

func ClusterConfigurationPtr(v *ClusterConfigurationArgs) ClusterConfigurationPtrInput

type ClusterConfigurationPtrOutput added in v0.2.0 

type ClusterConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ClusterConfigurationPtrOutput) Elem added in v0.2.0 

func (o ClusterConfigurationPtrOutput) Elem() ClusterConfigurationOutput

func (ClusterConfigurationPtrOutput) ElementType added in v0.2.0 

func (ClusterConfigurationPtrOutput) ElementType() reflect.Type

func (ClusterConfigurationPtrOutput) ExecuteCommandConfiguration added in v0.2.0 

func (o ClusterConfigurationPtrOutput) ExecuteCommandConfiguration() ClusterExecuteCommandConfigurationPtrOutput

The details of the execute command configuration.

func (ClusterConfigurationPtrOutput) ToClusterConfigurationPtrOutput added in v0.2.0 

func (o ClusterConfigurationPtrOutput) ToClusterConfigurationPtrOutput() ClusterConfigurationPtrOutput

func (ClusterConfigurationPtrOutput) ToClusterConfigurationPtrOutputWithContext added in v0.2.0 

func (o ClusterConfigurationPtrOutput) ToClusterConfigurationPtrOutputWithContext(ctx context.Context) ClusterConfigurationPtrOutput

type ClusterExecuteCommandConfiguration 

type ClusterExecuteCommandConfiguration struct {
	// Specify an KMSlong key ID to encrypt the data between the local client and the container.
	KmsKeyId *string `pulumi:"kmsKeyId"`
	// The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket. When “logging=OVERRIDE“ is specified, a “logConfiguration“ must be provided.
	LogConfiguration *ClusterExecuteCommandLogConfiguration `pulumi:"logConfiguration"`
	// The log setting to use for redirecting logs for your execute command results. The following log settings are available.
	//   +   “NONE“: The execute command session is not logged.
	//   +   “DEFAULT“: The “awslogs“ configuration in the task definition is used. If no logging parameter is specified, it defaults to this value. If no “awslogs“ log driver is configured in the task definition, the output won't be logged.
	//   +   “OVERRIDE“: Specify the logging details as a part of “logConfiguration“. If the “OVERRIDE“ logging option is specified, the “logConfiguration“ is required.
	Logging *string `pulumi:"logging"`
}

The details of the execute command configuration.

type ClusterExecuteCommandConfigurationArgs 

type ClusterExecuteCommandConfigurationArgs struct {
	// Specify an KMSlong key ID to encrypt the data between the local client and the container.
	KmsKeyId pulumi.StringPtrInput `pulumi:"kmsKeyId"`
	// The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket. When “logging=OVERRIDE“ is specified, a “logConfiguration“ must be provided.
	LogConfiguration ClusterExecuteCommandLogConfigurationPtrInput `pulumi:"logConfiguration"`
	// The log setting to use for redirecting logs for your execute command results. The following log settings are available.
	//   +   “NONE“: The execute command session is not logged.
	//   +   “DEFAULT“: The “awslogs“ configuration in the task definition is used. If no logging parameter is specified, it defaults to this value. If no “awslogs“ log driver is configured in the task definition, the output won't be logged.
	//   +   “OVERRIDE“: Specify the logging details as a part of “logConfiguration“. If the “OVERRIDE“ logging option is specified, the “logConfiguration“ is required.
	Logging pulumi.StringPtrInput `pulumi:"logging"`
}

The details of the execute command configuration.

func (ClusterExecuteCommandConfigurationArgs) ElementType 

func (ClusterExecuteCommandConfigurationArgs) ElementType() reflect.Type

func (ClusterExecuteCommandConfigurationArgs) ToClusterExecuteCommandConfigurationOutput 

func (i ClusterExecuteCommandConfigurationArgs) ToClusterExecuteCommandConfigurationOutput() ClusterExecuteCommandConfigurationOutput

func (ClusterExecuteCommandConfigurationArgs) ToClusterExecuteCommandConfigurationOutputWithContext 

func (i ClusterExecuteCommandConfigurationArgs) ToClusterExecuteCommandConfigurationOutputWithContext(ctx context.Context) ClusterExecuteCommandConfigurationOutput

func (ClusterExecuteCommandConfigurationArgs) ToClusterExecuteCommandConfigurationPtrOutput 

func (i ClusterExecuteCommandConfigurationArgs) ToClusterExecuteCommandConfigurationPtrOutput() ClusterExecuteCommandConfigurationPtrOutput

func (ClusterExecuteCommandConfigurationArgs) ToClusterExecuteCommandConfigurationPtrOutputWithContext 

func (i ClusterExecuteCommandConfigurationArgs) ToClusterExecuteCommandConfigurationPtrOutputWithContext(ctx context.Context) ClusterExecuteCommandConfigurationPtrOutput

type ClusterExecuteCommandConfigurationInput 

type ClusterExecuteCommandConfigurationInput interface {
	pulumi.Input

	ToClusterExecuteCommandConfigurationOutput() ClusterExecuteCommandConfigurationOutput
	ToClusterExecuteCommandConfigurationOutputWithContext(context.Context) ClusterExecuteCommandConfigurationOutput
}

ClusterExecuteCommandConfigurationInput is an input type that accepts ClusterExecuteCommandConfigurationArgs and ClusterExecuteCommandConfigurationOutput values. You can construct a concrete instance of `ClusterExecuteCommandConfigurationInput` via: 

ClusterExecuteCommandConfigurationArgs{...}

type ClusterExecuteCommandConfigurationOutput 

type ClusterExecuteCommandConfigurationOutput struct{ *pulumi.OutputState }

The details of the execute command configuration.

func (ClusterExecuteCommandConfigurationOutput) ElementType 

func (ClusterExecuteCommandConfigurationOutput) ElementType() reflect.Type

func (ClusterExecuteCommandConfigurationOutput) KmsKeyId 

func (o ClusterExecuteCommandConfigurationOutput) KmsKeyId() pulumi.StringPtrOutput

Specify an KMSlong key ID to encrypt the data between the local client and the container.

func (ClusterExecuteCommandConfigurationOutput) LogConfiguration 

func (o ClusterExecuteCommandConfigurationOutput) LogConfiguration() ClusterExecuteCommandLogConfigurationPtrOutput

The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket. When “logging=OVERRIDE“ is specified, a “logConfiguration“ must be provided.

func (ClusterExecuteCommandConfigurationOutput) Logging 

func (o ClusterExecuteCommandConfigurationOutput) Logging() pulumi.StringPtrOutput

The log setting to use for redirecting logs for your execute command results. The following log settings are available.

  • “NONE“: The execute command session is not logged.
  • “DEFAULT“: The “awslogs“ configuration in the task definition is used. If no logging parameter is specified, it defaults to this value. If no “awslogs“ log driver is configured in the task definition, the output won't be logged.
  • “OVERRIDE“: Specify the logging details as a part of “logConfiguration“. If the “OVERRIDE“ logging option is specified, the “logConfiguration“ is required.

func (ClusterExecuteCommandConfigurationOutput) ToClusterExecuteCommandConfigurationOutput 

func (o ClusterExecuteCommandConfigurationOutput) ToClusterExecuteCommandConfigurationOutput() ClusterExecuteCommandConfigurationOutput

func (ClusterExecuteCommandConfigurationOutput) ToClusterExecuteCommandConfigurationOutputWithContext 

func (o ClusterExecuteCommandConfigurationOutput) ToClusterExecuteCommandConfigurationOutputWithContext(ctx context.Context) ClusterExecuteCommandConfigurationOutput

func (ClusterExecuteCommandConfigurationOutput) ToClusterExecuteCommandConfigurationPtrOutput 

func (o ClusterExecuteCommandConfigurationOutput) ToClusterExecuteCommandConfigurationPtrOutput() ClusterExecuteCommandConfigurationPtrOutput

func (ClusterExecuteCommandConfigurationOutput) ToClusterExecuteCommandConfigurationPtrOutputWithContext 

func (o ClusterExecuteCommandConfigurationOutput) ToClusterExecuteCommandConfigurationPtrOutputWithContext(ctx context.Context) ClusterExecuteCommandConfigurationPtrOutput

type ClusterExecuteCommandConfigurationPtrInput 

type ClusterExecuteCommandConfigurationPtrInput interface {
	pulumi.Input

	ToClusterExecuteCommandConfigurationPtrOutput() ClusterExecuteCommandConfigurationPtrOutput
	ToClusterExecuteCommandConfigurationPtrOutputWithContext(context.Context) ClusterExecuteCommandConfigurationPtrOutput
}

ClusterExecuteCommandConfigurationPtrInput is an input type that accepts ClusterExecuteCommandConfigurationArgs, ClusterExecuteCommandConfigurationPtr and ClusterExecuteCommandConfigurationPtrOutput values. You can construct a concrete instance of `ClusterExecuteCommandConfigurationPtrInput` via: 

        ClusterExecuteCommandConfigurationArgs{...}

or:

        nil

func ClusterExecuteCommandConfigurationPtr 

func ClusterExecuteCommandConfigurationPtr(v *ClusterExecuteCommandConfigurationArgs) ClusterExecuteCommandConfigurationPtrInput

type ClusterExecuteCommandConfigurationPtrOutput 

type ClusterExecuteCommandConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ClusterExecuteCommandConfigurationPtrOutput) Elem 

func (o ClusterExecuteCommandConfigurationPtrOutput) Elem() ClusterExecuteCommandConfigurationOutput

func (ClusterExecuteCommandConfigurationPtrOutput) ElementType 

func (ClusterExecuteCommandConfigurationPtrOutput) ElementType() reflect.Type

func (ClusterExecuteCommandConfigurationPtrOutput) KmsKeyId 

func (o ClusterExecuteCommandConfigurationPtrOutput) KmsKeyId() pulumi.StringPtrOutput

Specify an KMSlong key ID to encrypt the data between the local client and the container.

func (ClusterExecuteCommandConfigurationPtrOutput) LogConfiguration 

func (o ClusterExecuteCommandConfigurationPtrOutput) LogConfiguration() ClusterExecuteCommandLogConfigurationPtrOutput

The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket. When “logging=OVERRIDE“ is specified, a “logConfiguration“ must be provided.

func (ClusterExecuteCommandConfigurationPtrOutput) Logging 

func (o ClusterExecuteCommandConfigurationPtrOutput) Logging() pulumi.StringPtrOutput

The log setting to use for redirecting logs for your execute command results. The following log settings are available.

  • “NONE“: The execute command session is not logged.
  • “DEFAULT“: The “awslogs“ configuration in the task definition is used. If no logging parameter is specified, it defaults to this value. If no “awslogs“ log driver is configured in the task definition, the output won't be logged.
  • “OVERRIDE“: Specify the logging details as a part of “logConfiguration“. If the “OVERRIDE“ logging option is specified, the “logConfiguration“ is required.

func (ClusterExecuteCommandConfigurationPtrOutput) ToClusterExecuteCommandConfigurationPtrOutput 

func (o ClusterExecuteCommandConfigurationPtrOutput) ToClusterExecuteCommandConfigurationPtrOutput() ClusterExecuteCommandConfigurationPtrOutput

func (ClusterExecuteCommandConfigurationPtrOutput) ToClusterExecuteCommandConfigurationPtrOutputWithContext 

func (o ClusterExecuteCommandConfigurationPtrOutput) ToClusterExecuteCommandConfigurationPtrOutputWithContext(ctx context.Context) ClusterExecuteCommandConfigurationPtrOutput

type ClusterExecuteCommandLogConfiguration 

type ClusterExecuteCommandLogConfiguration struct {
	// Determines whether to use encryption on the CloudWatch logs. If not specified, encryption will be off.
	CloudWatchEncryptionEnabled *bool `pulumi:"cloudWatchEncryptionEnabled"`
	// The name of the CloudWatch log group to send logs to.
	//   The CloudWatch log group must already be created.
	CloudWatchLogGroupName *string `pulumi:"cloudWatchLogGroupName"`
	// The name of the S3 bucket to send logs to.
	//   The S3 bucket must already be created.
	S3BucketName *string `pulumi:"s3BucketName"`
	// Determines whether to use encryption on the S3 logs. If not specified, encryption is not used.
	S3EncryptionEnabled *bool `pulumi:"s3EncryptionEnabled"`
	// An optional folder in the S3 bucket to place logs in.
	S3KeyPrefix *string `pulumi:"s3KeyPrefix"`
}

The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket.

type ClusterExecuteCommandLogConfigurationArgs 

type ClusterExecuteCommandLogConfigurationArgs struct {
	// Determines whether to use encryption on the CloudWatch logs. If not specified, encryption will be off.
	CloudWatchEncryptionEnabled pulumi.BoolPtrInput `pulumi:"cloudWatchEncryptionEnabled"`
	// The name of the CloudWatch log group to send logs to.
	//   The CloudWatch log group must already be created.
	CloudWatchLogGroupName pulumi.StringPtrInput `pulumi:"cloudWatchLogGroupName"`
	// The name of the S3 bucket to send logs to.
	//   The S3 bucket must already be created.
	S3BucketName pulumi.StringPtrInput `pulumi:"s3BucketName"`
	// Determines whether to use encryption on the S3 logs. If not specified, encryption is not used.
	S3EncryptionEnabled pulumi.BoolPtrInput `pulumi:"s3EncryptionEnabled"`
	// An optional folder in the S3 bucket to place logs in.
	S3KeyPrefix pulumi.StringPtrInput `pulumi:"s3KeyPrefix"`
}

The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket.

func (ClusterExecuteCommandLogConfigurationArgs) ElementType 

func (ClusterExecuteCommandLogConfigurationArgs) ElementType() reflect.Type

func (ClusterExecuteCommandLogConfigurationArgs) ToClusterExecuteCommandLogConfigurationOutput 

func (i ClusterExecuteCommandLogConfigurationArgs) ToClusterExecuteCommandLogConfigurationOutput() ClusterExecuteCommandLogConfigurationOutput

func (ClusterExecuteCommandLogConfigurationArgs) ToClusterExecuteCommandLogConfigurationOutputWithContext 

func (i ClusterExecuteCommandLogConfigurationArgs) ToClusterExecuteCommandLogConfigurationOutputWithContext(ctx context.Context) ClusterExecuteCommandLogConfigurationOutput

func (ClusterExecuteCommandLogConfigurationArgs) ToClusterExecuteCommandLogConfigurationPtrOutput 

func (i ClusterExecuteCommandLogConfigurationArgs) ToClusterExecuteCommandLogConfigurationPtrOutput() ClusterExecuteCommandLogConfigurationPtrOutput

func (ClusterExecuteCommandLogConfigurationArgs) ToClusterExecuteCommandLogConfigurationPtrOutputWithContext 

func (i ClusterExecuteCommandLogConfigurationArgs) ToClusterExecuteCommandLogConfigurationPtrOutputWithContext(ctx context.Context) ClusterExecuteCommandLogConfigurationPtrOutput

type ClusterExecuteCommandLogConfigurationInput 

type ClusterExecuteCommandLogConfigurationInput interface {
	pulumi.Input

	ToClusterExecuteCommandLogConfigurationOutput() ClusterExecuteCommandLogConfigurationOutput
	ToClusterExecuteCommandLogConfigurationOutputWithContext(context.Context) ClusterExecuteCommandLogConfigurationOutput
}

ClusterExecuteCommandLogConfigurationInput is an input type that accepts ClusterExecuteCommandLogConfigurationArgs and ClusterExecuteCommandLogConfigurationOutput values. You can construct a concrete instance of `ClusterExecuteCommandLogConfigurationInput` via: 

ClusterExecuteCommandLogConfigurationArgs{...}

type ClusterExecuteCommandLogConfigurationOutput 

type ClusterExecuteCommandLogConfigurationOutput struct{ *pulumi.OutputState }

The log configuration for the results of the execute command actions. The logs can be sent to CloudWatch Logs or an Amazon S3 bucket.

func (ClusterExecuteCommandLogConfigurationOutput) CloudWatchEncryptionEnabled 

func (o ClusterExecuteCommandLogConfigurationOutput) CloudWatchEncryptionEnabled() pulumi.BoolPtrOutput

Determines whether to use encryption on the CloudWatch logs. If not specified, encryption will be off.

func (ClusterExecuteCommandLogConfigurationOutput) CloudWatchLogGroupName 

func (o ClusterExecuteCommandLogConfigurationOutput) CloudWatchLogGroupName() pulumi.StringPtrOutput

The name of the CloudWatch log group to send logs to. 

The CloudWatch log group must already be created.

func (ClusterExecuteCommandLogConfigurationOutput) ElementType 

func (ClusterExecuteCommandLogConfigurationOutput) ElementType() reflect.Type

func (ClusterExecuteCommandLogConfigurationOutput) S3BucketName 

func (o ClusterExecuteCommandLogConfigurationOutput) S3BucketName() pulumi.StringPtrOutput

The name of the S3 bucket to send logs to. 

The S3 bucket must already be created.

func (ClusterExecuteCommandLogConfigurationOutput) S3EncryptionEnabled 

func (o ClusterExecuteCommandLogConfigurationOutput) S3EncryptionEnabled() pulumi.BoolPtrOutput

Determines whether to use encryption on the S3 logs. If not specified, encryption is not used.

func (ClusterExecuteCommandLogConfigurationOutput) S3KeyPrefix 

func (o ClusterExecuteCommandLogConfigurationOutput) S3KeyPrefix() pulumi.StringPtrOutput

An optional folder in the S3 bucket to place logs in.

func (ClusterExecuteCommandLogConfigurationOutput) ToClusterExecuteCommandLogConfigurationOutput 

func (o ClusterExecuteCommandLogConfigurationOutput) ToClusterExecuteCommandLogConfigurationOutput() ClusterExecuteCommandLogConfigurationOutput

func (ClusterExecuteCommandLogConfigurationOutput) ToClusterExecuteCommandLogConfigurationOutputWithContext 

func (o ClusterExecuteCommandLogConfigurationOutput) ToClusterExecuteCommandLogConfigurationOutputWithContext(ctx context.Context) ClusterExecuteCommandLogConfigurationOutput

func (ClusterExecuteCommandLogConfigurationOutput) ToClusterExecuteCommandLogConfigurationPtrOutput 

func (o ClusterExecuteCommandLogConfigurationOutput) ToClusterExecuteCommandLogConfigurationPtrOutput() ClusterExecuteCommandLogConfigurationPtrOutput

func (ClusterExecuteCommandLogConfigurationOutput) ToClusterExecuteCommandLogConfigurationPtrOutputWithContext 

func (o ClusterExecuteCommandLogConfigurationOutput) ToClusterExecuteCommandLogConfigurationPtrOutputWithContext(ctx context.Context) ClusterExecuteCommandLogConfigurationPtrOutput

type ClusterExecuteCommandLogConfigurationPtrInput 

type ClusterExecuteCommandLogConfigurationPtrInput interface {
	pulumi.Input

	ToClusterExecuteCommandLogConfigurationPtrOutput() ClusterExecuteCommandLogConfigurationPtrOutput
	ToClusterExecuteCommandLogConfigurationPtrOutputWithContext(context.Context) ClusterExecuteCommandLogConfigurationPtrOutput
}

ClusterExecuteCommandLogConfigurationPtrInput is an input type that accepts ClusterExecuteCommandLogConfigurationArgs, ClusterExecuteCommandLogConfigurationPtr and ClusterExecuteCommandLogConfigurationPtrOutput values. You can construct a concrete instance of `ClusterExecuteCommandLogConfigurationPtrInput` via: 

        ClusterExecuteCommandLogConfigurationArgs{...}

or:

        nil

func ClusterExecuteCommandLogConfigurationPtr 

func ClusterExecuteCommandLogConfigurationPtr(v *ClusterExecuteCommandLogConfigurationArgs) ClusterExecuteCommandLogConfigurationPtrInput

type ClusterExecuteCommandLogConfigurationPtrOutput 

type ClusterExecuteCommandLogConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ClusterExecuteCommandLogConfigurationPtrOutput) CloudWatchEncryptionEnabled 

func (o ClusterExecuteCommandLogConfigurationPtrOutput) CloudWatchEncryptionEnabled() pulumi.BoolPtrOutput

Determines whether to use encryption on the CloudWatch logs. If not specified, encryption will be off.

func (ClusterExecuteCommandLogConfigurationPtrOutput) CloudWatchLogGroupName 

func (o ClusterExecuteCommandLogConfigurationPtrOutput) CloudWatchLogGroupName() pulumi.StringPtrOutput

The name of the CloudWatch log group to send logs to. 

The CloudWatch log group must already be created.

func (ClusterExecuteCommandLogConfigurationPtrOutput) Elem 

func (o ClusterExecuteCommandLogConfigurationPtrOutput) Elem() ClusterExecuteCommandLogConfigurationOutput

func (ClusterExecuteCommandLogConfigurationPtrOutput) ElementType 

func (ClusterExecuteCommandLogConfigurationPtrOutput) ElementType() reflect.Type

func (ClusterExecuteCommandLogConfigurationPtrOutput) S3BucketName 

func (o ClusterExecuteCommandLogConfigurationPtrOutput) S3BucketName() pulumi.StringPtrOutput

The name of the S3 bucket to send logs to. 

The S3 bucket must already be created.

func (ClusterExecuteCommandLogConfigurationPtrOutput) S3EncryptionEnabled 

func (o ClusterExecuteCommandLogConfigurationPtrOutput) S3EncryptionEnabled() pulumi.BoolPtrOutput

Determines whether to use encryption on the S3 logs. If not specified, encryption is not used.

func (ClusterExecuteCommandLogConfigurationPtrOutput) S3KeyPrefix 

func (o ClusterExecuteCommandLogConfigurationPtrOutput) S3KeyPrefix() pulumi.StringPtrOutput

An optional folder in the S3 bucket to place logs in.

func (ClusterExecuteCommandLogConfigurationPtrOutput) ToClusterExecuteCommandLogConfigurationPtrOutput 

func (o ClusterExecuteCommandLogConfigurationPtrOutput) ToClusterExecuteCommandLogConfigurationPtrOutput() ClusterExecuteCommandLogConfigurationPtrOutput

func (ClusterExecuteCommandLogConfigurationPtrOutput) ToClusterExecuteCommandLogConfigurationPtrOutputWithContext 

func (o ClusterExecuteCommandLogConfigurationPtrOutput) ToClusterExecuteCommandLogConfigurationPtrOutputWithContext(ctx context.Context) ClusterExecuteCommandLogConfigurationPtrOutput

type ClusterInput 

type ClusterInput interface {
	pulumi.Input

	ToClusterOutput() ClusterOutput
	ToClusterOutputWithContext(ctx context.Context) ClusterOutput
}

type ClusterOutput 

type ClusterOutput struct{ *pulumi.OutputState }

func (ClusterOutput) Arn added in v0.17.0 

func (o ClusterOutput) Arn() pulumi.StringOutput

func (ClusterOutput) CapacityProviders added in v0.17.0 

func (o ClusterOutput) CapacityProviders() pulumi.StringArrayOutput

The short name of one or more capacity providers to associate with the cluster. A capacity provider must be associated with a cluster before it can be included as part of the default capacity provider strategy of the cluster or used in a capacity provider strategy when calling the [CreateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html) or [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html) actions. 

If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must be created but not associated with another cluster. New Auto Scaling group capacity providers can be created with the [CreateCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCapacityProvider.html) API operation.
To use a FARGATElong capacity provider, specify either the ``FARGATE`` or ``FARGATE_SPOT`` capacity providers. The FARGATElong capacity providers are available to all accounts and only need to be associated with a cluster to be used.
The [PutCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutCapacityProvider.html) API operation is used to update the list of available capacity providers for a cluster after the cluster is created.

func (ClusterOutput) ClusterName added in v0.17.0 

func (o ClusterOutput) ClusterName() pulumi.StringPtrOutput

A user-generated string that you use to identify your cluster. If you don't specify a name, CFNlong generates a unique physical ID for the name.

func (ClusterOutput) ClusterSettings added in v0.17.0 

func (o ClusterOutput) ClusterSettings() ClusterSettingsArrayOutput

The settings to use when creating a cluster. This parameter is used to turn on CloudWatch Container Insights for a cluster.

func (ClusterOutput) Configuration added in v0.17.0 

func (o ClusterOutput) Configuration() ClusterConfigurationPtrOutput

The execute command configuration for the cluster.

func (ClusterOutput) DefaultCapacityProviderStrategy added in v0.17.0 

func (o ClusterOutput) DefaultCapacityProviderStrategy() ClusterCapacityProviderStrategyItemArrayOutput

The default capacity provider strategy for the cluster. When services or tasks are run in the cluster with no launch type or capacity provider strategy specified, the default capacity provider strategy is used.

func (ClusterOutput) ElementType 

func (ClusterOutput) ElementType() reflect.Type

func (ClusterOutput) ServiceConnectDefaults added in v0.42.0 

func (o ClusterOutput) ServiceConnectDefaults() ClusterServiceConnectDefaultsPtrOutput

Use this parameter to set a default Service Connect namespace. After you set a default Service Connect namespace, any new services with Service Connect turned on that are created in the cluster are added as client services in the namespace. This setting only applies to new services that set the “enabled“ parameter to “true“ in the “ServiceConnectConfiguration“. You can set the namespace of each service individually in the “ServiceConnectConfiguration“ to override this default parameter. 

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ClusterOutput) Tags added in v0.17.0 

func (o ClusterOutput) Tags() aws.TagArrayOutput

The metadata that you apply to the cluster to help you categorize and organize them. Each tag consists of a key and an optional value. You define both. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

func (ClusterOutput) ToClusterOutput 

func (o ClusterOutput) ToClusterOutput() ClusterOutput

func (ClusterOutput) ToClusterOutputWithContext 

func (o ClusterOutput) ToClusterOutputWithContext(ctx context.Context) ClusterOutput

type ClusterServiceConnectDefaults added in v0.42.0 

type ClusterServiceConnectDefaults struct {
	// The namespace name or full Amazon Resource Name (ARN) of the CMAPlong namespace that's used when you create a service and don't specify a Service Connect configuration. The namespace name can include up to 1024 characters. The name is case-sensitive. The name can't include hyphens (-), tilde (~), greater than (>), less than (<), or slash (/).
	//  If you enter an existing namespace name or ARN, then that namespace will be used. Any namespace type is supported. The namespace must be in this account and this AWS Region.
	//  If you enter a new name, a CMAPlong namespace will be created. Amazon ECS creates a CMAP namespace with the "API calls" method of instance discovery only. This instance discovery method is the "HTTP" namespace type in the CLIlong. Other types of instance discovery aren't used by Service Connect.
	//  If you update the cluster with an empty string “""“ for the namespace name, the cluster configuration for Service Connect is removed. Note that the namespace will remain in CMAP and must be deleted separately.
	//  For more information about CMAPlong, see [Working with Services](https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html) in the *Developer Guide*.
	Namespace *string `pulumi:"namespace"`
}

Use this parameter to set a default Service Connect namespace. After you set a default Service Connect namespace, any new services with Service Connect turned on that are created in the cluster are added as client services in the namespace. This setting only applies to new services that set the “enabled“ parameter to “true“ in the “ServiceConnectConfiguration“. You can set the namespace of each service individually in the “ServiceConnectConfiguration“ to override this default parameter. 

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

type ClusterServiceConnectDefaultsArgs added in v0.42.0 

type ClusterServiceConnectDefaultsArgs struct {
	// The namespace name or full Amazon Resource Name (ARN) of the CMAPlong namespace that's used when you create a service and don't specify a Service Connect configuration. The namespace name can include up to 1024 characters. The name is case-sensitive. The name can't include hyphens (-), tilde (~), greater than (>), less than (<), or slash (/).
	//  If you enter an existing namespace name or ARN, then that namespace will be used. Any namespace type is supported. The namespace must be in this account and this AWS Region.
	//  If you enter a new name, a CMAPlong namespace will be created. Amazon ECS creates a CMAP namespace with the "API calls" method of instance discovery only. This instance discovery method is the "HTTP" namespace type in the CLIlong. Other types of instance discovery aren't used by Service Connect.
	//  If you update the cluster with an empty string “""“ for the namespace name, the cluster configuration for Service Connect is removed. Note that the namespace will remain in CMAP and must be deleted separately.
	//  For more information about CMAPlong, see [Working with Services](https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html) in the *Developer Guide*.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
}

Use this parameter to set a default Service Connect namespace. After you set a default Service Connect namespace, any new services with Service Connect turned on that are created in the cluster are added as client services in the namespace. This setting only applies to new services that set the “enabled“ parameter to “true“ in the “ServiceConnectConfiguration“. You can set the namespace of each service individually in the “ServiceConnectConfiguration“ to override this default parameter. 

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ClusterServiceConnectDefaultsArgs) ElementType added in v0.42.0 

func (ClusterServiceConnectDefaultsArgs) ElementType() reflect.Type

func (ClusterServiceConnectDefaultsArgs) ToClusterServiceConnectDefaultsOutput added in v0.42.0 

func (i ClusterServiceConnectDefaultsArgs) ToClusterServiceConnectDefaultsOutput() ClusterServiceConnectDefaultsOutput

func (ClusterServiceConnectDefaultsArgs) ToClusterServiceConnectDefaultsOutputWithContext added in v0.42.0 

func (i ClusterServiceConnectDefaultsArgs) ToClusterServiceConnectDefaultsOutputWithContext(ctx context.Context) ClusterServiceConnectDefaultsOutput

func (ClusterServiceConnectDefaultsArgs) ToClusterServiceConnectDefaultsPtrOutput added in v0.42.0 

func (i ClusterServiceConnectDefaultsArgs) ToClusterServiceConnectDefaultsPtrOutput() ClusterServiceConnectDefaultsPtrOutput

func (ClusterServiceConnectDefaultsArgs) ToClusterServiceConnectDefaultsPtrOutputWithContext added in v0.42.0 

func (i ClusterServiceConnectDefaultsArgs) ToClusterServiceConnectDefaultsPtrOutputWithContext(ctx context.Context) ClusterServiceConnectDefaultsPtrOutput

type ClusterServiceConnectDefaultsInput added in v0.42.0 

type ClusterServiceConnectDefaultsInput interface {
	pulumi.Input

	ToClusterServiceConnectDefaultsOutput() ClusterServiceConnectDefaultsOutput
	ToClusterServiceConnectDefaultsOutputWithContext(context.Context) ClusterServiceConnectDefaultsOutput
}

ClusterServiceConnectDefaultsInput is an input type that accepts ClusterServiceConnectDefaultsArgs and ClusterServiceConnectDefaultsOutput values. You can construct a concrete instance of `ClusterServiceConnectDefaultsInput` via: 

ClusterServiceConnectDefaultsArgs{...}

type ClusterServiceConnectDefaultsOutput added in v0.42.0 

type ClusterServiceConnectDefaultsOutput struct{ *pulumi.OutputState }

Use this parameter to set a default Service Connect namespace. After you set a default Service Connect namespace, any new services with Service Connect turned on that are created in the cluster are added as client services in the namespace. This setting only applies to new services that set the “enabled“ parameter to “true“ in the “ServiceConnectConfiguration“. You can set the namespace of each service individually in the “ServiceConnectConfiguration“ to override this default parameter. 

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ClusterServiceConnectDefaultsOutput) ElementType added in v0.42.0 

func (ClusterServiceConnectDefaultsOutput) ElementType() reflect.Type

func (ClusterServiceConnectDefaultsOutput) Namespace added in v0.42.0 

func (o ClusterServiceConnectDefaultsOutput) Namespace() pulumi.StringPtrOutput

The namespace name or full Amazon Resource Name (ARN) of the CMAPlong namespace that's used when you create a service and don't specify a Service Connect configuration. The namespace name can include up to 1024 characters. The name is case-sensitive. The name can't include hyphens (-), tilde (~), greater than (>), less than (<), or slash (/). 

If you enter an existing namespace name or ARN, then that namespace will be used. Any namespace type is supported. The namespace must be in this account and this AWS Region.
If you enter a new name, a CMAPlong namespace will be created. Amazon ECS creates a CMAP namespace with the "API calls" method of instance discovery only. This instance discovery method is the "HTTP" namespace type in the CLIlong. Other types of instance discovery aren't used by Service Connect.
If you update the cluster with an empty string ``""`` for the namespace name, the cluster configuration for Service Connect is removed. Note that the namespace will remain in CMAP and must be deleted separately.
For more information about CMAPlong, see [Working with Services](https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html) in the *Developer Guide*.

func (ClusterServiceConnectDefaultsOutput) ToClusterServiceConnectDefaultsOutput added in v0.42.0 

func (o ClusterServiceConnectDefaultsOutput) ToClusterServiceConnectDefaultsOutput() ClusterServiceConnectDefaultsOutput

func (ClusterServiceConnectDefaultsOutput) ToClusterServiceConnectDefaultsOutputWithContext added in v0.42.0 

func (o ClusterServiceConnectDefaultsOutput) ToClusterServiceConnectDefaultsOutputWithContext(ctx context.Context) ClusterServiceConnectDefaultsOutput

func (ClusterServiceConnectDefaultsOutput) ToClusterServiceConnectDefaultsPtrOutput added in v0.42.0 

func (o ClusterServiceConnectDefaultsOutput) ToClusterServiceConnectDefaultsPtrOutput() ClusterServiceConnectDefaultsPtrOutput

func (ClusterServiceConnectDefaultsOutput) ToClusterServiceConnectDefaultsPtrOutputWithContext added in v0.42.0 

func (o ClusterServiceConnectDefaultsOutput) ToClusterServiceConnectDefaultsPtrOutputWithContext(ctx context.Context) ClusterServiceConnectDefaultsPtrOutput

type ClusterServiceConnectDefaultsPtrInput added in v0.42.0 

type ClusterServiceConnectDefaultsPtrInput interface {
	pulumi.Input

	ToClusterServiceConnectDefaultsPtrOutput() ClusterServiceConnectDefaultsPtrOutput
	ToClusterServiceConnectDefaultsPtrOutputWithContext(context.Context) ClusterServiceConnectDefaultsPtrOutput
}

ClusterServiceConnectDefaultsPtrInput is an input type that accepts ClusterServiceConnectDefaultsArgs, ClusterServiceConnectDefaultsPtr and ClusterServiceConnectDefaultsPtrOutput values. You can construct a concrete instance of `ClusterServiceConnectDefaultsPtrInput` via: 

        ClusterServiceConnectDefaultsArgs{...}

or:

        nil

func ClusterServiceConnectDefaultsPtr added in v0.42.0 

func ClusterServiceConnectDefaultsPtr(v *ClusterServiceConnectDefaultsArgs) ClusterServiceConnectDefaultsPtrInput

type ClusterServiceConnectDefaultsPtrOutput added in v0.42.0 

type ClusterServiceConnectDefaultsPtrOutput struct{ *pulumi.OutputState }

func (ClusterServiceConnectDefaultsPtrOutput) Elem added in v0.42.0 

func (o ClusterServiceConnectDefaultsPtrOutput) Elem() ClusterServiceConnectDefaultsOutput

func (ClusterServiceConnectDefaultsPtrOutput) ElementType added in v0.42.0 

func (ClusterServiceConnectDefaultsPtrOutput) ElementType() reflect.Type

func (ClusterServiceConnectDefaultsPtrOutput) Namespace added in v0.42.0 

func (o ClusterServiceConnectDefaultsPtrOutput) Namespace() pulumi.StringPtrOutput

The namespace name or full Amazon Resource Name (ARN) of the CMAPlong namespace that's used when you create a service and don't specify a Service Connect configuration. The namespace name can include up to 1024 characters. The name is case-sensitive. The name can't include hyphens (-), tilde (~), greater than (>), less than (<), or slash (/). 

If you enter an existing namespace name or ARN, then that namespace will be used. Any namespace type is supported. The namespace must be in this account and this AWS Region.
If you enter a new name, a CMAPlong namespace will be created. Amazon ECS creates a CMAP namespace with the "API calls" method of instance discovery only. This instance discovery method is the "HTTP" namespace type in the CLIlong. Other types of instance discovery aren't used by Service Connect.
If you update the cluster with an empty string ``""`` for the namespace name, the cluster configuration for Service Connect is removed. Note that the namespace will remain in CMAP and must be deleted separately.
For more information about CMAPlong, see [Working with Services](https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html) in the *Developer Guide*.

func (ClusterServiceConnectDefaultsPtrOutput) ToClusterServiceConnectDefaultsPtrOutput added in v0.42.0 

func (o ClusterServiceConnectDefaultsPtrOutput) ToClusterServiceConnectDefaultsPtrOutput() ClusterServiceConnectDefaultsPtrOutput

func (ClusterServiceConnectDefaultsPtrOutput) ToClusterServiceConnectDefaultsPtrOutputWithContext added in v0.42.0 

func (o ClusterServiceConnectDefaultsPtrOutput) ToClusterServiceConnectDefaultsPtrOutputWithContext(ctx context.Context) ClusterServiceConnectDefaultsPtrOutput

type ClusterSettings added in v0.2.0 

type ClusterSettings struct {
	// The name of the cluster setting. The value is “containerInsights“ .
	Name *string `pulumi:"name"`
	// The value to set for the cluster setting. The supported values are “enabled“ and “disabled“.
	//  If you set “name“ to “containerInsights“ and “value“ to “enabled“, CloudWatch Container Insights will be on for the cluster, otherwise it will be off unless the “containerInsights“ account setting is turned on. If a cluster value is specified, it will override the “containerInsights“ value set with [PutAccountSetting](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSetting.html) or [PutAccountSettingDefault](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSettingDefault.html).
	Value *string `pulumi:"value"`
}

The settings to use when creating a cluster. This parameter is used to turn on CloudWatch Container Insights for a cluster.

type ClusterSettingsArgs added in v0.2.0 

type ClusterSettingsArgs struct {
	// The name of the cluster setting. The value is “containerInsights“ .
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The value to set for the cluster setting. The supported values are “enabled“ and “disabled“.
	//  If you set “name“ to “containerInsights“ and “value“ to “enabled“, CloudWatch Container Insights will be on for the cluster, otherwise it will be off unless the “containerInsights“ account setting is turned on. If a cluster value is specified, it will override the “containerInsights“ value set with [PutAccountSetting](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSetting.html) or [PutAccountSettingDefault](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSettingDefault.html).
	Value pulumi.StringPtrInput `pulumi:"value"`
}

The settings to use when creating a cluster. This parameter is used to turn on CloudWatch Container Insights for a cluster.

func (ClusterSettingsArgs) ElementType added in v0.2.0 

func (ClusterSettingsArgs) ElementType() reflect.Type

func (ClusterSettingsArgs) ToClusterSettingsOutput added in v0.2.0 

func (i ClusterSettingsArgs) ToClusterSettingsOutput() ClusterSettingsOutput

func (ClusterSettingsArgs) ToClusterSettingsOutputWithContext added in v0.2.0 

func (i ClusterSettingsArgs) ToClusterSettingsOutputWithContext(ctx context.Context) ClusterSettingsOutput

type ClusterSettingsArray added in v0.2.0 

type ClusterSettingsArray []ClusterSettingsInput

func (ClusterSettingsArray) ElementType added in v0.2.0 

func (ClusterSettingsArray) ElementType() reflect.Type

func (ClusterSettingsArray) ToClusterSettingsArrayOutput added in v0.2.0 

func (i ClusterSettingsArray) ToClusterSettingsArrayOutput() ClusterSettingsArrayOutput

func (ClusterSettingsArray) ToClusterSettingsArrayOutputWithContext added in v0.2.0 

func (i ClusterSettingsArray) ToClusterSettingsArrayOutputWithContext(ctx context.Context) ClusterSettingsArrayOutput

type ClusterSettingsArrayInput added in v0.2.0 

type ClusterSettingsArrayInput interface {
	pulumi.Input

	ToClusterSettingsArrayOutput() ClusterSettingsArrayOutput
	ToClusterSettingsArrayOutputWithContext(context.Context) ClusterSettingsArrayOutput
}

ClusterSettingsArrayInput is an input type that accepts ClusterSettingsArray and ClusterSettingsArrayOutput values. You can construct a concrete instance of `ClusterSettingsArrayInput` via: 

ClusterSettingsArray{ ClusterSettingsArgs{...} }

type ClusterSettingsArrayOutput added in v0.2.0 

type ClusterSettingsArrayOutput struct{ *pulumi.OutputState }

func (ClusterSettingsArrayOutput) ElementType added in v0.2.0 

func (ClusterSettingsArrayOutput) ElementType() reflect.Type

func (ClusterSettingsArrayOutput) Index added in v0.2.0 

func (o ClusterSettingsArrayOutput) Index(i pulumi.IntInput) ClusterSettingsOutput

func (ClusterSettingsArrayOutput) ToClusterSettingsArrayOutput added in v0.2.0 

func (o ClusterSettingsArrayOutput) ToClusterSettingsArrayOutput() ClusterSettingsArrayOutput

func (ClusterSettingsArrayOutput) ToClusterSettingsArrayOutputWithContext added in v0.2.0 

func (o ClusterSettingsArrayOutput) ToClusterSettingsArrayOutputWithContext(ctx context.Context) ClusterSettingsArrayOutput

type ClusterSettingsInput added in v0.2.0 

type ClusterSettingsInput interface {
	pulumi.Input

	ToClusterSettingsOutput() ClusterSettingsOutput
	ToClusterSettingsOutputWithContext(context.Context) ClusterSettingsOutput
}

ClusterSettingsInput is an input type that accepts ClusterSettingsArgs and ClusterSettingsOutput values. You can construct a concrete instance of `ClusterSettingsInput` via: 

ClusterSettingsArgs{...}

type ClusterSettingsOutput added in v0.2.0 

type ClusterSettingsOutput struct{ *pulumi.OutputState }

The settings to use when creating a cluster. This parameter is used to turn on CloudWatch Container Insights for a cluster.

func (ClusterSettingsOutput) ElementType added in v0.2.0 

func (ClusterSettingsOutput) ElementType() reflect.Type

func (ClusterSettingsOutput) Name added in v0.2.0 

func (o ClusterSettingsOutput) Name() pulumi.StringPtrOutput

The name of the cluster setting. The value is “containerInsights“ .

func (ClusterSettingsOutput) ToClusterSettingsOutput added in v0.2.0 

func (o ClusterSettingsOutput) ToClusterSettingsOutput() ClusterSettingsOutput

func (ClusterSettingsOutput) ToClusterSettingsOutputWithContext added in v0.2.0 

func (o ClusterSettingsOutput) ToClusterSettingsOutputWithContext(ctx context.Context) ClusterSettingsOutput

func (ClusterSettingsOutput) Value added in v0.2.0 

func (o ClusterSettingsOutput) Value() pulumi.StringPtrOutput

The value to set for the cluster setting. The supported values are “enabled“ and “disabled“. 

If you set ``name`` to ``containerInsights`` and ``value`` to ``enabled``, CloudWatch Container Insights will be on for the cluster, otherwise it will be off unless the ``containerInsights`` account setting is turned on. If a cluster value is specified, it will override the ``containerInsights`` value set with [PutAccountSetting](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSetting.html) or [PutAccountSettingDefault](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutAccountSettingDefault.html).

type ClusterState 

type ClusterState struct {
}

func (ClusterState) ElementType 

func (ClusterState) ElementType() reflect.Type

type ClusterTag 

type ClusterTag struct {
	// One part of a key-value pair that make up a tag. A “key“ is a general label that acts like a category for more specific tag values.
	Key *string `pulumi:"key"`
	// The optional part of a key-value pair that make up a tag. A “value“ acts as a descriptor within a tag category (key).
	Value *string `pulumi:"value"`
}

The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value. You define them. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

type LookupCapacityProviderArgs added in v0.12.0 

type LookupCapacityProviderArgs struct {
	Name string `pulumi:"name"`
}

type LookupCapacityProviderOutputArgs added in v0.12.0 

type LookupCapacityProviderOutputArgs struct {
	Name pulumi.StringInput `pulumi:"name"`
}

func (LookupCapacityProviderOutputArgs) ElementType added in v0.12.0 

func (LookupCapacityProviderOutputArgs) ElementType() reflect.Type

type LookupCapacityProviderResult added in v0.12.0 

type LookupCapacityProviderResult struct {
	AutoScalingGroupProvider *CapacityProviderAutoScalingGroupProvider `pulumi:"autoScalingGroupProvider"`
	Tags                     []aws.Tag                                 `pulumi:"tags"`
}

func LookupCapacityProvider added in v0.12.0 

func LookupCapacityProvider(ctx *pulumi.Context, args *LookupCapacityProviderArgs, opts ...pulumi.InvokeOption) (*LookupCapacityProviderResult, error)

Resource Type definition for AWS::ECS::CapacityProvider.

type LookupCapacityProviderResultOutput added in v0.12.0 

type LookupCapacityProviderResultOutput struct{ *pulumi.OutputState }

func LookupCapacityProviderOutput added in v0.12.0 

func LookupCapacityProviderOutput(ctx *pulumi.Context, args LookupCapacityProviderOutputArgs, opts ...pulumi.InvokeOption) LookupCapacityProviderResultOutput

func (LookupCapacityProviderResultOutput) AutoScalingGroupProvider added in v0.12.0 

func (o LookupCapacityProviderResultOutput) AutoScalingGroupProvider() CapacityProviderAutoScalingGroupProviderPtrOutput

func (LookupCapacityProviderResultOutput) ElementType added in v0.12.0 

func (LookupCapacityProviderResultOutput) ElementType() reflect.Type

func (LookupCapacityProviderResultOutput) Tags added in v0.12.0 

func (o LookupCapacityProviderResultOutput) Tags() aws.TagArrayOutput

func (LookupCapacityProviderResultOutput) ToLookupCapacityProviderResultOutput added in v0.12.0 

func (o LookupCapacityProviderResultOutput) ToLookupCapacityProviderResultOutput() LookupCapacityProviderResultOutput

func (LookupCapacityProviderResultOutput) ToLookupCapacityProviderResultOutputWithContext added in v0.12.0 

func (o LookupCapacityProviderResultOutput) ToLookupCapacityProviderResultOutputWithContext(ctx context.Context) LookupCapacityProviderResultOutput

type LookupClusterArgs added in v0.12.0 

type LookupClusterArgs struct {
	// A user-generated string that you use to identify your cluster. If you don't specify a name, CFNlong generates a unique physical ID for the name.
	ClusterName string `pulumi:"clusterName"`
}

type LookupClusterCapacityProviderAssociationsArgs added in v0.12.0 

type LookupClusterCapacityProviderAssociationsArgs struct {
	Cluster string `pulumi:"cluster"`
}

type LookupClusterCapacityProviderAssociationsOutputArgs added in v0.12.0 

type LookupClusterCapacityProviderAssociationsOutputArgs struct {
	Cluster pulumi.StringInput `pulumi:"cluster"`
}

func (LookupClusterCapacityProviderAssociationsOutputArgs) ElementType added in v0.12.0 

func (LookupClusterCapacityProviderAssociationsOutputArgs) ElementType() reflect.Type

type LookupClusterCapacityProviderAssociationsResult added in v0.12.0 

type LookupClusterCapacityProviderAssociationsResult struct {
	CapacityProviders               []string                                                      `pulumi:"capacityProviders"`
	DefaultCapacityProviderStrategy []ClusterCapacityProviderAssociationsCapacityProviderStrategy `pulumi:"defaultCapacityProviderStrategy"`
}

func LookupClusterCapacityProviderAssociations added in v0.12.0 

func LookupClusterCapacityProviderAssociations(ctx *pulumi.Context, args *LookupClusterCapacityProviderAssociationsArgs, opts ...pulumi.InvokeOption) (*LookupClusterCapacityProviderAssociationsResult, error)

Associate a set of ECS Capacity Providers with a specified ECS Cluster

type LookupClusterCapacityProviderAssociationsResultOutput added in v0.12.0 

type LookupClusterCapacityProviderAssociationsResultOutput struct{ *pulumi.OutputState }

func LookupClusterCapacityProviderAssociationsOutput added in v0.12.0 

func LookupClusterCapacityProviderAssociationsOutput(ctx *pulumi.Context, args LookupClusterCapacityProviderAssociationsOutputArgs, opts ...pulumi.InvokeOption) LookupClusterCapacityProviderAssociationsResultOutput

func (LookupClusterCapacityProviderAssociationsResultOutput) CapacityProviders added in v0.12.0 

func (o LookupClusterCapacityProviderAssociationsResultOutput) CapacityProviders() pulumi.StringArrayOutput

func (LookupClusterCapacityProviderAssociationsResultOutput) DefaultCapacityProviderStrategy added in v0.12.0 

func (o LookupClusterCapacityProviderAssociationsResultOutput) DefaultCapacityProviderStrategy() ClusterCapacityProviderAssociationsCapacityProviderStrategyArrayOutput

func (LookupClusterCapacityProviderAssociationsResultOutput) ElementType added in v0.12.0 

func (LookupClusterCapacityProviderAssociationsResultOutput) ElementType() reflect.Type

func (LookupClusterCapacityProviderAssociationsResultOutput) ToLookupClusterCapacityProviderAssociationsResultOutput added in v0.12.0 

func (o LookupClusterCapacityProviderAssociationsResultOutput) ToLookupClusterCapacityProviderAssociationsResultOutput() LookupClusterCapacityProviderAssociationsResultOutput

func (LookupClusterCapacityProviderAssociationsResultOutput) ToLookupClusterCapacityProviderAssociationsResultOutputWithContext added in v0.12.0 

func (o LookupClusterCapacityProviderAssociationsResultOutput) ToLookupClusterCapacityProviderAssociationsResultOutputWithContext(ctx context.Context) LookupClusterCapacityProviderAssociationsResultOutput

type LookupClusterOutputArgs added in v0.12.0 

type LookupClusterOutputArgs struct {
	// A user-generated string that you use to identify your cluster. If you don't specify a name, CFNlong generates a unique physical ID for the name.
	ClusterName pulumi.StringInput `pulumi:"clusterName"`
}

func (LookupClusterOutputArgs) ElementType added in v0.12.0 

func (LookupClusterOutputArgs) ElementType() reflect.Type

type LookupClusterResult added in v0.12.0 

type LookupClusterResult struct {
	Arn *string `pulumi:"arn"`
	// The short name of one or more capacity providers to associate with the cluster. A capacity provider must be associated with a cluster before it can be included as part of the default capacity provider strategy of the cluster or used in a capacity provider strategy when calling the [CreateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html) or [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html) actions.
	//  If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must be created but not associated with another cluster. New Auto Scaling group capacity providers can be created with the [CreateCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCapacityProvider.html) API operation.
	//  To use a FARGATElong capacity provider, specify either the “FARGATE“ or “FARGATE_SPOT“ capacity providers. The FARGATElong capacity providers are available to all accounts and only need to be associated with a cluster to be used.
	//  The [PutCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutCapacityProvider.html) API operation is used to update the list of available capacity providers for a cluster after the cluster is created.
	CapacityProviders []string `pulumi:"capacityProviders"`
	// The settings to use when creating a cluster. This parameter is used to turn on CloudWatch Container Insights for a cluster.
	ClusterSettings []ClusterSettings `pulumi:"clusterSettings"`
	// The execute command configuration for the cluster.
	Configuration *ClusterConfiguration `pulumi:"configuration"`
	// The default capacity provider strategy for the cluster. When services or tasks are run in the cluster with no launch type or capacity provider strategy specified, the default capacity provider strategy is used.
	DefaultCapacityProviderStrategy []ClusterCapacityProviderStrategyItem `pulumi:"defaultCapacityProviderStrategy"`
	// The metadata that you apply to the cluster to help you categorize and organize them. Each tag consists of a key and an optional value. You define both.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags []aws.Tag `pulumi:"tags"`
}

func LookupCluster added in v0.12.0 

func LookupCluster(ctx *pulumi.Context, args *LookupClusterArgs, opts ...pulumi.InvokeOption) (*LookupClusterResult, error)

The “AWS::ECS::Cluster“ resource creates an Amazon Elastic Container Service (Amazon ECS) cluster.

type LookupClusterResultOutput added in v0.12.0 

type LookupClusterResultOutput struct{ *pulumi.OutputState }

func LookupClusterOutput added in v0.12.0 

func LookupClusterOutput(ctx *pulumi.Context, args LookupClusterOutputArgs, opts ...pulumi.InvokeOption) LookupClusterResultOutput

func (LookupClusterResultOutput) Arn added in v0.12.0 

func (o LookupClusterResultOutput) Arn() pulumi.StringPtrOutput

func (LookupClusterResultOutput) CapacityProviders added in v0.12.0 

func (o LookupClusterResultOutput) CapacityProviders() pulumi.StringArrayOutput

The short name of one or more capacity providers to associate with the cluster. A capacity provider must be associated with a cluster before it can be included as part of the default capacity provider strategy of the cluster or used in a capacity provider strategy when calling the [CreateService](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateService.html) or [RunTask](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html) actions. 

If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must be created but not associated with another cluster. New Auto Scaling group capacity providers can be created with the [CreateCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_CreateCapacityProvider.html) API operation.
To use a FARGATElong capacity provider, specify either the ``FARGATE`` or ``FARGATE_SPOT`` capacity providers. The FARGATElong capacity providers are available to all accounts and only need to be associated with a cluster to be used.
The [PutCapacityProvider](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_PutCapacityProvider.html) API operation is used to update the list of available capacity providers for a cluster after the cluster is created.

func (LookupClusterResultOutput) ClusterSettings added in v0.12.0 

func (o LookupClusterResultOutput) ClusterSettings() ClusterSettingsArrayOutput

The settings to use when creating a cluster. This parameter is used to turn on CloudWatch Container Insights for a cluster.

func (LookupClusterResultOutput) Configuration added in v0.12.0 

func (o LookupClusterResultOutput) Configuration() ClusterConfigurationPtrOutput

The execute command configuration for the cluster.

func (LookupClusterResultOutput) DefaultCapacityProviderStrategy added in v0.12.0 

func (o LookupClusterResultOutput) DefaultCapacityProviderStrategy() ClusterCapacityProviderStrategyItemArrayOutput

The default capacity provider strategy for the cluster. When services or tasks are run in the cluster with no launch type or capacity provider strategy specified, the default capacity provider strategy is used.

func (LookupClusterResultOutput) ElementType added in v0.12.0 

func (LookupClusterResultOutput) ElementType() reflect.Type

func (LookupClusterResultOutput) Tags added in v0.12.0 

func (o LookupClusterResultOutput) Tags() aws.TagArrayOutput

The metadata that you apply to the cluster to help you categorize and organize them. Each tag consists of a key and an optional value. You define both. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

func (LookupClusterResultOutput) ToLookupClusterResultOutput added in v0.12.0 

func (o LookupClusterResultOutput) ToLookupClusterResultOutput() LookupClusterResultOutput

func (LookupClusterResultOutput) ToLookupClusterResultOutputWithContext added in v0.12.0 

func (o LookupClusterResultOutput) ToLookupClusterResultOutputWithContext(ctx context.Context) LookupClusterResultOutput

type LookupPrimaryTaskSetArgs added in v0.12.0 

type LookupPrimaryTaskSetArgs struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
	Cluster string `pulumi:"cluster"`
	// The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
	Service string `pulumi:"service"`
}

type LookupPrimaryTaskSetOutputArgs added in v0.12.0 

type LookupPrimaryTaskSetOutputArgs struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
	Cluster pulumi.StringInput `pulumi:"cluster"`
	// The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
	Service pulumi.StringInput `pulumi:"service"`
}

func (LookupPrimaryTaskSetOutputArgs) ElementType added in v0.12.0 

func (LookupPrimaryTaskSetOutputArgs) ElementType() reflect.Type

type LookupPrimaryTaskSetResult added in v0.12.0 

type LookupPrimaryTaskSetResult struct {
	// The ID or full Amazon Resource Name (ARN) of the task set.
	TaskSetId *string `pulumi:"taskSetId"`
}

func LookupPrimaryTaskSet added in v0.12.0 

func LookupPrimaryTaskSet(ctx *pulumi.Context, args *LookupPrimaryTaskSetArgs, opts ...pulumi.InvokeOption) (*LookupPrimaryTaskSetResult, error)

A pseudo-resource that manages which of your ECS task sets is primary.

type LookupPrimaryTaskSetResultOutput added in v0.12.0 

type LookupPrimaryTaskSetResultOutput struct{ *pulumi.OutputState }

func LookupPrimaryTaskSetOutput added in v0.12.0 

func LookupPrimaryTaskSetOutput(ctx *pulumi.Context, args LookupPrimaryTaskSetOutputArgs, opts ...pulumi.InvokeOption) LookupPrimaryTaskSetResultOutput

func (LookupPrimaryTaskSetResultOutput) ElementType added in v0.12.0 

func (LookupPrimaryTaskSetResultOutput) ElementType() reflect.Type

func (LookupPrimaryTaskSetResultOutput) TaskSetId added in v0.12.0 

func (o LookupPrimaryTaskSetResultOutput) TaskSetId() pulumi.StringPtrOutput

The ID or full Amazon Resource Name (ARN) of the task set.

func (LookupPrimaryTaskSetResultOutput) ToLookupPrimaryTaskSetResultOutput added in v0.12.0 

func (o LookupPrimaryTaskSetResultOutput) ToLookupPrimaryTaskSetResultOutput() LookupPrimaryTaskSetResultOutput

func (LookupPrimaryTaskSetResultOutput) ToLookupPrimaryTaskSetResultOutputWithContext added in v0.12.0 

func (o LookupPrimaryTaskSetResultOutput) ToLookupPrimaryTaskSetResultOutputWithContext(ctx context.Context) LookupPrimaryTaskSetResultOutput

type LookupServiceArgs added in v0.12.0 

type LookupServiceArgs struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.
	Cluster    string `pulumi:"cluster"`
	ServiceArn string `pulumi:"serviceArn"`
}

type LookupServiceOutputArgs added in v0.12.0 

type LookupServiceOutputArgs struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.
	Cluster    pulumi.StringInput `pulumi:"cluster"`
	ServiceArn pulumi.StringInput `pulumi:"serviceArn"`
}

func (LookupServiceOutputArgs) ElementType added in v0.12.0 

func (LookupServiceOutputArgs) ElementType() reflect.Type

type LookupServiceResult added in v0.12.0 

type LookupServiceResult struct {
	// The capacity provider strategy to use for the service.
	//  If a “capacityProviderStrategy“ is specified, the “launchType“ parameter must be omitted. If no “capacityProviderStrategy“ or “launchType“ is specified, the “defaultCapacityProviderStrategy“ for the cluster is used.
	//  A capacity provider strategy may contain a maximum of 6 capacity providers.
	CapacityProviderStrategy []ServiceCapacityProviderStrategyItem `pulumi:"capacityProviderStrategy"`
	// Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.
	DeploymentConfiguration *ServiceDeploymentConfiguration `pulumi:"deploymentConfiguration"`
	// The number of instantiations of the specified task definition to place and keep running in your service.
	//  For new services, if a desired count is not specified, a default value of “1“ is used. When using the “DAEMON“ scheduling strategy, the desired count is not required.
	//  For existing services, if a desired count is not specified, it is omitted from the operation.
	DesiredCount *int `pulumi:"desiredCount"`
	// Specifies whether to turn on Amazon ECS managed tags for the tasks within the service. For more information, see [Tagging your Amazon ECS resources](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  When you use Amazon ECS managed tags, you need to set the “propagateTags“ request parameter.
	EnableEcsManagedTags *bool `pulumi:"enableEcsManagedTags"`
	// Determines whether the execute command functionality is turned on for the service. If “true“, the execute command functionality is turned on for all containers in tasks as part of the service.
	EnableExecuteCommand *bool `pulumi:"enableExecuteCommand"`
	// The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. This is only used when your service is configured to use a load balancer. If your service has a load balancer defined and you don't specify a health check grace period value, the default value of “0“ is used.
	//  If you do not use an Elastic Load Balancing, we recommend that you use the “startPeriod“ in the task definition health check parameters. For more information, see [Health check](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html).
	//  If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
	HealthCheckGracePeriodSeconds *int `pulumi:"healthCheckGracePeriodSeconds"`
	// A list of load balancer objects to associate with the service. If you specify the “Role“ property, “LoadBalancers“ must be specified as well. For information about the number of load balancers that you can specify per service, see [Service Load Balancing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html) in the *Amazon Elastic Container Service Developer Guide*.
	LoadBalancers []ServiceLoadBalancer `pulumi:"loadBalancers"`
	Name          *string               `pulumi:"name"`
	// The network configuration for the service. This parameter is required for task definitions that use the “awsvpc“ network mode to receive their own elastic network interface, and it is not supported for other network modes. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.
	NetworkConfiguration *ServiceNetworkConfiguration `pulumi:"networkConfiguration"`
	// An array of placement constraint objects to use for tasks in your service. You can specify a maximum of 10 constraints for each task. This limit includes constraints in the task definition and those specified at runtime.
	PlacementConstraints []ServicePlacementConstraint `pulumi:"placementConstraints"`
	// The placement strategy objects to use for tasks in your service. You can specify a maximum of 5 strategy rules for each service.
	PlacementStrategies []ServicePlacementStrategy `pulumi:"placementStrategies"`
	// The platform version that your tasks in the service are running on. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the “LATEST“ platform version is used. For more information, see [platform versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) in the *Amazon Elastic Container Service Developer Guide*.
	PlatformVersion *string `pulumi:"platformVersion"`
	// Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the task during task creation. To add tags to a task after task creation, use the [TagResource](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html) API action.
	//  The default is “NONE“.
	PropagateTags *ServicePropagateTags `pulumi:"propagateTags"`
	ServiceArn    *string               `pulumi:"serviceArn"`
	// The details of the service discovery registry to associate with this service. For more information, see [Service discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html).
	//   Each service may be associated with one service registry. Multiple service registries for each service isn't supported.
	ServiceRegistries []ServiceRegistry `pulumi:"serviceRegistries"`
	// The metadata that you apply to the service to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. When a service is deleted, the tags are deleted as well.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags []aws.Tag `pulumi:"tags"`
	// The “family“ and “revision“ (“family:revision“) or full ARN of the task definition to run in your service. If a “revision“ isn't specified, the latest “ACTIVE“ revision is used.
	//  A task definition must be specified if the service uses either the “ECS“ or “CODE_DEPLOY“ deployment controllers.
	//  For more information about deployment types, see [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html).
	TaskDefinition *string `pulumi:"taskDefinition"`
}

func LookupService added in v0.12.0 

func LookupService(ctx *pulumi.Context, args *LookupServiceArgs, opts ...pulumi.InvokeOption) (*LookupServiceResult, error)

The “AWS::ECS::Service“ resource creates an Amazon Elastic Container Service (Amazon ECS) service that runs and maintains the requested number of tasks and associated load balancers. 

The stack update fails if you change any properties that require replacement and at least one Amazon ECS Service Connect ``ServiceConnectService`` is configured. This is because AWS CloudFormation creates the replacement service first, but each ``ServiceConnectService`` must have a name that is unique in the namespace.
Starting April 15, 2023, AWS; will not onboard new customers to Amazon Elastic Inference (EI), and will help current customers migrate their workloads to options that offer better price and performance. After April 15, 2023, new customers will not be able to launch instances with Amazon EI accelerators in Amazon SageMaker, ECS, or EC2. However, customers who have used Amazon EI at least once during the past 30-day period are considered current customers and will be able to continue using the service.

type LookupServiceResultOutput added in v0.12.0 

type LookupServiceResultOutput struct{ *pulumi.OutputState }

func LookupServiceOutput added in v0.12.0 

func LookupServiceOutput(ctx *pulumi.Context, args LookupServiceOutputArgs, opts ...pulumi.InvokeOption) LookupServiceResultOutput

func (LookupServiceResultOutput) CapacityProviderStrategy added in v0.12.0 

func (o LookupServiceResultOutput) CapacityProviderStrategy() ServiceCapacityProviderStrategyItemArrayOutput

The capacity provider strategy to use for the service. 

If a ``capacityProviderStrategy`` is specified, the ``launchType`` parameter must be omitted. If no ``capacityProviderStrategy`` or ``launchType`` is specified, the ``defaultCapacityProviderStrategy`` for the cluster is used.
A capacity provider strategy may contain a maximum of 6 capacity providers.

func (LookupServiceResultOutput) DeploymentConfiguration added in v0.12.0 

func (o LookupServiceResultOutput) DeploymentConfiguration() ServiceDeploymentConfigurationPtrOutput

Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.

func (LookupServiceResultOutput) DesiredCount added in v0.12.0 

func (o LookupServiceResultOutput) DesiredCount() pulumi.IntPtrOutput

The number of instantiations of the specified task definition to place and keep running in your service. 

For new services, if a desired count is not specified, a default value of ``1`` is used. When using the ``DAEMON`` scheduling strategy, the desired count is not required.
For existing services, if a desired count is not specified, it is omitted from the operation.

func (LookupServiceResultOutput) ElementType added in v0.12.0 

func (LookupServiceResultOutput) ElementType() reflect.Type

func (LookupServiceResultOutput) EnableEcsManagedTags added in v0.72.0 

func (o LookupServiceResultOutput) EnableEcsManagedTags() pulumi.BoolPtrOutput

Specifies whether to turn on Amazon ECS managed tags for the tasks within the service. For more information, see [Tagging your Amazon ECS resources](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html) in the *Amazon Elastic Container Service Developer Guide*. 

When you use Amazon ECS managed tags, you need to set the ``propagateTags`` request parameter.

func (LookupServiceResultOutput) EnableExecuteCommand added in v0.12.0 

func (o LookupServiceResultOutput) EnableExecuteCommand() pulumi.BoolPtrOutput

Determines whether the execute command functionality is turned on for the service. If “true“, the execute command functionality is turned on for all containers in tasks as part of the service.

func (LookupServiceResultOutput) HealthCheckGracePeriodSeconds added in v0.12.0 

func (o LookupServiceResultOutput) HealthCheckGracePeriodSeconds() pulumi.IntPtrOutput

The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. This is only used when your service is configured to use a load balancer. If your service has a load balancer defined and you don't specify a health check grace period value, the default value of “0“ is used. 

If you do not use an Elastic Load Balancing, we recommend that you use the ``startPeriod`` in the task definition health check parameters. For more information, see [Health check](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html).
If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.

func (LookupServiceResultOutput) LoadBalancers added in v0.14.0 

func (o LookupServiceResultOutput) LoadBalancers() ServiceLoadBalancerArrayOutput

A list of load balancer objects to associate with the service. If you specify the “Role“ property, “LoadBalancers“ must be specified as well. For information about the number of load balancers that you can specify per service, see [Service Load Balancing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html) in the *Amazon Elastic Container Service Developer Guide*.

func (LookupServiceResultOutput) Name added in v0.12.0 

func (o LookupServiceResultOutput) Name() pulumi.StringPtrOutput

func (LookupServiceResultOutput) NetworkConfiguration added in v0.12.0 

func (o LookupServiceResultOutput) NetworkConfiguration() ServiceNetworkConfigurationPtrOutput

The network configuration for the service. This parameter is required for task definitions that use the “awsvpc“ network mode to receive their own elastic network interface, and it is not supported for other network modes. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.

func (LookupServiceResultOutput) PlacementConstraints added in v0.15.0 

func (o LookupServiceResultOutput) PlacementConstraints() ServicePlacementConstraintArrayOutput

An array of placement constraint objects to use for tasks in your service. You can specify a maximum of 10 constraints for each task. This limit includes constraints in the task definition and those specified at runtime.

func (LookupServiceResultOutput) PlacementStrategies added in v0.15.0 

func (o LookupServiceResultOutput) PlacementStrategies() ServicePlacementStrategyArrayOutput

The placement strategy objects to use for tasks in your service. You can specify a maximum of 5 strategy rules for each service.

func (LookupServiceResultOutput) PlatformVersion added in v0.12.0 

func (o LookupServiceResultOutput) PlatformVersion() pulumi.StringPtrOutput

The platform version that your tasks in the service are running on. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the “LATEST“ platform version is used. For more information, see [platform versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) in the *Amazon Elastic Container Service Developer Guide*.

func (LookupServiceResultOutput) PropagateTags added in v0.14.0 

func (o LookupServiceResultOutput) PropagateTags() ServicePropagateTagsPtrOutput

Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the task during task creation. To add tags to a task after task creation, use the [TagResource](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html) API action. 

The default is ``NONE``.

func (LookupServiceResultOutput) ServiceArn added in v0.12.0 

func (o LookupServiceResultOutput) ServiceArn() pulumi.StringPtrOutput

func (LookupServiceResultOutput) ServiceRegistries added in v0.14.0 

func (o LookupServiceResultOutput) ServiceRegistries() ServiceRegistryArrayOutput

The details of the service discovery registry to associate with this service. For more information, see [Service discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). 

Each service may be associated with one service registry. Multiple service registries for each service isn't supported.

func (LookupServiceResultOutput) Tags added in v0.12.0 

func (o LookupServiceResultOutput) Tags() aws.TagArrayOutput

The metadata that you apply to the service to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. When a service is deleted, the tags are deleted as well. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

func (LookupServiceResultOutput) TaskDefinition added in v0.12.0 

func (o LookupServiceResultOutput) TaskDefinition() pulumi.StringPtrOutput

The “family“ and “revision“ (“family:revision“) or full ARN of the task definition to run in your service. If a “revision“ isn't specified, the latest “ACTIVE“ revision is used. 

A task definition must be specified if the service uses either the ``ECS`` or ``CODE_DEPLOY`` deployment controllers.
For more information about deployment types, see [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html).

func (LookupServiceResultOutput) ToLookupServiceResultOutput added in v0.12.0 

func (o LookupServiceResultOutput) ToLookupServiceResultOutput() LookupServiceResultOutput

func (LookupServiceResultOutput) ToLookupServiceResultOutputWithContext added in v0.12.0 

func (o LookupServiceResultOutput) ToLookupServiceResultOutputWithContext(ctx context.Context) LookupServiceResultOutput

type LookupTaskDefinitionArgs added in v0.12.0 

type LookupTaskDefinitionArgs struct {
	TaskDefinitionArn string `pulumi:"taskDefinitionArn"`
}

type LookupTaskDefinitionOutputArgs added in v0.12.0 

type LookupTaskDefinitionOutputArgs struct {
	TaskDefinitionArn pulumi.StringInput `pulumi:"taskDefinitionArn"`
}

func (LookupTaskDefinitionOutputArgs) ElementType added in v0.12.0 

func (LookupTaskDefinitionOutputArgs) ElementType() reflect.Type

type LookupTaskDefinitionResult added in v0.12.0 

type LookupTaskDefinitionResult struct {
	// The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags              []aws.Tag `pulumi:"tags"`
	TaskDefinitionArn *string   `pulumi:"taskDefinitionArn"`
}

func LookupTaskDefinition added in v0.12.0 

func LookupTaskDefinition(ctx *pulumi.Context, args *LookupTaskDefinitionArgs, opts ...pulumi.InvokeOption) (*LookupTaskDefinitionResult, error)

Registers a new task definition from the supplied “family“ and “containerDefinitions“. Optionally, you can add data volumes to your containers with the “volumes“ parameter. For more information about task definition parameters and defaults, see [Amazon ECS Task Definitions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html) in the *Amazon Elastic Container Service Developer Guide*. 

You can specify a role for your task with the ``taskRoleArn`` parameter. When you specify a role for a task, its containers can then use the latest versions of the CLI or SDKs to make API requests to the AWS services that are specified in the policy that's associated with the role. For more information, see [IAM Roles for Tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) in the *Amazon Elastic Container Service Developer Guide*.
You can specify a Docker networking mode for the containers in your task definition with the ``networkMode`` parameter. The available network modes correspond to those described in [Network settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#/network-settings) in the Docker run reference. If you specify the ``awsvpc`` network mode, the task is allocated an elastic network interface, and you must specify a NetworkConfiguration when you create a service or run a task with the task definition. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.
 In the following example or examples, the Authorization header contents (``AUTHPARAMS``) must be replaced with an AWS Signature Version 4 signature. For more information, see [Signature Version 4 Signing Process](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in the *General Reference*.
You only need to learn how to sign HTTP requests if you intend to create them manually. When you use the [](https://docs.aws.amazon.com/cli/) or one of the [SDKs](https://docs.aws.amazon.com/tools/) to make requests to AWS, these tools automatically sign the requests for you, with the access key that you specify when you configure the tools. When you use these tools, you don't have to sign requests yourself.

type LookupTaskDefinitionResultOutput added in v0.12.0 

type LookupTaskDefinitionResultOutput struct{ *pulumi.OutputState }

func LookupTaskDefinitionOutput added in v0.12.0 

func LookupTaskDefinitionOutput(ctx *pulumi.Context, args LookupTaskDefinitionOutputArgs, opts ...pulumi.InvokeOption) LookupTaskDefinitionResultOutput

func (LookupTaskDefinitionResultOutput) ElementType added in v0.12.0 

func (LookupTaskDefinitionResultOutput) ElementType() reflect.Type

func (LookupTaskDefinitionResultOutput) Tags added in v0.12.0 

func (o LookupTaskDefinitionResultOutput) Tags() aws.TagArrayOutput

The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

func (LookupTaskDefinitionResultOutput) TaskDefinitionArn added in v0.12.0 

func (o LookupTaskDefinitionResultOutput) TaskDefinitionArn() pulumi.StringPtrOutput

func (LookupTaskDefinitionResultOutput) ToLookupTaskDefinitionResultOutput added in v0.12.0 

func (o LookupTaskDefinitionResultOutput) ToLookupTaskDefinitionResultOutput() LookupTaskDefinitionResultOutput

func (LookupTaskDefinitionResultOutput) ToLookupTaskDefinitionResultOutputWithContext added in v0.12.0 

func (o LookupTaskDefinitionResultOutput) ToLookupTaskDefinitionResultOutputWithContext(ctx context.Context) LookupTaskDefinitionResultOutput

type LookupTaskSetArgs added in v0.12.0 

type LookupTaskSetArgs struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
	Cluster string `pulumi:"cluster"`
	// The ID of the task set.
	Id string `pulumi:"id"`
	// The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
	Service string `pulumi:"service"`
}

type LookupTaskSetOutputArgs added in v0.12.0 

type LookupTaskSetOutputArgs struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
	Cluster pulumi.StringInput `pulumi:"cluster"`
	// The ID of the task set.
	Id pulumi.StringInput `pulumi:"id"`
	// The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
	Service pulumi.StringInput `pulumi:"service"`
}

func (LookupTaskSetOutputArgs) ElementType added in v0.12.0 

func (LookupTaskSetOutputArgs) ElementType() reflect.Type

type LookupTaskSetResult added in v0.12.0 

type LookupTaskSetResult struct {
	// The ID of the task set.
	Id *string `pulumi:"id"`
	// A floating-point percentage of the desired number of tasks to place and keep running in the task set.
	Scale *TaskSetScale `pulumi:"scale"`
	Tags  []aws.Tag     `pulumi:"tags"`
}

func LookupTaskSet added in v0.12.0 

func LookupTaskSet(ctx *pulumi.Context, args *LookupTaskSetArgs, opts ...pulumi.InvokeOption) (*LookupTaskSetResult, error)

Create a task set in the specified cluster and service. This is used when a service uses the EXTERNAL deployment controller type. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.htmlin the Amazon Elastic Container Service Developer Guide.

type LookupTaskSetResultOutput added in v0.12.0 

type LookupTaskSetResultOutput struct{ *pulumi.OutputState }

func LookupTaskSetOutput added in v0.12.0 

func LookupTaskSetOutput(ctx *pulumi.Context, args LookupTaskSetOutputArgs, opts ...pulumi.InvokeOption) LookupTaskSetResultOutput

func (LookupTaskSetResultOutput) ElementType added in v0.12.0 

func (LookupTaskSetResultOutput) ElementType() reflect.Type

func (LookupTaskSetResultOutput) Id added in v0.12.0 

func (o LookupTaskSetResultOutput) Id() pulumi.StringPtrOutput

The ID of the task set.

func (LookupTaskSetResultOutput) Scale added in v0.12.0 

func (o LookupTaskSetResultOutput) Scale() TaskSetScalePtrOutput

A floating-point percentage of the desired number of tasks to place and keep running in the task set.

func (LookupTaskSetResultOutput) Tags added in v0.98.0 

func (o LookupTaskSetResultOutput) Tags() aws.TagArrayOutput

func (LookupTaskSetResultOutput) ToLookupTaskSetResultOutput added in v0.12.0 

func (o LookupTaskSetResultOutput) ToLookupTaskSetResultOutput() LookupTaskSetResultOutput

func (LookupTaskSetResultOutput) ToLookupTaskSetResultOutputWithContext added in v0.12.0 

func (o LookupTaskSetResultOutput) ToLookupTaskSetResultOutputWithContext(ctx context.Context) LookupTaskSetResultOutput

type PrimaryTaskSet 

type PrimaryTaskSet struct {
	pulumi.CustomResourceState

	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
	Cluster pulumi.StringOutput `pulumi:"cluster"`
	// The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
	Service pulumi.StringOutput `pulumi:"service"`
	// The ID or full Amazon Resource Name (ARN) of the task set.
	TaskSetId pulumi.StringOutput `pulumi:"taskSetId"`
}

A pseudo-resource that manages which of your ECS task sets is primary.

func GetPrimaryTaskSet 

func GetPrimaryTaskSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *PrimaryTaskSetState, opts ...pulumi.ResourceOption) (*PrimaryTaskSet, error)

GetPrimaryTaskSet gets an existing PrimaryTaskSet 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 NewPrimaryTaskSet 

func NewPrimaryTaskSet(ctx *pulumi.Context,
	name string, args *PrimaryTaskSetArgs, opts ...pulumi.ResourceOption) (*PrimaryTaskSet, error)

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

func (*PrimaryTaskSet) ElementType 

func (*PrimaryTaskSet) ElementType() reflect.Type

func (*PrimaryTaskSet) ToPrimaryTaskSetOutput 

func (i *PrimaryTaskSet) ToPrimaryTaskSetOutput() PrimaryTaskSetOutput

func (*PrimaryTaskSet) ToPrimaryTaskSetOutputWithContext 

func (i *PrimaryTaskSet) ToPrimaryTaskSetOutputWithContext(ctx context.Context) PrimaryTaskSetOutput

type PrimaryTaskSetArgs 

type PrimaryTaskSetArgs struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
	Cluster pulumi.StringInput
	// The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
	Service pulumi.StringInput
	// The ID or full Amazon Resource Name (ARN) of the task set.
	TaskSetId pulumi.StringInput
}

The set of arguments for constructing a PrimaryTaskSet resource.

func (PrimaryTaskSetArgs) ElementType 

func (PrimaryTaskSetArgs) ElementType() reflect.Type

type PrimaryTaskSetInput 

type PrimaryTaskSetInput interface {
	pulumi.Input

	ToPrimaryTaskSetOutput() PrimaryTaskSetOutput
	ToPrimaryTaskSetOutputWithContext(ctx context.Context) PrimaryTaskSetOutput
}

type PrimaryTaskSetOutput 

type PrimaryTaskSetOutput struct{ *pulumi.OutputState }

func (PrimaryTaskSetOutput) Cluster added in v0.17.0 

func (o PrimaryTaskSetOutput) Cluster() pulumi.StringOutput

The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.

func (PrimaryTaskSetOutput) ElementType 

func (PrimaryTaskSetOutput) ElementType() reflect.Type

func (PrimaryTaskSetOutput) Service added in v0.17.0 

func (o PrimaryTaskSetOutput) Service() pulumi.StringOutput

The short name or full Amazon Resource Name (ARN) of the service to create the task set in.

func (PrimaryTaskSetOutput) TaskSetId added in v0.17.0 

func (o PrimaryTaskSetOutput) TaskSetId() pulumi.StringOutput

The ID or full Amazon Resource Name (ARN) of the task set.

func (PrimaryTaskSetOutput) ToPrimaryTaskSetOutput 

func (o PrimaryTaskSetOutput) ToPrimaryTaskSetOutput() PrimaryTaskSetOutput

func (PrimaryTaskSetOutput) ToPrimaryTaskSetOutputWithContext 

func (o PrimaryTaskSetOutput) ToPrimaryTaskSetOutputWithContext(ctx context.Context) PrimaryTaskSetOutput

type PrimaryTaskSetState 

type PrimaryTaskSetState struct {
}

func (PrimaryTaskSetState) ElementType 

func (PrimaryTaskSetState) ElementType() reflect.Type

type Service 

type Service struct {
	pulumi.CustomResourceState

	// The capacity provider strategy to use for the service.
	//  If a “capacityProviderStrategy“ is specified, the “launchType“ parameter must be omitted. If no “capacityProviderStrategy“ or “launchType“ is specified, the “defaultCapacityProviderStrategy“ for the cluster is used.
	//  A capacity provider strategy may contain a maximum of 6 capacity providers.
	CapacityProviderStrategy ServiceCapacityProviderStrategyItemArrayOutput `pulumi:"capacityProviderStrategy"`
	// The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.
	Cluster pulumi.StringPtrOutput `pulumi:"cluster"`
	// Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.
	DeploymentConfiguration ServiceDeploymentConfigurationPtrOutput `pulumi:"deploymentConfiguration"`
	// The deployment controller to use for the service. If no deployment controller is specified, the default value of “ECS“ is used.
	DeploymentController ServiceDeploymentControllerPtrOutput `pulumi:"deploymentController"`
	// The number of instantiations of the specified task definition to place and keep running in your service.
	//  For new services, if a desired count is not specified, a default value of “1“ is used. When using the “DAEMON“ scheduling strategy, the desired count is not required.
	//  For existing services, if a desired count is not specified, it is omitted from the operation.
	DesiredCount pulumi.IntPtrOutput `pulumi:"desiredCount"`
	// Specifies whether to turn on Amazon ECS managed tags for the tasks within the service. For more information, see [Tagging your Amazon ECS resources](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  When you use Amazon ECS managed tags, you need to set the “propagateTags“ request parameter.
	EnableEcsManagedTags pulumi.BoolPtrOutput `pulumi:"enableEcsManagedTags"`
	// Determines whether the execute command functionality is turned on for the service. If “true“, the execute command functionality is turned on for all containers in tasks as part of the service.
	EnableExecuteCommand pulumi.BoolPtrOutput `pulumi:"enableExecuteCommand"`
	// The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. This is only used when your service is configured to use a load balancer. If your service has a load balancer defined and you don't specify a health check grace period value, the default value of “0“ is used.
	//  If you do not use an Elastic Load Balancing, we recommend that you use the “startPeriod“ in the task definition health check parameters. For more information, see [Health check](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html).
	//  If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
	HealthCheckGracePeriodSeconds pulumi.IntPtrOutput `pulumi:"healthCheckGracePeriodSeconds"`
	// The launch type on which to run your service. For more information, see [Amazon ECS Launch Types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.
	LaunchType ServiceLaunchTypePtrOutput `pulumi:"launchType"`
	// A list of load balancer objects to associate with the service. If you specify the “Role“ property, “LoadBalancers“ must be specified as well. For information about the number of load balancers that you can specify per service, see [Service Load Balancing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html) in the *Amazon Elastic Container Service Developer Guide*.
	LoadBalancers ServiceLoadBalancerArrayOutput `pulumi:"loadBalancers"`
	Name          pulumi.StringOutput            `pulumi:"name"`
	// The network configuration for the service. This parameter is required for task definitions that use the “awsvpc“ network mode to receive their own elastic network interface, and it is not supported for other network modes. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.
	NetworkConfiguration ServiceNetworkConfigurationPtrOutput `pulumi:"networkConfiguration"`
	// An array of placement constraint objects to use for tasks in your service. You can specify a maximum of 10 constraints for each task. This limit includes constraints in the task definition and those specified at runtime.
	PlacementConstraints ServicePlacementConstraintArrayOutput `pulumi:"placementConstraints"`
	// The placement strategy objects to use for tasks in your service. You can specify a maximum of 5 strategy rules for each service.
	PlacementStrategies ServicePlacementStrategyArrayOutput `pulumi:"placementStrategies"`
	// The platform version that your tasks in the service are running on. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the “LATEST“ platform version is used. For more information, see [platform versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) in the *Amazon Elastic Container Service Developer Guide*.
	PlatformVersion pulumi.StringPtrOutput `pulumi:"platformVersion"`
	// Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the task during task creation. To add tags to a task after task creation, use the [TagResource](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html) API action.
	//  The default is “NONE“.
	PropagateTags ServicePropagateTagsPtrOutput `pulumi:"propagateTags"`
	// The name or full Amazon Resource Name (ARN) of the IAM role that allows Amazon ECS to make calls to your load balancer on your behalf. This parameter is only permitted if you are using a load balancer with your service and your task definition doesn't use the “awsvpc“ network mode. If you specify the “role“ parameter, you must also specify a load balancer object with the “loadBalancers“ parameter.
	//   If your account has already created the Amazon ECS service-linked role, that role is used for your service unless you specify a role here. The service-linked role is required if your task definition uses the “awsvpc“ network mode or if the service is configured to use service discovery, an external deployment controller, multiple target groups, or Elastic Inference accelerators in which case you don't specify a role here. For more information, see [Using service-linked roles for Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   If your specified role has a path other than “/“, then you must either specify the full role ARN (this is recommended) or prefix the role name with the path. For example, if a role with the name “bar“ has a path of “/foo/“ then you would specify “/foo/bar“ as the role name. For more information, see [Friendly names and paths](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names) in the *IAM User Guide*.
	Role pulumi.StringPtrOutput `pulumi:"role"`
	// The scheduling strategy to use for the service. For more information, see [Services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html).
	//  There are two service scheduler strategies available:
	//   +   “REPLICA“-The replica scheduling strategy places and maintains the desired number of tasks across your cluster. By default, the service scheduler spreads tasks across Availability Zones. You can use task placement strategies and constraints to customize task placement decisions. This scheduler strategy is required if the service uses the “CODE_DEPLOY“ or “EXTERNAL“ deployment controller types.
	//   +   “DAEMON“-The daemon scheduling strategy deploys exactly one task on each active container instance that meets all of the task placement constraints that you specify in your cluster. The service scheduler also evaluates the task placement constraints for running tasks and will stop tasks that don't meet the placement constraints. When you're using this strategy, you don't need to specify a desired number of tasks, a task placement strategy, or use Service Auto Scaling policies.
	//         Tasks using the Fargate launch type or the “CODE_DEPLOY“ or “EXTERNAL“ deployment controller types don't support the “DAEMON“ scheduling strategy.
	SchedulingStrategy ServiceSchedulingStrategyPtrOutput `pulumi:"schedulingStrategy"`
	ServiceArn         pulumi.StringOutput                `pulumi:"serviceArn"`
	// The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace.
	//  Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	ServiceConnectConfiguration ServiceConnectConfigurationPtrOutput `pulumi:"serviceConnectConfiguration"`
	// The name of your service. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. Service names must be unique within a cluster, but you can have similarly named services in multiple clusters within a Region or across multiple Regions.
	//   The stack update fails if you change any properties that require replacement and the “ServiceName“ is configured. This is because AWS CloudFormation creates the replacement service first, but each “ServiceName“ must be unique in the cluster.
	ServiceName pulumi.StringPtrOutput `pulumi:"serviceName"`
	// The details of the service discovery registry to associate with this service. For more information, see [Service discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html).
	//   Each service may be associated with one service registry. Multiple service registries for each service isn't supported.
	ServiceRegistries ServiceRegistryArrayOutput `pulumi:"serviceRegistries"`
	// The metadata that you apply to the service to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. When a service is deleted, the tags are deleted as well.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags aws.TagArrayOutput `pulumi:"tags"`
	// The “family“ and “revision“ (“family:revision“) or full ARN of the task definition to run in your service. If a “revision“ isn't specified, the latest “ACTIVE“ revision is used.
	//  A task definition must be specified if the service uses either the “ECS“ or “CODE_DEPLOY“ deployment controllers.
	//  For more information about deployment types, see [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html).
	TaskDefinition pulumi.StringPtrOutput `pulumi:"taskDefinition"`
	// The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.
	VolumeConfigurations ServiceVolumeConfigurationArrayOutput `pulumi:"volumeConfigurations"`
}

The “AWS::ECS::Service“ resource creates an Amazon Elastic Container Service (Amazon ECS) service that runs and maintains the requested number of tasks and associated load balancers. 

The stack update fails if you change any properties that require replacement and at least one Amazon ECS Service Connect ``ServiceConnectService`` is configured. This is because AWS CloudFormation creates the replacement service first, but each ``ServiceConnectService`` must have a name that is unique in the namespace.
Starting April 15, 2023, AWS; will not onboard new customers to Amazon Elastic Inference (EI), and will help current customers migrate their workloads to options that offer better price and performance. After April 15, 2023, new customers will not be able to launch instances with Amazon EI accelerators in Amazon SageMaker, ECS, or EC2. However, customers who have used Amazon EI at least once during the past 30-day period are considered current customers and will be able to continue using the service.

func GetService 

func GetService(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ServiceState, opts ...pulumi.ResourceOption) (*Service, error)

GetService gets an existing Service 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 NewService 

func NewService(ctx *pulumi.Context,
	name string, args *ServiceArgs, opts ...pulumi.ResourceOption) (*Service, error)

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

func (*Service) ElementType 

func (*Service) ElementType() reflect.Type

func (*Service) ToServiceOutput 

func (i *Service) ToServiceOutput() ServiceOutput

func (*Service) ToServiceOutputWithContext 

func (i *Service) ToServiceOutputWithContext(ctx context.Context) ServiceOutput

type ServiceArgs 

type ServiceArgs struct {
	// The capacity provider strategy to use for the service.
	//  If a “capacityProviderStrategy“ is specified, the “launchType“ parameter must be omitted. If no “capacityProviderStrategy“ or “launchType“ is specified, the “defaultCapacityProviderStrategy“ for the cluster is used.
	//  A capacity provider strategy may contain a maximum of 6 capacity providers.
	CapacityProviderStrategy ServiceCapacityProviderStrategyItemArrayInput
	// The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.
	Cluster pulumi.StringPtrInput
	// Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.
	DeploymentConfiguration ServiceDeploymentConfigurationPtrInput
	// The deployment controller to use for the service. If no deployment controller is specified, the default value of “ECS“ is used.
	DeploymentController ServiceDeploymentControllerPtrInput
	// The number of instantiations of the specified task definition to place and keep running in your service.
	//  For new services, if a desired count is not specified, a default value of “1“ is used. When using the “DAEMON“ scheduling strategy, the desired count is not required.
	//  For existing services, if a desired count is not specified, it is omitted from the operation.
	DesiredCount pulumi.IntPtrInput
	// Specifies whether to turn on Amazon ECS managed tags for the tasks within the service. For more information, see [Tagging your Amazon ECS resources](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  When you use Amazon ECS managed tags, you need to set the “propagateTags“ request parameter.
	EnableEcsManagedTags pulumi.BoolPtrInput
	// Determines whether the execute command functionality is turned on for the service. If “true“, the execute command functionality is turned on for all containers in tasks as part of the service.
	EnableExecuteCommand pulumi.BoolPtrInput
	// The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. This is only used when your service is configured to use a load balancer. If your service has a load balancer defined and you don't specify a health check grace period value, the default value of “0“ is used.
	//  If you do not use an Elastic Load Balancing, we recommend that you use the “startPeriod“ in the task definition health check parameters. For more information, see [Health check](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html).
	//  If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
	HealthCheckGracePeriodSeconds pulumi.IntPtrInput
	// The launch type on which to run your service. For more information, see [Amazon ECS Launch Types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.
	LaunchType ServiceLaunchTypePtrInput
	// A list of load balancer objects to associate with the service. If you specify the “Role“ property, “LoadBalancers“ must be specified as well. For information about the number of load balancers that you can specify per service, see [Service Load Balancing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html) in the *Amazon Elastic Container Service Developer Guide*.
	LoadBalancers ServiceLoadBalancerArrayInput
	// The network configuration for the service. This parameter is required for task definitions that use the “awsvpc“ network mode to receive their own elastic network interface, and it is not supported for other network modes. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.
	NetworkConfiguration ServiceNetworkConfigurationPtrInput
	// An array of placement constraint objects to use for tasks in your service. You can specify a maximum of 10 constraints for each task. This limit includes constraints in the task definition and those specified at runtime.
	PlacementConstraints ServicePlacementConstraintArrayInput
	// The placement strategy objects to use for tasks in your service. You can specify a maximum of 5 strategy rules for each service.
	PlacementStrategies ServicePlacementStrategyArrayInput
	// The platform version that your tasks in the service are running on. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the “LATEST“ platform version is used. For more information, see [platform versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) in the *Amazon Elastic Container Service Developer Guide*.
	PlatformVersion pulumi.StringPtrInput
	// Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the task during task creation. To add tags to a task after task creation, use the [TagResource](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html) API action.
	//  The default is “NONE“.
	PropagateTags ServicePropagateTagsPtrInput
	// The name or full Amazon Resource Name (ARN) of the IAM role that allows Amazon ECS to make calls to your load balancer on your behalf. This parameter is only permitted if you are using a load balancer with your service and your task definition doesn't use the “awsvpc“ network mode. If you specify the “role“ parameter, you must also specify a load balancer object with the “loadBalancers“ parameter.
	//   If your account has already created the Amazon ECS service-linked role, that role is used for your service unless you specify a role here. The service-linked role is required if your task definition uses the “awsvpc“ network mode or if the service is configured to use service discovery, an external deployment controller, multiple target groups, or Elastic Inference accelerators in which case you don't specify a role here. For more information, see [Using service-linked roles for Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   If your specified role has a path other than “/“, then you must either specify the full role ARN (this is recommended) or prefix the role name with the path. For example, if a role with the name “bar“ has a path of “/foo/“ then you would specify “/foo/bar“ as the role name. For more information, see [Friendly names and paths](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names) in the *IAM User Guide*.
	Role pulumi.StringPtrInput
	// The scheduling strategy to use for the service. For more information, see [Services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html).
	//  There are two service scheduler strategies available:
	//   +   “REPLICA“-The replica scheduling strategy places and maintains the desired number of tasks across your cluster. By default, the service scheduler spreads tasks across Availability Zones. You can use task placement strategies and constraints to customize task placement decisions. This scheduler strategy is required if the service uses the “CODE_DEPLOY“ or “EXTERNAL“ deployment controller types.
	//   +   “DAEMON“-The daemon scheduling strategy deploys exactly one task on each active container instance that meets all of the task placement constraints that you specify in your cluster. The service scheduler also evaluates the task placement constraints for running tasks and will stop tasks that don't meet the placement constraints. When you're using this strategy, you don't need to specify a desired number of tasks, a task placement strategy, or use Service Auto Scaling policies.
	//         Tasks using the Fargate launch type or the “CODE_DEPLOY“ or “EXTERNAL“ deployment controller types don't support the “DAEMON“ scheduling strategy.
	SchedulingStrategy ServiceSchedulingStrategyPtrInput
	// The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace.
	//  Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	ServiceConnectConfiguration ServiceConnectConfigurationPtrInput
	// The name of your service. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. Service names must be unique within a cluster, but you can have similarly named services in multiple clusters within a Region or across multiple Regions.
	//   The stack update fails if you change any properties that require replacement and the “ServiceName“ is configured. This is because AWS CloudFormation creates the replacement service first, but each “ServiceName“ must be unique in the cluster.
	ServiceName pulumi.StringPtrInput
	// The details of the service discovery registry to associate with this service. For more information, see [Service discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html).
	//   Each service may be associated with one service registry. Multiple service registries for each service isn't supported.
	ServiceRegistries ServiceRegistryArrayInput
	// The metadata that you apply to the service to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. When a service is deleted, the tags are deleted as well.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags aws.TagArrayInput
	// The “family“ and “revision“ (“family:revision“) or full ARN of the task definition to run in your service. If a “revision“ isn't specified, the latest “ACTIVE“ revision is used.
	//  A task definition must be specified if the service uses either the “ECS“ or “CODE_DEPLOY“ deployment controllers.
	//  For more information about deployment types, see [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html).
	TaskDefinition pulumi.StringPtrInput
	// The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.
	VolumeConfigurations ServiceVolumeConfigurationArrayInput
}

The set of arguments for constructing a Service resource.

func (ServiceArgs) ElementType 

func (ServiceArgs) ElementType() reflect.Type

type ServiceAwsVpcConfiguration 

type ServiceAwsVpcConfiguration struct {
	// Whether the task's elastic network interface receives a public IP address. The default value is “DISABLED“.
	AssignPublicIp *ServiceAwsVpcConfigurationAssignPublicIp `pulumi:"assignPublicIp"`
	// The IDs of the security groups associated with the task or service. If you don't specify a security group, the default security group for the VPC is used. There's a limit of 5 security groups that can be specified per “AwsVpcConfiguration“.
	//   All specified security groups must be from the same VPC.
	SecurityGroups []string `pulumi:"securityGroups"`
	// The IDs of the subnets associated with the task or service. There's a limit of 16 subnets that can be specified per “AwsVpcConfiguration“.
	//   All specified subnets must be from the same VPC.
	Subnets []string `pulumi:"subnets"`
}

An object representing the networking details for a task or service. For example “awsvpcConfiguration={subnets=["subnet-12344321"],securityGroups=["sg-12344321"]}“

type ServiceAwsVpcConfigurationArgs 

type ServiceAwsVpcConfigurationArgs struct {
	// Whether the task's elastic network interface receives a public IP address. The default value is “DISABLED“.
	AssignPublicIp ServiceAwsVpcConfigurationAssignPublicIpPtrInput `pulumi:"assignPublicIp"`
	// The IDs of the security groups associated with the task or service. If you don't specify a security group, the default security group for the VPC is used. There's a limit of 5 security groups that can be specified per “AwsVpcConfiguration“.
	//   All specified security groups must be from the same VPC.
	SecurityGroups pulumi.StringArrayInput `pulumi:"securityGroups"`
	// The IDs of the subnets associated with the task or service. There's a limit of 16 subnets that can be specified per “AwsVpcConfiguration“.
	//   All specified subnets must be from the same VPC.
	Subnets pulumi.StringArrayInput `pulumi:"subnets"`
}

An object representing the networking details for a task or service. For example “awsvpcConfiguration={subnets=["subnet-12344321"],securityGroups=["sg-12344321"]}“

func (ServiceAwsVpcConfigurationArgs) ElementType 

func (ServiceAwsVpcConfigurationArgs) ElementType() reflect.Type

func (ServiceAwsVpcConfigurationArgs) ToServiceAwsVpcConfigurationOutput 

func (i ServiceAwsVpcConfigurationArgs) ToServiceAwsVpcConfigurationOutput() ServiceAwsVpcConfigurationOutput

func (ServiceAwsVpcConfigurationArgs) ToServiceAwsVpcConfigurationOutputWithContext 

func (i ServiceAwsVpcConfigurationArgs) ToServiceAwsVpcConfigurationOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationOutput

func (ServiceAwsVpcConfigurationArgs) ToServiceAwsVpcConfigurationPtrOutput 

func (i ServiceAwsVpcConfigurationArgs) ToServiceAwsVpcConfigurationPtrOutput() ServiceAwsVpcConfigurationPtrOutput

func (ServiceAwsVpcConfigurationArgs) ToServiceAwsVpcConfigurationPtrOutputWithContext 

func (i ServiceAwsVpcConfigurationArgs) ToServiceAwsVpcConfigurationPtrOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationPtrOutput

type ServiceAwsVpcConfigurationAssignPublicIp 

type ServiceAwsVpcConfigurationAssignPublicIp string

Whether the task's elastic network interface receives a public IP address. The default value is “DISABLED“.

func (ServiceAwsVpcConfigurationAssignPublicIp) ElementType 

func (ServiceAwsVpcConfigurationAssignPublicIp) ElementType() reflect.Type

func (ServiceAwsVpcConfigurationAssignPublicIp) ToServiceAwsVpcConfigurationAssignPublicIpOutput 

func (e ServiceAwsVpcConfigurationAssignPublicIp) ToServiceAwsVpcConfigurationAssignPublicIpOutput() ServiceAwsVpcConfigurationAssignPublicIpOutput

func (ServiceAwsVpcConfigurationAssignPublicIp) ToServiceAwsVpcConfigurationAssignPublicIpOutputWithContext 

func (e ServiceAwsVpcConfigurationAssignPublicIp) ToServiceAwsVpcConfigurationAssignPublicIpOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationAssignPublicIpOutput

func (ServiceAwsVpcConfigurationAssignPublicIp) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutput 

func (e ServiceAwsVpcConfigurationAssignPublicIp) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutput() ServiceAwsVpcConfigurationAssignPublicIpPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIp) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutputWithContext 

func (e ServiceAwsVpcConfigurationAssignPublicIp) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationAssignPublicIpPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIp) ToStringOutput 

func (e ServiceAwsVpcConfigurationAssignPublicIp) ToStringOutput() pulumi.StringOutput

func (ServiceAwsVpcConfigurationAssignPublicIp) ToStringOutputWithContext 

func (e ServiceAwsVpcConfigurationAssignPublicIp) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceAwsVpcConfigurationAssignPublicIp) ToStringPtrOutput 

func (e ServiceAwsVpcConfigurationAssignPublicIp) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIp) ToStringPtrOutputWithContext 

func (e ServiceAwsVpcConfigurationAssignPublicIp) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceAwsVpcConfigurationAssignPublicIpInput 

type ServiceAwsVpcConfigurationAssignPublicIpInput interface {
	pulumi.Input

	ToServiceAwsVpcConfigurationAssignPublicIpOutput() ServiceAwsVpcConfigurationAssignPublicIpOutput
	ToServiceAwsVpcConfigurationAssignPublicIpOutputWithContext(context.Context) ServiceAwsVpcConfigurationAssignPublicIpOutput
}

ServiceAwsVpcConfigurationAssignPublicIpInput is an input type that accepts values of the ServiceAwsVpcConfigurationAssignPublicIp enum A concrete instance of `ServiceAwsVpcConfigurationAssignPublicIpInput` can be one of the following: 

ServiceAwsVpcConfigurationAssignPublicIpDisabled
ServiceAwsVpcConfigurationAssignPublicIpEnabled

type ServiceAwsVpcConfigurationAssignPublicIpOutput 

type ServiceAwsVpcConfigurationAssignPublicIpOutput struct{ *pulumi.OutputState }

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ElementType 

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ElementType() reflect.Type

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ToServiceAwsVpcConfigurationAssignPublicIpOutput 

func (o ServiceAwsVpcConfigurationAssignPublicIpOutput) ToServiceAwsVpcConfigurationAssignPublicIpOutput() ServiceAwsVpcConfigurationAssignPublicIpOutput

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ToServiceAwsVpcConfigurationAssignPublicIpOutputWithContext 

func (o ServiceAwsVpcConfigurationAssignPublicIpOutput) ToServiceAwsVpcConfigurationAssignPublicIpOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationAssignPublicIpOutput

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutput 

func (o ServiceAwsVpcConfigurationAssignPublicIpOutput) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutput() ServiceAwsVpcConfigurationAssignPublicIpPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutputWithContext 

func (o ServiceAwsVpcConfigurationAssignPublicIpOutput) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationAssignPublicIpPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ToStringOutput 

func (o ServiceAwsVpcConfigurationAssignPublicIpOutput) ToStringOutput() pulumi.StringOutput

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ToStringOutputWithContext 

func (o ServiceAwsVpcConfigurationAssignPublicIpOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ToStringPtrOutput 

func (o ServiceAwsVpcConfigurationAssignPublicIpOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIpOutput) ToStringPtrOutputWithContext 

func (o ServiceAwsVpcConfigurationAssignPublicIpOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceAwsVpcConfigurationAssignPublicIpPtrInput 

type ServiceAwsVpcConfigurationAssignPublicIpPtrInput interface {
	pulumi.Input

	ToServiceAwsVpcConfigurationAssignPublicIpPtrOutput() ServiceAwsVpcConfigurationAssignPublicIpPtrOutput
	ToServiceAwsVpcConfigurationAssignPublicIpPtrOutputWithContext(context.Context) ServiceAwsVpcConfigurationAssignPublicIpPtrOutput
}

func ServiceAwsVpcConfigurationAssignPublicIpPtr 

func ServiceAwsVpcConfigurationAssignPublicIpPtr(v string) ServiceAwsVpcConfigurationAssignPublicIpPtrInput

type ServiceAwsVpcConfigurationAssignPublicIpPtrOutput 

type ServiceAwsVpcConfigurationAssignPublicIpPtrOutput struct{ *pulumi.OutputState }

func (ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) Elem 

func (o ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) Elem() ServiceAwsVpcConfigurationAssignPublicIpOutput

func (ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ElementType 

func (ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ElementType() reflect.Type

func (ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutput 

func (o ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutput() ServiceAwsVpcConfigurationAssignPublicIpPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutputWithContext 

func (o ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ToServiceAwsVpcConfigurationAssignPublicIpPtrOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationAssignPublicIpPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ToStringPtrOutput 

func (o ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ToStringPtrOutputWithContext 

func (o ServiceAwsVpcConfigurationAssignPublicIpPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceAwsVpcConfigurationInput 

type ServiceAwsVpcConfigurationInput interface {
	pulumi.Input

	ToServiceAwsVpcConfigurationOutput() ServiceAwsVpcConfigurationOutput
	ToServiceAwsVpcConfigurationOutputWithContext(context.Context) ServiceAwsVpcConfigurationOutput
}

ServiceAwsVpcConfigurationInput is an input type that accepts ServiceAwsVpcConfigurationArgs and ServiceAwsVpcConfigurationOutput values. You can construct a concrete instance of `ServiceAwsVpcConfigurationInput` via: 

ServiceAwsVpcConfigurationArgs{...}

type ServiceAwsVpcConfigurationOutput 

type ServiceAwsVpcConfigurationOutput struct{ *pulumi.OutputState }

An object representing the networking details for a task or service. For example “awsvpcConfiguration={subnets=["subnet-12344321"],securityGroups=["sg-12344321"]}“

func (ServiceAwsVpcConfigurationOutput) AssignPublicIp 

func (o ServiceAwsVpcConfigurationOutput) AssignPublicIp() ServiceAwsVpcConfigurationAssignPublicIpPtrOutput

Whether the task's elastic network interface receives a public IP address. The default value is “DISABLED“.

func (ServiceAwsVpcConfigurationOutput) ElementType 

func (ServiceAwsVpcConfigurationOutput) ElementType() reflect.Type

func (ServiceAwsVpcConfigurationOutput) SecurityGroups 

func (o ServiceAwsVpcConfigurationOutput) SecurityGroups() pulumi.StringArrayOutput

The IDs of the security groups associated with the task or service. If you don't specify a security group, the default security group for the VPC is used. There's a limit of 5 security groups that can be specified per “AwsVpcConfiguration“. 

All specified security groups must be from the same VPC.

func (ServiceAwsVpcConfigurationOutput) Subnets 

func (o ServiceAwsVpcConfigurationOutput) Subnets() pulumi.StringArrayOutput

The IDs of the subnets associated with the task or service. There's a limit of 16 subnets that can be specified per “AwsVpcConfiguration“. 

All specified subnets must be from the same VPC.

func (ServiceAwsVpcConfigurationOutput) ToServiceAwsVpcConfigurationOutput 

func (o ServiceAwsVpcConfigurationOutput) ToServiceAwsVpcConfigurationOutput() ServiceAwsVpcConfigurationOutput

func (ServiceAwsVpcConfigurationOutput) ToServiceAwsVpcConfigurationOutputWithContext 

func (o ServiceAwsVpcConfigurationOutput) ToServiceAwsVpcConfigurationOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationOutput

func (ServiceAwsVpcConfigurationOutput) ToServiceAwsVpcConfigurationPtrOutput 

func (o ServiceAwsVpcConfigurationOutput) ToServiceAwsVpcConfigurationPtrOutput() ServiceAwsVpcConfigurationPtrOutput

func (ServiceAwsVpcConfigurationOutput) ToServiceAwsVpcConfigurationPtrOutputWithContext 

func (o ServiceAwsVpcConfigurationOutput) ToServiceAwsVpcConfigurationPtrOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationPtrOutput

type ServiceAwsVpcConfigurationPtrInput 

type ServiceAwsVpcConfigurationPtrInput interface {
	pulumi.Input

	ToServiceAwsVpcConfigurationPtrOutput() ServiceAwsVpcConfigurationPtrOutput
	ToServiceAwsVpcConfigurationPtrOutputWithContext(context.Context) ServiceAwsVpcConfigurationPtrOutput
}

ServiceAwsVpcConfigurationPtrInput is an input type that accepts ServiceAwsVpcConfigurationArgs, ServiceAwsVpcConfigurationPtr and ServiceAwsVpcConfigurationPtrOutput values. You can construct a concrete instance of `ServiceAwsVpcConfigurationPtrInput` via: 

        ServiceAwsVpcConfigurationArgs{...}

or:

        nil

func ServiceAwsVpcConfigurationPtr 

func ServiceAwsVpcConfigurationPtr(v *ServiceAwsVpcConfigurationArgs) ServiceAwsVpcConfigurationPtrInput

type ServiceAwsVpcConfigurationPtrOutput 

type ServiceAwsVpcConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceAwsVpcConfigurationPtrOutput) AssignPublicIp 

func (o ServiceAwsVpcConfigurationPtrOutput) AssignPublicIp() ServiceAwsVpcConfigurationAssignPublicIpPtrOutput

Whether the task's elastic network interface receives a public IP address. The default value is “DISABLED“.

func (ServiceAwsVpcConfigurationPtrOutput) Elem 

func (o ServiceAwsVpcConfigurationPtrOutput) Elem() ServiceAwsVpcConfigurationOutput

func (ServiceAwsVpcConfigurationPtrOutput) ElementType 

func (ServiceAwsVpcConfigurationPtrOutput) ElementType() reflect.Type

func (ServiceAwsVpcConfigurationPtrOutput) SecurityGroups 

func (o ServiceAwsVpcConfigurationPtrOutput) SecurityGroups() pulumi.StringArrayOutput

The IDs of the security groups associated with the task or service. If you don't specify a security group, the default security group for the VPC is used. There's a limit of 5 security groups that can be specified per “AwsVpcConfiguration“. 

All specified security groups must be from the same VPC.

func (ServiceAwsVpcConfigurationPtrOutput) Subnets 

func (o ServiceAwsVpcConfigurationPtrOutput) Subnets() pulumi.StringArrayOutput

The IDs of the subnets associated with the task or service. There's a limit of 16 subnets that can be specified per “AwsVpcConfiguration“. 

All specified subnets must be from the same VPC.

func (ServiceAwsVpcConfigurationPtrOutput) ToServiceAwsVpcConfigurationPtrOutput 

func (o ServiceAwsVpcConfigurationPtrOutput) ToServiceAwsVpcConfigurationPtrOutput() ServiceAwsVpcConfigurationPtrOutput

func (ServiceAwsVpcConfigurationPtrOutput) ToServiceAwsVpcConfigurationPtrOutputWithContext 

func (o ServiceAwsVpcConfigurationPtrOutput) ToServiceAwsVpcConfigurationPtrOutputWithContext(ctx context.Context) ServiceAwsVpcConfigurationPtrOutput

type ServiceCapacityProviderStrategyItem 

type ServiceCapacityProviderStrategyItem struct {
	// The *base* value designates how many tasks, at a minimum, to run on the specified capacity provider. Only one capacity provider in a capacity provider strategy can have a *base* defined. If no value is specified, the default value of “0“ is used.
	Base *int `pulumi:"base"`
	// The short name of the capacity provider.
	CapacityProvider *string `pulumi:"capacityProvider"`
	// The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The “weight“ value is taken into consideration after the “base“ value, if defined, is satisfied.
	//  If no “weight“ value is specified, the default value of “0“ is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of “0“ can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of “0“, any “RunTask“ or “CreateService“ actions using the capacity provider strategy will fail.
	//  An example scenario for using weights is defining a strategy that contains two capacity providers and both have a weight of “1“, then when the “base“ is satisfied, the tasks will be split evenly across the two capacity providers. Using that same logic, if you specify a weight of “1“ for *capacityProviderA* and a weight of “4“ for *capacityProviderB*, then for every one task that's run using *capacityProviderA*, four tasks would use *capacityProviderB*.
	Weight *int `pulumi:"weight"`
}

The details of a capacity provider strategy. A capacity provider strategy can be set when using the “RunTask“ or “CreateService“ APIs or as the default capacity provider strategy for a cluster with the “CreateCluster“ API. 

Only capacity providers that are already associated with a cluster and have an ``ACTIVE`` or ``UPDATING`` status can be used in a capacity provider strategy. The ``PutClusterCapacityProviders`` API is used to associate a capacity provider with a cluster.
If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must already be created. New Auto Scaling group capacity providers can be created with the ``CreateCapacityProvider`` API operation.
To use an FARGATElong capacity provider, specify either the ``FARGATE`` or ``FARGATE_SPOT`` capacity providers. The FARGATElong capacity providers are available to all accounts and only need to be associated with a cluster to be used in a capacity provider strategy.

type ServiceCapacityProviderStrategyItemArgs 

type ServiceCapacityProviderStrategyItemArgs struct {
	// The *base* value designates how many tasks, at a minimum, to run on the specified capacity provider. Only one capacity provider in a capacity provider strategy can have a *base* defined. If no value is specified, the default value of “0“ is used.
	Base pulumi.IntPtrInput `pulumi:"base"`
	// The short name of the capacity provider.
	CapacityProvider pulumi.StringPtrInput `pulumi:"capacityProvider"`
	// The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The “weight“ value is taken into consideration after the “base“ value, if defined, is satisfied.
	//  If no “weight“ value is specified, the default value of “0“ is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of “0“ can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of “0“, any “RunTask“ or “CreateService“ actions using the capacity provider strategy will fail.
	//  An example scenario for using weights is defining a strategy that contains two capacity providers and both have a weight of “1“, then when the “base“ is satisfied, the tasks will be split evenly across the two capacity providers. Using that same logic, if you specify a weight of “1“ for *capacityProviderA* and a weight of “4“ for *capacityProviderB*, then for every one task that's run using *capacityProviderA*, four tasks would use *capacityProviderB*.
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

The details of a capacity provider strategy. A capacity provider strategy can be set when using the “RunTask“ or “CreateService“ APIs or as the default capacity provider strategy for a cluster with the “CreateCluster“ API. 

Only capacity providers that are already associated with a cluster and have an ``ACTIVE`` or ``UPDATING`` status can be used in a capacity provider strategy. The ``PutClusterCapacityProviders`` API is used to associate a capacity provider with a cluster.
If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must already be created. New Auto Scaling group capacity providers can be created with the ``CreateCapacityProvider`` API operation.
To use an FARGATElong capacity provider, specify either the ``FARGATE`` or ``FARGATE_SPOT`` capacity providers. The FARGATElong capacity providers are available to all accounts and only need to be associated with a cluster to be used in a capacity provider strategy.

func (ServiceCapacityProviderStrategyItemArgs) ElementType 

func (ServiceCapacityProviderStrategyItemArgs) ElementType() reflect.Type

func (ServiceCapacityProviderStrategyItemArgs) ToServiceCapacityProviderStrategyItemOutput 

func (i ServiceCapacityProviderStrategyItemArgs) ToServiceCapacityProviderStrategyItemOutput() ServiceCapacityProviderStrategyItemOutput

func (ServiceCapacityProviderStrategyItemArgs) ToServiceCapacityProviderStrategyItemOutputWithContext 

func (i ServiceCapacityProviderStrategyItemArgs) ToServiceCapacityProviderStrategyItemOutputWithContext(ctx context.Context) ServiceCapacityProviderStrategyItemOutput

type ServiceCapacityProviderStrategyItemArray 

type ServiceCapacityProviderStrategyItemArray []ServiceCapacityProviderStrategyItemInput

func (ServiceCapacityProviderStrategyItemArray) ElementType 

func (ServiceCapacityProviderStrategyItemArray) ElementType() reflect.Type

func (ServiceCapacityProviderStrategyItemArray) ToServiceCapacityProviderStrategyItemArrayOutput 

func (i ServiceCapacityProviderStrategyItemArray) ToServiceCapacityProviderStrategyItemArrayOutput() ServiceCapacityProviderStrategyItemArrayOutput

func (ServiceCapacityProviderStrategyItemArray) ToServiceCapacityProviderStrategyItemArrayOutputWithContext 

func (i ServiceCapacityProviderStrategyItemArray) ToServiceCapacityProviderStrategyItemArrayOutputWithContext(ctx context.Context) ServiceCapacityProviderStrategyItemArrayOutput

type ServiceCapacityProviderStrategyItemArrayInput 

type ServiceCapacityProviderStrategyItemArrayInput interface {
	pulumi.Input

	ToServiceCapacityProviderStrategyItemArrayOutput() ServiceCapacityProviderStrategyItemArrayOutput
	ToServiceCapacityProviderStrategyItemArrayOutputWithContext(context.Context) ServiceCapacityProviderStrategyItemArrayOutput
}

ServiceCapacityProviderStrategyItemArrayInput is an input type that accepts ServiceCapacityProviderStrategyItemArray and ServiceCapacityProviderStrategyItemArrayOutput values. You can construct a concrete instance of `ServiceCapacityProviderStrategyItemArrayInput` via: 

ServiceCapacityProviderStrategyItemArray{ ServiceCapacityProviderStrategyItemArgs{...} }

type ServiceCapacityProviderStrategyItemArrayOutput 

type ServiceCapacityProviderStrategyItemArrayOutput struct{ *pulumi.OutputState }

func (ServiceCapacityProviderStrategyItemArrayOutput) ElementType 

func (ServiceCapacityProviderStrategyItemArrayOutput) ElementType() reflect.Type

func (ServiceCapacityProviderStrategyItemArrayOutput) Index 

func (o ServiceCapacityProviderStrategyItemArrayOutput) Index(i pulumi.IntInput) ServiceCapacityProviderStrategyItemOutput

func (ServiceCapacityProviderStrategyItemArrayOutput) ToServiceCapacityProviderStrategyItemArrayOutput 

func (o ServiceCapacityProviderStrategyItemArrayOutput) ToServiceCapacityProviderStrategyItemArrayOutput() ServiceCapacityProviderStrategyItemArrayOutput

func (ServiceCapacityProviderStrategyItemArrayOutput) ToServiceCapacityProviderStrategyItemArrayOutputWithContext 

func (o ServiceCapacityProviderStrategyItemArrayOutput) ToServiceCapacityProviderStrategyItemArrayOutputWithContext(ctx context.Context) ServiceCapacityProviderStrategyItemArrayOutput

type ServiceCapacityProviderStrategyItemInput 

type ServiceCapacityProviderStrategyItemInput interface {
	pulumi.Input

	ToServiceCapacityProviderStrategyItemOutput() ServiceCapacityProviderStrategyItemOutput
	ToServiceCapacityProviderStrategyItemOutputWithContext(context.Context) ServiceCapacityProviderStrategyItemOutput
}

ServiceCapacityProviderStrategyItemInput is an input type that accepts ServiceCapacityProviderStrategyItemArgs and ServiceCapacityProviderStrategyItemOutput values. You can construct a concrete instance of `ServiceCapacityProviderStrategyItemInput` via: 

ServiceCapacityProviderStrategyItemArgs{...}

type ServiceCapacityProviderStrategyItemOutput 

type ServiceCapacityProviderStrategyItemOutput struct{ *pulumi.OutputState }

The details of a capacity provider strategy. A capacity provider strategy can be set when using the “RunTask“ or “CreateService“ APIs or as the default capacity provider strategy for a cluster with the “CreateCluster“ API. 

Only capacity providers that are already associated with a cluster and have an ``ACTIVE`` or ``UPDATING`` status can be used in a capacity provider strategy. The ``PutClusterCapacityProviders`` API is used to associate a capacity provider with a cluster.
If specifying a capacity provider that uses an Auto Scaling group, the capacity provider must already be created. New Auto Scaling group capacity providers can be created with the ``CreateCapacityProvider`` API operation.
To use an FARGATElong capacity provider, specify either the ``FARGATE`` or ``FARGATE_SPOT`` capacity providers. The FARGATElong capacity providers are available to all accounts and only need to be associated with a cluster to be used in a capacity provider strategy.

func (ServiceCapacityProviderStrategyItemOutput) Base 

func (o ServiceCapacityProviderStrategyItemOutput) Base() pulumi.IntPtrOutput

The *base* value designates how many tasks, at a minimum, to run on the specified capacity provider. Only one capacity provider in a capacity provider strategy can have a *base* defined. If no value is specified, the default value of “0“ is used.

func (ServiceCapacityProviderStrategyItemOutput) CapacityProvider 

func (o ServiceCapacityProviderStrategyItemOutput) CapacityProvider() pulumi.StringPtrOutput

The short name of the capacity provider.

func (ServiceCapacityProviderStrategyItemOutput) ElementType 

func (ServiceCapacityProviderStrategyItemOutput) ElementType() reflect.Type

func (ServiceCapacityProviderStrategyItemOutput) ToServiceCapacityProviderStrategyItemOutput 

func (o ServiceCapacityProviderStrategyItemOutput) ToServiceCapacityProviderStrategyItemOutput() ServiceCapacityProviderStrategyItemOutput

func (ServiceCapacityProviderStrategyItemOutput) ToServiceCapacityProviderStrategyItemOutputWithContext 

func (o ServiceCapacityProviderStrategyItemOutput) ToServiceCapacityProviderStrategyItemOutputWithContext(ctx context.Context) ServiceCapacityProviderStrategyItemOutput

func (ServiceCapacityProviderStrategyItemOutput) Weight 

func (o ServiceCapacityProviderStrategyItemOutput) Weight() pulumi.IntPtrOutput

The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The “weight“ value is taken into consideration after the “base“ value, if defined, is satisfied. 

If no ``weight`` value is specified, the default value of ``0`` is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of ``0`` can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of ``0``, any ``RunTask`` or ``CreateService`` actions using the capacity provider strategy will fail.
An example scenario for using weights is defining a strategy that contains two capacity providers and both have a weight of ``1``, then when the ``base`` is satisfied, the tasks will be split evenly across the two capacity providers. Using that same logic, if you specify a weight of ``1`` for *capacityProviderA* and a weight of ``4`` for *capacityProviderB*, then for every one task that's run using *capacityProviderA*, four tasks would use *capacityProviderB*.

type ServiceConnectClientAlias added in v0.41.0 

type ServiceConnectClientAlias struct {
	// The “dnsName“ is the name that you use in the applications of client tasks to connect to this service. The name must be a valid DNS name but doesn't need to be fully-qualified. The name can include up to 127 characters. The name can include lowercase letters, numbers, underscores (_), hyphens (-), and periods (.). The name can't start with a hyphen.
	//  If this parameter isn't specified, the default value of “discoveryName.namespace“ is used. If the “discoveryName“ isn't specified, the port mapping name from the task definition is used in “portName.namespace“.
	//  To avoid changing your applications in client Amazon ECS services, set this to the same name that the client application uses by default. For example, a few common names are “database“, “db“, or the lowercase name of a database, such as “mysql“ or “redis“. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	DnsName *string `pulumi:"dnsName"`
	// The listening port number for the Service Connect proxy. This port is available inside of all of the tasks within the same namespace.
	//  To avoid changing your applications in client Amazon ECS services, set this to the same port that the client application uses by default. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	Port int `pulumi:"port"`
}

Each alias ("endpoint") is a fully-qualified name and port number that other tasks ("clients") can use to connect to this service. 

Each name and port mapping must be unique within the namespace.
Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServiceConnectClientAliasArgs added in v0.41.0 

type ServiceConnectClientAliasArgs struct {
	// The “dnsName“ is the name that you use in the applications of client tasks to connect to this service. The name must be a valid DNS name but doesn't need to be fully-qualified. The name can include up to 127 characters. The name can include lowercase letters, numbers, underscores (_), hyphens (-), and periods (.). The name can't start with a hyphen.
	//  If this parameter isn't specified, the default value of “discoveryName.namespace“ is used. If the “discoveryName“ isn't specified, the port mapping name from the task definition is used in “portName.namespace“.
	//  To avoid changing your applications in client Amazon ECS services, set this to the same name that the client application uses by default. For example, a few common names are “database“, “db“, or the lowercase name of a database, such as “mysql“ or “redis“. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	DnsName pulumi.StringPtrInput `pulumi:"dnsName"`
	// The listening port number for the Service Connect proxy. This port is available inside of all of the tasks within the same namespace.
	//  To avoid changing your applications in client Amazon ECS services, set this to the same port that the client application uses by default. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	Port pulumi.IntInput `pulumi:"port"`
}

Each alias ("endpoint") is a fully-qualified name and port number that other tasks ("clients") can use to connect to this service. 

Each name and port mapping must be unique within the namespace.
Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceConnectClientAliasArgs) ElementType added in v0.41.0 

func (ServiceConnectClientAliasArgs) ElementType() reflect.Type

func (ServiceConnectClientAliasArgs) ToServiceConnectClientAliasOutput added in v0.41.0 

func (i ServiceConnectClientAliasArgs) ToServiceConnectClientAliasOutput() ServiceConnectClientAliasOutput

func (ServiceConnectClientAliasArgs) ToServiceConnectClientAliasOutputWithContext added in v0.41.0 

func (i ServiceConnectClientAliasArgs) ToServiceConnectClientAliasOutputWithContext(ctx context.Context) ServiceConnectClientAliasOutput

type ServiceConnectClientAliasArray added in v0.41.0 

type ServiceConnectClientAliasArray []ServiceConnectClientAliasInput

func (ServiceConnectClientAliasArray) ElementType added in v0.41.0 

func (ServiceConnectClientAliasArray) ElementType() reflect.Type

func (ServiceConnectClientAliasArray) ToServiceConnectClientAliasArrayOutput added in v0.41.0 

func (i ServiceConnectClientAliasArray) ToServiceConnectClientAliasArrayOutput() ServiceConnectClientAliasArrayOutput

func (ServiceConnectClientAliasArray) ToServiceConnectClientAliasArrayOutputWithContext added in v0.41.0 

func (i ServiceConnectClientAliasArray) ToServiceConnectClientAliasArrayOutputWithContext(ctx context.Context) ServiceConnectClientAliasArrayOutput

type ServiceConnectClientAliasArrayInput added in v0.41.0 

type ServiceConnectClientAliasArrayInput interface {
	pulumi.Input

	ToServiceConnectClientAliasArrayOutput() ServiceConnectClientAliasArrayOutput
	ToServiceConnectClientAliasArrayOutputWithContext(context.Context) ServiceConnectClientAliasArrayOutput
}

ServiceConnectClientAliasArrayInput is an input type that accepts ServiceConnectClientAliasArray and ServiceConnectClientAliasArrayOutput values. You can construct a concrete instance of `ServiceConnectClientAliasArrayInput` via: 

ServiceConnectClientAliasArray{ ServiceConnectClientAliasArgs{...} }

type ServiceConnectClientAliasArrayOutput added in v0.41.0 

type ServiceConnectClientAliasArrayOutput struct{ *pulumi.OutputState }

func (ServiceConnectClientAliasArrayOutput) ElementType added in v0.41.0 

func (ServiceConnectClientAliasArrayOutput) ElementType() reflect.Type

func (ServiceConnectClientAliasArrayOutput) Index added in v0.41.0 

func (o ServiceConnectClientAliasArrayOutput) Index(i pulumi.IntInput) ServiceConnectClientAliasOutput

func (ServiceConnectClientAliasArrayOutput) ToServiceConnectClientAliasArrayOutput added in v0.41.0 

func (o ServiceConnectClientAliasArrayOutput) ToServiceConnectClientAliasArrayOutput() ServiceConnectClientAliasArrayOutput

func (ServiceConnectClientAliasArrayOutput) ToServiceConnectClientAliasArrayOutputWithContext added in v0.41.0 

func (o ServiceConnectClientAliasArrayOutput) ToServiceConnectClientAliasArrayOutputWithContext(ctx context.Context) ServiceConnectClientAliasArrayOutput

type ServiceConnectClientAliasInput added in v0.41.0 

type ServiceConnectClientAliasInput interface {
	pulumi.Input

	ToServiceConnectClientAliasOutput() ServiceConnectClientAliasOutput
	ToServiceConnectClientAliasOutputWithContext(context.Context) ServiceConnectClientAliasOutput
}

ServiceConnectClientAliasInput is an input type that accepts ServiceConnectClientAliasArgs and ServiceConnectClientAliasOutput values. You can construct a concrete instance of `ServiceConnectClientAliasInput` via: 

ServiceConnectClientAliasArgs{...}

type ServiceConnectClientAliasOutput added in v0.41.0 

type ServiceConnectClientAliasOutput struct{ *pulumi.OutputState }

Each alias ("endpoint") is a fully-qualified name and port number that other tasks ("clients") can use to connect to this service. 

Each name and port mapping must be unique within the namespace.
Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceConnectClientAliasOutput) DnsName added in v0.41.0 

func (o ServiceConnectClientAliasOutput) DnsName() pulumi.StringPtrOutput

The “dnsName“ is the name that you use in the applications of client tasks to connect to this service. The name must be a valid DNS name but doesn't need to be fully-qualified. The name can include up to 127 characters. The name can include lowercase letters, numbers, underscores (_), hyphens (-), and periods (.). The name can't start with a hyphen. 

If this parameter isn't specified, the default value of ``discoveryName.namespace`` is used. If the ``discoveryName`` isn't specified, the port mapping name from the task definition is used in ``portName.namespace``.
To avoid changing your applications in client Amazon ECS services, set this to the same name that the client application uses by default. For example, a few common names are ``database``, ``db``, or the lowercase name of a database, such as ``mysql`` or ``redis``. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceConnectClientAliasOutput) ElementType added in v0.41.0 

func (ServiceConnectClientAliasOutput) ElementType() reflect.Type

func (ServiceConnectClientAliasOutput) Port added in v0.41.0 

func (o ServiceConnectClientAliasOutput) Port() pulumi.IntOutput

The listening port number for the Service Connect proxy. This port is available inside of all of the tasks within the same namespace. 

To avoid changing your applications in client Amazon ECS services, set this to the same port that the client application uses by default. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceConnectClientAliasOutput) ToServiceConnectClientAliasOutput added in v0.41.0 

func (o ServiceConnectClientAliasOutput) ToServiceConnectClientAliasOutput() ServiceConnectClientAliasOutput

func (ServiceConnectClientAliasOutput) ToServiceConnectClientAliasOutputWithContext added in v0.41.0 

func (o ServiceConnectClientAliasOutput) ToServiceConnectClientAliasOutputWithContext(ctx context.Context) ServiceConnectClientAliasOutput

type ServiceConnectConfiguration added in v0.41.0 

type ServiceConnectConfiguration struct {
	// Specifies whether to use Service Connect with this service.
	Enabled bool `pulumi:"enabled"`
	// The log configuration for the container. This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/run/).
	//  By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition. For more information about the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
	//  Understand the following when specifying a log configuration for your containers.
	//   +  Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.
	//       For tasks on FARGATElong, the supported log drivers are “awslogs“, “splunk“, and “awsfirelens“.
	//       For tasks hosted on Amazon EC2 instances, the supported log drivers are “awslogs“, “fluentd“, “gelf“, “json-file“, “journald“, “logentries“,“syslog“, “splunk“, and “awsfirelens“.
	//   +  This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.
	//   +  For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the “ECS_AVAILABLE_LOGGING_DRIVERS“ environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS container agent configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   +  For tasks that are on FARGATElong, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.
	LogConfiguration *ServiceLogConfiguration `pulumi:"logConfiguration"`
	// The namespace name or full Amazon Resource Name (ARN) of the CMAPlong namespace for use with Service Connect. The namespace must be in the same AWS Region as the Amazon ECS service and cluster. The type of namespace doesn't affect Service Connect. For more information about CMAPlong, see [Working with Services](https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html) in the *Developer Guide*.
	Namespace *string `pulumi:"namespace"`
	// The list of Service Connect service objects. These are names and aliases (also known as endpoints) that are used by other Amazon ECS services to connect to this service.
	//  This field is not required for a "client" Amazon ECS service that's a member of a namespace only to connect to other services within the namespace. An example of this would be a frontend application that accepts incoming requests from either a load balancer that's attached to the service or by other means.
	//  An object selects a port from the task definition, assigns a name for the CMAPlong service, and a list of aliases (endpoints) and ports for client applications to refer to this service.
	Services []ServiceConnectService `pulumi:"services"`
}

The Service Connect configuration of your Amazon ECS service. The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace. 

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServiceConnectConfigurationArgs added in v0.41.0 

type ServiceConnectConfigurationArgs struct {
	// Specifies whether to use Service Connect with this service.
	Enabled pulumi.BoolInput `pulumi:"enabled"`
	// The log configuration for the container. This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/run/).
	//  By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition. For more information about the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
	//  Understand the following when specifying a log configuration for your containers.
	//   +  Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.
	//       For tasks on FARGATElong, the supported log drivers are “awslogs“, “splunk“, and “awsfirelens“.
	//       For tasks hosted on Amazon EC2 instances, the supported log drivers are “awslogs“, “fluentd“, “gelf“, “json-file“, “journald“, “logentries“,“syslog“, “splunk“, and “awsfirelens“.
	//   +  This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.
	//   +  For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the “ECS_AVAILABLE_LOGGING_DRIVERS“ environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS container agent configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   +  For tasks that are on FARGATElong, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.
	LogConfiguration ServiceLogConfigurationPtrInput `pulumi:"logConfiguration"`
	// The namespace name or full Amazon Resource Name (ARN) of the CMAPlong namespace for use with Service Connect. The namespace must be in the same AWS Region as the Amazon ECS service and cluster. The type of namespace doesn't affect Service Connect. For more information about CMAPlong, see [Working with Services](https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html) in the *Developer Guide*.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
	// The list of Service Connect service objects. These are names and aliases (also known as endpoints) that are used by other Amazon ECS services to connect to this service.
	//  This field is not required for a "client" Amazon ECS service that's a member of a namespace only to connect to other services within the namespace. An example of this would be a frontend application that accepts incoming requests from either a load balancer that's attached to the service or by other means.
	//  An object selects a port from the task definition, assigns a name for the CMAPlong service, and a list of aliases (endpoints) and ports for client applications to refer to this service.
	Services ServiceConnectServiceArrayInput `pulumi:"services"`
}

The Service Connect configuration of your Amazon ECS service. The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace. 

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceConnectConfigurationArgs) ElementType added in v0.41.0 

func (ServiceConnectConfigurationArgs) ElementType() reflect.Type

func (ServiceConnectConfigurationArgs) ToServiceConnectConfigurationOutput added in v0.41.0 

func (i ServiceConnectConfigurationArgs) ToServiceConnectConfigurationOutput() ServiceConnectConfigurationOutput

func (ServiceConnectConfigurationArgs) ToServiceConnectConfigurationOutputWithContext added in v0.41.0 

func (i ServiceConnectConfigurationArgs) ToServiceConnectConfigurationOutputWithContext(ctx context.Context) ServiceConnectConfigurationOutput

func (ServiceConnectConfigurationArgs) ToServiceConnectConfigurationPtrOutput added in v0.41.0 

func (i ServiceConnectConfigurationArgs) ToServiceConnectConfigurationPtrOutput() ServiceConnectConfigurationPtrOutput

func (ServiceConnectConfigurationArgs) ToServiceConnectConfigurationPtrOutputWithContext added in v0.41.0 

func (i ServiceConnectConfigurationArgs) ToServiceConnectConfigurationPtrOutputWithContext(ctx context.Context) ServiceConnectConfigurationPtrOutput

type ServiceConnectConfigurationInput added in v0.41.0 

type ServiceConnectConfigurationInput interface {
	pulumi.Input

	ToServiceConnectConfigurationOutput() ServiceConnectConfigurationOutput
	ToServiceConnectConfigurationOutputWithContext(context.Context) ServiceConnectConfigurationOutput
}

ServiceConnectConfigurationInput is an input type that accepts ServiceConnectConfigurationArgs and ServiceConnectConfigurationOutput values. You can construct a concrete instance of `ServiceConnectConfigurationInput` via: 

ServiceConnectConfigurationArgs{...}

type ServiceConnectConfigurationOutput added in v0.41.0 

type ServiceConnectConfigurationOutput struct{ *pulumi.OutputState }

The Service Connect configuration of your Amazon ECS service. The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace. 

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceConnectConfigurationOutput) ElementType added in v0.41.0 

func (ServiceConnectConfigurationOutput) ElementType() reflect.Type

func (ServiceConnectConfigurationOutput) Enabled added in v0.41.0 

func (o ServiceConnectConfigurationOutput) Enabled() pulumi.BoolOutput

Specifies whether to use Service Connect with this service.

func (ServiceConnectConfigurationOutput) LogConfiguration added in v0.41.0 

func (o ServiceConnectConfigurationOutput) LogConfiguration() ServiceLogConfigurationPtrOutput

The log configuration for the container. This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/run/). 

By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition. For more information about the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
Understand the following when specifying a log configuration for your containers.
 +  Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.
     For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
     For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
 +  This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.
 +  For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the ``ECS_AVAILABLE_LOGGING_DRIVERS`` environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS container agent configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
 +  For tasks that are on FARGATElong, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.

func (ServiceConnectConfigurationOutput) Namespace added in v0.41.0 

func (o ServiceConnectConfigurationOutput) Namespace() pulumi.StringPtrOutput

The namespace name or full Amazon Resource Name (ARN) of the CMAPlong namespace for use with Service Connect. The namespace must be in the same AWS Region as the Amazon ECS service and cluster. The type of namespace doesn't affect Service Connect. For more information about CMAPlong, see [Working with Services](https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html) in the *Developer Guide*.

func (ServiceConnectConfigurationOutput) Services added in v0.41.0 

func (o ServiceConnectConfigurationOutput) Services() ServiceConnectServiceArrayOutput

The list of Service Connect service objects. These are names and aliases (also known as endpoints) that are used by other Amazon ECS services to connect to this service. 

This field is not required for a "client" Amazon ECS service that's a member of a namespace only to connect to other services within the namespace. An example of this would be a frontend application that accepts incoming requests from either a load balancer that's attached to the service or by other means.
An object selects a port from the task definition, assigns a name for the CMAPlong service, and a list of aliases (endpoints) and ports for client applications to refer to this service.

func (ServiceConnectConfigurationOutput) ToServiceConnectConfigurationOutput added in v0.41.0 

func (o ServiceConnectConfigurationOutput) ToServiceConnectConfigurationOutput() ServiceConnectConfigurationOutput

func (ServiceConnectConfigurationOutput) ToServiceConnectConfigurationOutputWithContext added in v0.41.0 

func (o ServiceConnectConfigurationOutput) ToServiceConnectConfigurationOutputWithContext(ctx context.Context) ServiceConnectConfigurationOutput

func (ServiceConnectConfigurationOutput) ToServiceConnectConfigurationPtrOutput added in v0.41.0 

func (o ServiceConnectConfigurationOutput) ToServiceConnectConfigurationPtrOutput() ServiceConnectConfigurationPtrOutput

func (ServiceConnectConfigurationOutput) ToServiceConnectConfigurationPtrOutputWithContext added in v0.41.0 

func (o ServiceConnectConfigurationOutput) ToServiceConnectConfigurationPtrOutputWithContext(ctx context.Context) ServiceConnectConfigurationPtrOutput

type ServiceConnectConfigurationPtrInput added in v0.41.0 

type ServiceConnectConfigurationPtrInput interface {
	pulumi.Input

	ToServiceConnectConfigurationPtrOutput() ServiceConnectConfigurationPtrOutput
	ToServiceConnectConfigurationPtrOutputWithContext(context.Context) ServiceConnectConfigurationPtrOutput
}

ServiceConnectConfigurationPtrInput is an input type that accepts ServiceConnectConfigurationArgs, ServiceConnectConfigurationPtr and ServiceConnectConfigurationPtrOutput values. You can construct a concrete instance of `ServiceConnectConfigurationPtrInput` via: 

        ServiceConnectConfigurationArgs{...}

or:

        nil

func ServiceConnectConfigurationPtr added in v0.41.0 

func ServiceConnectConfigurationPtr(v *ServiceConnectConfigurationArgs) ServiceConnectConfigurationPtrInput

type ServiceConnectConfigurationPtrOutput added in v0.41.0 

type ServiceConnectConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceConnectConfigurationPtrOutput) Elem added in v0.41.0 

func (o ServiceConnectConfigurationPtrOutput) Elem() ServiceConnectConfigurationOutput

func (ServiceConnectConfigurationPtrOutput) ElementType added in v0.41.0 

func (ServiceConnectConfigurationPtrOutput) ElementType() reflect.Type

func (ServiceConnectConfigurationPtrOutput) Enabled added in v0.41.0 

func (o ServiceConnectConfigurationPtrOutput) Enabled() pulumi.BoolPtrOutput

Specifies whether to use Service Connect with this service.

func (ServiceConnectConfigurationPtrOutput) LogConfiguration added in v0.41.0 

func (o ServiceConnectConfigurationPtrOutput) LogConfiguration() ServiceLogConfigurationPtrOutput

The log configuration for the container. This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/run/). 

By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition. For more information about the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
Understand the following when specifying a log configuration for your containers.
 +  Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.
     For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
     For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
 +  This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.
 +  For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the ``ECS_AVAILABLE_LOGGING_DRIVERS`` environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS container agent configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
 +  For tasks that are on FARGATElong, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.

func (ServiceConnectConfigurationPtrOutput) Namespace added in v0.41.0 

func (o ServiceConnectConfigurationPtrOutput) Namespace() pulumi.StringPtrOutput

The namespace name or full Amazon Resource Name (ARN) of the CMAPlong namespace for use with Service Connect. The namespace must be in the same AWS Region as the Amazon ECS service and cluster. The type of namespace doesn't affect Service Connect. For more information about CMAPlong, see [Working with Services](https://docs.aws.amazon.com/cloud-map/latest/dg/working-with-services.html) in the *Developer Guide*.

func (ServiceConnectConfigurationPtrOutput) Services added in v0.41.0 

func (o ServiceConnectConfigurationPtrOutput) Services() ServiceConnectServiceArrayOutput

The list of Service Connect service objects. These are names and aliases (also known as endpoints) that are used by other Amazon ECS services to connect to this service. 

This field is not required for a "client" Amazon ECS service that's a member of a namespace only to connect to other services within the namespace. An example of this would be a frontend application that accepts incoming requests from either a load balancer that's attached to the service or by other means.
An object selects a port from the task definition, assigns a name for the CMAPlong service, and a list of aliases (endpoints) and ports for client applications to refer to this service.

func (ServiceConnectConfigurationPtrOutput) ToServiceConnectConfigurationPtrOutput added in v0.41.0 

func (o ServiceConnectConfigurationPtrOutput) ToServiceConnectConfigurationPtrOutput() ServiceConnectConfigurationPtrOutput

func (ServiceConnectConfigurationPtrOutput) ToServiceConnectConfigurationPtrOutputWithContext added in v0.41.0 

func (o ServiceConnectConfigurationPtrOutput) ToServiceConnectConfigurationPtrOutputWithContext(ctx context.Context) ServiceConnectConfigurationPtrOutput

type ServiceConnectService added in v0.41.0 

type ServiceConnectService struct {
	// The list of client aliases for this Service Connect service. You use these to assign names that can be used by client applications. The maximum number of client aliases that you can have in this list is 1.
	//  Each alias ("endpoint") is a fully-qualified name and port number that other Amazon ECS tasks ("clients") can use to connect to this service.
	//  Each name and port mapping must be unique within the namespace.
	//  For each “ServiceConnectService“, you must provide at least one “clientAlias“ with one “port“.
	ClientAliases []ServiceConnectClientAlias `pulumi:"clientAliases"`
	// The “discoveryName“ is the name of the new CMAP service that Amazon ECS creates for this Amazon ECS service. This must be unique within the CMAP namespace. The name can contain up to 64 characters. The name can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen.
	//  If the “discoveryName“ isn't specified, the port mapping name from the task definition is used in “portName.namespace“.
	DiscoveryName *string `pulumi:"discoveryName"`
	// The port number for the Service Connect proxy to listen on.
	//  Use the value of this field to bypass the proxy for traffic on the port number specified in the named “portMapping“ in the task definition of this application, and then use it in your VPC security groups to allow traffic into the proxy for this Amazon ECS service.
	//  In “awsvpc“ mode and Fargate, the default value is the container port number. The container port number is in the “portMapping“ in the task definition. In bridge mode, the default value is the ephemeral port of the Service Connect proxy.
	IngressPortOverride *int `pulumi:"ingressPortOverride"`
	// The “portName“ must match the name of one of the “portMappings“ from all the containers in the task definition of this Amazon ECS service.
	PortName string `pulumi:"portName"`
	// A reference to an object that represents the configured timeouts for Service Connect.
	Timeout *ServiceTimeoutConfiguration `pulumi:"timeout"`
	// A reference to an object that represents a Transport Layer Security (TLS) configuration.
	Tls *ServiceConnectTlsConfiguration `pulumi:"tls"`
}

The Service Connect service object configuration. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServiceConnectServiceArgs added in v0.41.0 

type ServiceConnectServiceArgs struct {
	// The list of client aliases for this Service Connect service. You use these to assign names that can be used by client applications. The maximum number of client aliases that you can have in this list is 1.
	//  Each alias ("endpoint") is a fully-qualified name and port number that other Amazon ECS tasks ("clients") can use to connect to this service.
	//  Each name and port mapping must be unique within the namespace.
	//  For each “ServiceConnectService“, you must provide at least one “clientAlias“ with one “port“.
	ClientAliases ServiceConnectClientAliasArrayInput `pulumi:"clientAliases"`
	// The “discoveryName“ is the name of the new CMAP service that Amazon ECS creates for this Amazon ECS service. This must be unique within the CMAP namespace. The name can contain up to 64 characters. The name can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen.
	//  If the “discoveryName“ isn't specified, the port mapping name from the task definition is used in “portName.namespace“.
	DiscoveryName pulumi.StringPtrInput `pulumi:"discoveryName"`
	// The port number for the Service Connect proxy to listen on.
	//  Use the value of this field to bypass the proxy for traffic on the port number specified in the named “portMapping“ in the task definition of this application, and then use it in your VPC security groups to allow traffic into the proxy for this Amazon ECS service.
	//  In “awsvpc“ mode and Fargate, the default value is the container port number. The container port number is in the “portMapping“ in the task definition. In bridge mode, the default value is the ephemeral port of the Service Connect proxy.
	IngressPortOverride pulumi.IntPtrInput `pulumi:"ingressPortOverride"`
	// The “portName“ must match the name of one of the “portMappings“ from all the containers in the task definition of this Amazon ECS service.
	PortName pulumi.StringInput `pulumi:"portName"`
	// A reference to an object that represents the configured timeouts for Service Connect.
	Timeout ServiceTimeoutConfigurationPtrInput `pulumi:"timeout"`
	// A reference to an object that represents a Transport Layer Security (TLS) configuration.
	Tls ServiceConnectTlsConfigurationPtrInput `pulumi:"tls"`
}

The Service Connect service object configuration. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceConnectServiceArgs) ElementType added in v0.41.0 

func (ServiceConnectServiceArgs) ElementType() reflect.Type

func (ServiceConnectServiceArgs) ToServiceConnectServiceOutput added in v0.41.0 

func (i ServiceConnectServiceArgs) ToServiceConnectServiceOutput() ServiceConnectServiceOutput

func (ServiceConnectServiceArgs) ToServiceConnectServiceOutputWithContext added in v0.41.0 

func (i ServiceConnectServiceArgs) ToServiceConnectServiceOutputWithContext(ctx context.Context) ServiceConnectServiceOutput

type ServiceConnectServiceArray added in v0.41.0 

type ServiceConnectServiceArray []ServiceConnectServiceInput

func (ServiceConnectServiceArray) ElementType added in v0.41.0 

func (ServiceConnectServiceArray) ElementType() reflect.Type

func (ServiceConnectServiceArray) ToServiceConnectServiceArrayOutput added in v0.41.0 

func (i ServiceConnectServiceArray) ToServiceConnectServiceArrayOutput() ServiceConnectServiceArrayOutput

func (ServiceConnectServiceArray) ToServiceConnectServiceArrayOutputWithContext added in v0.41.0 

func (i ServiceConnectServiceArray) ToServiceConnectServiceArrayOutputWithContext(ctx context.Context) ServiceConnectServiceArrayOutput

type ServiceConnectServiceArrayInput added in v0.41.0 

type ServiceConnectServiceArrayInput interface {
	pulumi.Input

	ToServiceConnectServiceArrayOutput() ServiceConnectServiceArrayOutput
	ToServiceConnectServiceArrayOutputWithContext(context.Context) ServiceConnectServiceArrayOutput
}

ServiceConnectServiceArrayInput is an input type that accepts ServiceConnectServiceArray and ServiceConnectServiceArrayOutput values. You can construct a concrete instance of `ServiceConnectServiceArrayInput` via: 

ServiceConnectServiceArray{ ServiceConnectServiceArgs{...} }

type ServiceConnectServiceArrayOutput added in v0.41.0 

type ServiceConnectServiceArrayOutput struct{ *pulumi.OutputState }

func (ServiceConnectServiceArrayOutput) ElementType added in v0.41.0 

func (ServiceConnectServiceArrayOutput) ElementType() reflect.Type

func (ServiceConnectServiceArrayOutput) Index added in v0.41.0 

func (o ServiceConnectServiceArrayOutput) Index(i pulumi.IntInput) ServiceConnectServiceOutput

func (ServiceConnectServiceArrayOutput) ToServiceConnectServiceArrayOutput added in v0.41.0 

func (o ServiceConnectServiceArrayOutput) ToServiceConnectServiceArrayOutput() ServiceConnectServiceArrayOutput

func (ServiceConnectServiceArrayOutput) ToServiceConnectServiceArrayOutputWithContext added in v0.41.0 

func (o ServiceConnectServiceArrayOutput) ToServiceConnectServiceArrayOutputWithContext(ctx context.Context) ServiceConnectServiceArrayOutput

type ServiceConnectServiceInput added in v0.41.0 

type ServiceConnectServiceInput interface {
	pulumi.Input

	ToServiceConnectServiceOutput() ServiceConnectServiceOutput
	ToServiceConnectServiceOutputWithContext(context.Context) ServiceConnectServiceOutput
}

ServiceConnectServiceInput is an input type that accepts ServiceConnectServiceArgs and ServiceConnectServiceOutput values. You can construct a concrete instance of `ServiceConnectServiceInput` via: 

ServiceConnectServiceArgs{...}

type ServiceConnectServiceOutput added in v0.41.0 

type ServiceConnectServiceOutput struct{ *pulumi.OutputState }

The Service Connect service object configuration. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceConnectServiceOutput) ClientAliases added in v0.41.0 

func (o ServiceConnectServiceOutput) ClientAliases() ServiceConnectClientAliasArrayOutput

The list of client aliases for this Service Connect service. You use these to assign names that can be used by client applications. The maximum number of client aliases that you can have in this list is 1. 

Each alias ("endpoint") is a fully-qualified name and port number that other Amazon ECS tasks ("clients") can use to connect to this service.
Each name and port mapping must be unique within the namespace.
For each ``ServiceConnectService``, you must provide at least one ``clientAlias`` with one ``port``.

func (ServiceConnectServiceOutput) DiscoveryName added in v0.41.0 

func (o ServiceConnectServiceOutput) DiscoveryName() pulumi.StringPtrOutput

The “discoveryName“ is the name of the new CMAP service that Amazon ECS creates for this Amazon ECS service. This must be unique within the CMAP namespace. The name can contain up to 64 characters. The name can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen. 

If the ``discoveryName`` isn't specified, the port mapping name from the task definition is used in ``portName.namespace``.

func (ServiceConnectServiceOutput) ElementType added in v0.41.0 

func (ServiceConnectServiceOutput) ElementType() reflect.Type

func (ServiceConnectServiceOutput) IngressPortOverride added in v0.41.0 

func (o ServiceConnectServiceOutput) IngressPortOverride() pulumi.IntPtrOutput

The port number for the Service Connect proxy to listen on. 

Use the value of this field to bypass the proxy for traffic on the port number specified in the named ``portMapping`` in the task definition of this application, and then use it in your VPC security groups to allow traffic into the proxy for this Amazon ECS service.
In ``awsvpc`` mode and Fargate, the default value is the container port number. The container port number is in the ``portMapping`` in the task definition. In bridge mode, the default value is the ephemeral port of the Service Connect proxy.

func (ServiceConnectServiceOutput) PortName added in v0.41.0 

func (o ServiceConnectServiceOutput) PortName() pulumi.StringOutput

The “portName“ must match the name of one of the “portMappings“ from all the containers in the task definition of this Amazon ECS service.

func (ServiceConnectServiceOutput) Timeout added in v0.95.0 

func (o ServiceConnectServiceOutput) Timeout() ServiceTimeoutConfigurationPtrOutput

A reference to an object that represents the configured timeouts for Service Connect.

func (ServiceConnectServiceOutput) Tls added in v0.95.0 

func (o ServiceConnectServiceOutput) Tls() ServiceConnectTlsConfigurationPtrOutput

A reference to an object that represents a Transport Layer Security (TLS) configuration.

func (ServiceConnectServiceOutput) ToServiceConnectServiceOutput added in v0.41.0 

func (o ServiceConnectServiceOutput) ToServiceConnectServiceOutput() ServiceConnectServiceOutput

func (ServiceConnectServiceOutput) ToServiceConnectServiceOutputWithContext added in v0.41.0 

func (o ServiceConnectServiceOutput) ToServiceConnectServiceOutputWithContext(ctx context.Context) ServiceConnectServiceOutput

type ServiceConnectTlsCertificateAuthority added in v0.95.0 

type ServiceConnectTlsCertificateAuthority struct {
	// The ARN of the AWS Private Certificate Authority certificate.
	AwsPcaAuthorityArn *string `pulumi:"awsPcaAuthorityArn"`
}

An object that represents the AWS Private Certificate Authority certificate.

type ServiceConnectTlsCertificateAuthorityArgs added in v0.95.0 

type ServiceConnectTlsCertificateAuthorityArgs struct {
	// The ARN of the AWS Private Certificate Authority certificate.
	AwsPcaAuthorityArn pulumi.StringPtrInput `pulumi:"awsPcaAuthorityArn"`
}

An object that represents the AWS Private Certificate Authority certificate.

func (ServiceConnectTlsCertificateAuthorityArgs) ElementType added in v0.95.0 

func (ServiceConnectTlsCertificateAuthorityArgs) ElementType() reflect.Type

func (ServiceConnectTlsCertificateAuthorityArgs) ToServiceConnectTlsCertificateAuthorityOutput added in v0.95.0 

func (i ServiceConnectTlsCertificateAuthorityArgs) ToServiceConnectTlsCertificateAuthorityOutput() ServiceConnectTlsCertificateAuthorityOutput

func (ServiceConnectTlsCertificateAuthorityArgs) ToServiceConnectTlsCertificateAuthorityOutputWithContext added in v0.95.0 

func (i ServiceConnectTlsCertificateAuthorityArgs) ToServiceConnectTlsCertificateAuthorityOutputWithContext(ctx context.Context) ServiceConnectTlsCertificateAuthorityOutput

func (ServiceConnectTlsCertificateAuthorityArgs) ToServiceConnectTlsCertificateAuthorityPtrOutput added in v0.95.0 

func (i ServiceConnectTlsCertificateAuthorityArgs) ToServiceConnectTlsCertificateAuthorityPtrOutput() ServiceConnectTlsCertificateAuthorityPtrOutput

func (ServiceConnectTlsCertificateAuthorityArgs) ToServiceConnectTlsCertificateAuthorityPtrOutputWithContext added in v0.95.0 

func (i ServiceConnectTlsCertificateAuthorityArgs) ToServiceConnectTlsCertificateAuthorityPtrOutputWithContext(ctx context.Context) ServiceConnectTlsCertificateAuthorityPtrOutput

type ServiceConnectTlsCertificateAuthorityInput added in v0.95.0 

type ServiceConnectTlsCertificateAuthorityInput interface {
	pulumi.Input

	ToServiceConnectTlsCertificateAuthorityOutput() ServiceConnectTlsCertificateAuthorityOutput
	ToServiceConnectTlsCertificateAuthorityOutputWithContext(context.Context) ServiceConnectTlsCertificateAuthorityOutput
}

ServiceConnectTlsCertificateAuthorityInput is an input type that accepts ServiceConnectTlsCertificateAuthorityArgs and ServiceConnectTlsCertificateAuthorityOutput values. You can construct a concrete instance of `ServiceConnectTlsCertificateAuthorityInput` via: 

ServiceConnectTlsCertificateAuthorityArgs{...}

type ServiceConnectTlsCertificateAuthorityOutput added in v0.95.0 

type ServiceConnectTlsCertificateAuthorityOutput struct{ *pulumi.OutputState }

An object that represents the AWS Private Certificate Authority certificate.

func (ServiceConnectTlsCertificateAuthorityOutput) AwsPcaAuthorityArn added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityOutput) AwsPcaAuthorityArn() pulumi.StringPtrOutput

The ARN of the AWS Private Certificate Authority certificate.

func (ServiceConnectTlsCertificateAuthorityOutput) ElementType added in v0.95.0 

func (ServiceConnectTlsCertificateAuthorityOutput) ElementType() reflect.Type

func (ServiceConnectTlsCertificateAuthorityOutput) ToServiceConnectTlsCertificateAuthorityOutput added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityOutput) ToServiceConnectTlsCertificateAuthorityOutput() ServiceConnectTlsCertificateAuthorityOutput

func (ServiceConnectTlsCertificateAuthorityOutput) ToServiceConnectTlsCertificateAuthorityOutputWithContext added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityOutput) ToServiceConnectTlsCertificateAuthorityOutputWithContext(ctx context.Context) ServiceConnectTlsCertificateAuthorityOutput

func (ServiceConnectTlsCertificateAuthorityOutput) ToServiceConnectTlsCertificateAuthorityPtrOutput added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityOutput) ToServiceConnectTlsCertificateAuthorityPtrOutput() ServiceConnectTlsCertificateAuthorityPtrOutput

func (ServiceConnectTlsCertificateAuthorityOutput) ToServiceConnectTlsCertificateAuthorityPtrOutputWithContext added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityOutput) ToServiceConnectTlsCertificateAuthorityPtrOutputWithContext(ctx context.Context) ServiceConnectTlsCertificateAuthorityPtrOutput

type ServiceConnectTlsCertificateAuthorityPtrInput added in v0.95.0 

type ServiceConnectTlsCertificateAuthorityPtrInput interface {
	pulumi.Input

	ToServiceConnectTlsCertificateAuthorityPtrOutput() ServiceConnectTlsCertificateAuthorityPtrOutput
	ToServiceConnectTlsCertificateAuthorityPtrOutputWithContext(context.Context) ServiceConnectTlsCertificateAuthorityPtrOutput
}

ServiceConnectTlsCertificateAuthorityPtrInput is an input type that accepts ServiceConnectTlsCertificateAuthorityArgs, ServiceConnectTlsCertificateAuthorityPtr and ServiceConnectTlsCertificateAuthorityPtrOutput values. You can construct a concrete instance of `ServiceConnectTlsCertificateAuthorityPtrInput` via: 

        ServiceConnectTlsCertificateAuthorityArgs{...}

or:

        nil

func ServiceConnectTlsCertificateAuthorityPtr added in v0.95.0 

func ServiceConnectTlsCertificateAuthorityPtr(v *ServiceConnectTlsCertificateAuthorityArgs) ServiceConnectTlsCertificateAuthorityPtrInput

type ServiceConnectTlsCertificateAuthorityPtrOutput added in v0.95.0 

type ServiceConnectTlsCertificateAuthorityPtrOutput struct{ *pulumi.OutputState }

func (ServiceConnectTlsCertificateAuthorityPtrOutput) AwsPcaAuthorityArn added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityPtrOutput) AwsPcaAuthorityArn() pulumi.StringPtrOutput

The ARN of the AWS Private Certificate Authority certificate.

func (ServiceConnectTlsCertificateAuthorityPtrOutput) Elem added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityPtrOutput) Elem() ServiceConnectTlsCertificateAuthorityOutput

func (ServiceConnectTlsCertificateAuthorityPtrOutput) ElementType added in v0.95.0 

func (ServiceConnectTlsCertificateAuthorityPtrOutput) ElementType() reflect.Type

func (ServiceConnectTlsCertificateAuthorityPtrOutput) ToServiceConnectTlsCertificateAuthorityPtrOutput added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityPtrOutput) ToServiceConnectTlsCertificateAuthorityPtrOutput() ServiceConnectTlsCertificateAuthorityPtrOutput

func (ServiceConnectTlsCertificateAuthorityPtrOutput) ToServiceConnectTlsCertificateAuthorityPtrOutputWithContext added in v0.95.0 

func (o ServiceConnectTlsCertificateAuthorityPtrOutput) ToServiceConnectTlsCertificateAuthorityPtrOutputWithContext(ctx context.Context) ServiceConnectTlsCertificateAuthorityPtrOutput

type ServiceConnectTlsConfiguration added in v0.95.0 

type ServiceConnectTlsConfiguration struct {
	// The signer certificate authority.
	IssuerCertificateAuthority ServiceConnectTlsCertificateAuthority `pulumi:"issuerCertificateAuthority"`
	// The AWS Key Management Service key.
	KmsKey *string `pulumi:"kmsKey"`
	// The Amazon Resource Name (ARN) of the IAM role that's associated with the Service Connect TLS.
	RoleArn *string `pulumi:"roleArn"`
}

An object that represents the configuration for Service Connect TLS.

type ServiceConnectTlsConfigurationArgs added in v0.95.0 

type ServiceConnectTlsConfigurationArgs struct {
	// The signer certificate authority.
	IssuerCertificateAuthority ServiceConnectTlsCertificateAuthorityInput `pulumi:"issuerCertificateAuthority"`
	// The AWS Key Management Service key.
	KmsKey pulumi.StringPtrInput `pulumi:"kmsKey"`
	// The Amazon Resource Name (ARN) of the IAM role that's associated with the Service Connect TLS.
	RoleArn pulumi.StringPtrInput `pulumi:"roleArn"`
}

An object that represents the configuration for Service Connect TLS.

func (ServiceConnectTlsConfigurationArgs) ElementType added in v0.95.0 

func (ServiceConnectTlsConfigurationArgs) ElementType() reflect.Type

func (ServiceConnectTlsConfigurationArgs) ToServiceConnectTlsConfigurationOutput added in v0.95.0 

func (i ServiceConnectTlsConfigurationArgs) ToServiceConnectTlsConfigurationOutput() ServiceConnectTlsConfigurationOutput

func (ServiceConnectTlsConfigurationArgs) ToServiceConnectTlsConfigurationOutputWithContext added in v0.95.0 

func (i ServiceConnectTlsConfigurationArgs) ToServiceConnectTlsConfigurationOutputWithContext(ctx context.Context) ServiceConnectTlsConfigurationOutput

func (ServiceConnectTlsConfigurationArgs) ToServiceConnectTlsConfigurationPtrOutput added in v0.95.0 

func (i ServiceConnectTlsConfigurationArgs) ToServiceConnectTlsConfigurationPtrOutput() ServiceConnectTlsConfigurationPtrOutput

func (ServiceConnectTlsConfigurationArgs) ToServiceConnectTlsConfigurationPtrOutputWithContext added in v0.95.0 

func (i ServiceConnectTlsConfigurationArgs) ToServiceConnectTlsConfigurationPtrOutputWithContext(ctx context.Context) ServiceConnectTlsConfigurationPtrOutput

type ServiceConnectTlsConfigurationInput added in v0.95.0 

type ServiceConnectTlsConfigurationInput interface {
	pulumi.Input

	ToServiceConnectTlsConfigurationOutput() ServiceConnectTlsConfigurationOutput
	ToServiceConnectTlsConfigurationOutputWithContext(context.Context) ServiceConnectTlsConfigurationOutput
}

ServiceConnectTlsConfigurationInput is an input type that accepts ServiceConnectTlsConfigurationArgs and ServiceConnectTlsConfigurationOutput values. You can construct a concrete instance of `ServiceConnectTlsConfigurationInput` via: 

ServiceConnectTlsConfigurationArgs{...}

type ServiceConnectTlsConfigurationOutput added in v0.95.0 

type ServiceConnectTlsConfigurationOutput struct{ *pulumi.OutputState }

An object that represents the configuration for Service Connect TLS.

func (ServiceConnectTlsConfigurationOutput) ElementType added in v0.95.0 

func (ServiceConnectTlsConfigurationOutput) ElementType() reflect.Type

func (ServiceConnectTlsConfigurationOutput) IssuerCertificateAuthority added in v0.95.0 

func (o ServiceConnectTlsConfigurationOutput) IssuerCertificateAuthority() ServiceConnectTlsCertificateAuthorityOutput

The signer certificate authority.

func (ServiceConnectTlsConfigurationOutput) KmsKey added in v0.95.0 

func (o ServiceConnectTlsConfigurationOutput) KmsKey() pulumi.StringPtrOutput

The AWS Key Management Service key.

func (ServiceConnectTlsConfigurationOutput) RoleArn added in v0.95.0 

func (o ServiceConnectTlsConfigurationOutput) RoleArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the IAM role that's associated with the Service Connect TLS.

func (ServiceConnectTlsConfigurationOutput) ToServiceConnectTlsConfigurationOutput added in v0.95.0 

func (o ServiceConnectTlsConfigurationOutput) ToServiceConnectTlsConfigurationOutput() ServiceConnectTlsConfigurationOutput

func (ServiceConnectTlsConfigurationOutput) ToServiceConnectTlsConfigurationOutputWithContext added in v0.95.0 

func (o ServiceConnectTlsConfigurationOutput) ToServiceConnectTlsConfigurationOutputWithContext(ctx context.Context) ServiceConnectTlsConfigurationOutput

func (ServiceConnectTlsConfigurationOutput) ToServiceConnectTlsConfigurationPtrOutput added in v0.95.0 

func (o ServiceConnectTlsConfigurationOutput) ToServiceConnectTlsConfigurationPtrOutput() ServiceConnectTlsConfigurationPtrOutput

func (ServiceConnectTlsConfigurationOutput) ToServiceConnectTlsConfigurationPtrOutputWithContext added in v0.95.0 

func (o ServiceConnectTlsConfigurationOutput) ToServiceConnectTlsConfigurationPtrOutputWithContext(ctx context.Context) ServiceConnectTlsConfigurationPtrOutput

type ServiceConnectTlsConfigurationPtrInput added in v0.95.0 

type ServiceConnectTlsConfigurationPtrInput interface {
	pulumi.Input

	ToServiceConnectTlsConfigurationPtrOutput() ServiceConnectTlsConfigurationPtrOutput
	ToServiceConnectTlsConfigurationPtrOutputWithContext(context.Context) ServiceConnectTlsConfigurationPtrOutput
}

ServiceConnectTlsConfigurationPtrInput is an input type that accepts ServiceConnectTlsConfigurationArgs, ServiceConnectTlsConfigurationPtr and ServiceConnectTlsConfigurationPtrOutput values. You can construct a concrete instance of `ServiceConnectTlsConfigurationPtrInput` via: 

        ServiceConnectTlsConfigurationArgs{...}

or:

        nil

func ServiceConnectTlsConfigurationPtr added in v0.95.0 

func ServiceConnectTlsConfigurationPtr(v *ServiceConnectTlsConfigurationArgs) ServiceConnectTlsConfigurationPtrInput

type ServiceConnectTlsConfigurationPtrOutput added in v0.95.0 

type ServiceConnectTlsConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceConnectTlsConfigurationPtrOutput) Elem added in v0.95.0 

func (o ServiceConnectTlsConfigurationPtrOutput) Elem() ServiceConnectTlsConfigurationOutput

func (ServiceConnectTlsConfigurationPtrOutput) ElementType added in v0.95.0 

func (ServiceConnectTlsConfigurationPtrOutput) ElementType() reflect.Type

func (ServiceConnectTlsConfigurationPtrOutput) IssuerCertificateAuthority added in v0.95.0 

func (o ServiceConnectTlsConfigurationPtrOutput) IssuerCertificateAuthority() ServiceConnectTlsCertificateAuthorityPtrOutput

The signer certificate authority.

func (ServiceConnectTlsConfigurationPtrOutput) KmsKey added in v0.95.0 

func (o ServiceConnectTlsConfigurationPtrOutput) KmsKey() pulumi.StringPtrOutput

The AWS Key Management Service key.

func (ServiceConnectTlsConfigurationPtrOutput) RoleArn added in v0.95.0 

func (o ServiceConnectTlsConfigurationPtrOutput) RoleArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the IAM role that's associated with the Service Connect TLS.

func (ServiceConnectTlsConfigurationPtrOutput) ToServiceConnectTlsConfigurationPtrOutput added in v0.95.0 

func (o ServiceConnectTlsConfigurationPtrOutput) ToServiceConnectTlsConfigurationPtrOutput() ServiceConnectTlsConfigurationPtrOutput

func (ServiceConnectTlsConfigurationPtrOutput) ToServiceConnectTlsConfigurationPtrOutputWithContext added in v0.95.0 

func (o ServiceConnectTlsConfigurationPtrOutput) ToServiceConnectTlsConfigurationPtrOutputWithContext(ctx context.Context) ServiceConnectTlsConfigurationPtrOutput

type ServiceDeploymentAlarms added in v0.45.0 

type ServiceDeploymentAlarms struct {
	// One or more CloudWatch alarm names. Use a "," to separate the alarms.
	AlarmNames []string `pulumi:"alarmNames"`
	// Determines whether to use the CloudWatch alarm option in the service deployment process.
	Enable bool `pulumi:"enable"`
	// Determines whether to configure Amazon ECS to roll back the service if a service deployment fails. If rollback is used, when a service deployment fails, the service is rolled back to the last deployment that completed successfully.
	Rollback bool `pulumi:"rollback"`
}

One of the methods which provide a way for you to quickly identify when a deployment has failed, and then to optionally roll back the failure to the last working deployment. 

When the alarms are generated, Amazon ECS sets the service deployment to failed. Set the rollback parameter to have Amazon ECS to roll back your service to the last completed deployment after a failure.
You can only use the ``DeploymentAlarms`` method to detect failures when the ``DeploymentController`` is set to ``ECS`` (rolling update).
For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServiceDeploymentAlarmsArgs added in v0.45.0 

type ServiceDeploymentAlarmsArgs struct {
	// One or more CloudWatch alarm names. Use a "," to separate the alarms.
	AlarmNames pulumi.StringArrayInput `pulumi:"alarmNames"`
	// Determines whether to use the CloudWatch alarm option in the service deployment process.
	Enable pulumi.BoolInput `pulumi:"enable"`
	// Determines whether to configure Amazon ECS to roll back the service if a service deployment fails. If rollback is used, when a service deployment fails, the service is rolled back to the last deployment that completed successfully.
	Rollback pulumi.BoolInput `pulumi:"rollback"`
}

One of the methods which provide a way for you to quickly identify when a deployment has failed, and then to optionally roll back the failure to the last working deployment. 

When the alarms are generated, Amazon ECS sets the service deployment to failed. Set the rollback parameter to have Amazon ECS to roll back your service to the last completed deployment after a failure.
You can only use the ``DeploymentAlarms`` method to detect failures when the ``DeploymentController`` is set to ``ECS`` (rolling update).
For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceDeploymentAlarmsArgs) ElementType added in v0.45.0 

func (ServiceDeploymentAlarmsArgs) ElementType() reflect.Type

func (ServiceDeploymentAlarmsArgs) ToServiceDeploymentAlarmsOutput added in v0.45.0 

func (i ServiceDeploymentAlarmsArgs) ToServiceDeploymentAlarmsOutput() ServiceDeploymentAlarmsOutput

func (ServiceDeploymentAlarmsArgs) ToServiceDeploymentAlarmsOutputWithContext added in v0.45.0 

func (i ServiceDeploymentAlarmsArgs) ToServiceDeploymentAlarmsOutputWithContext(ctx context.Context) ServiceDeploymentAlarmsOutput

func (ServiceDeploymentAlarmsArgs) ToServiceDeploymentAlarmsPtrOutput added in v0.45.0 

func (i ServiceDeploymentAlarmsArgs) ToServiceDeploymentAlarmsPtrOutput() ServiceDeploymentAlarmsPtrOutput

func (ServiceDeploymentAlarmsArgs) ToServiceDeploymentAlarmsPtrOutputWithContext added in v0.45.0 

func (i ServiceDeploymentAlarmsArgs) ToServiceDeploymentAlarmsPtrOutputWithContext(ctx context.Context) ServiceDeploymentAlarmsPtrOutput

type ServiceDeploymentAlarmsInput added in v0.45.0 

type ServiceDeploymentAlarmsInput interface {
	pulumi.Input

	ToServiceDeploymentAlarmsOutput() ServiceDeploymentAlarmsOutput
	ToServiceDeploymentAlarmsOutputWithContext(context.Context) ServiceDeploymentAlarmsOutput
}

ServiceDeploymentAlarmsInput is an input type that accepts ServiceDeploymentAlarmsArgs and ServiceDeploymentAlarmsOutput values. You can construct a concrete instance of `ServiceDeploymentAlarmsInput` via: 

ServiceDeploymentAlarmsArgs{...}

type ServiceDeploymentAlarmsOutput added in v0.45.0 

type ServiceDeploymentAlarmsOutput struct{ *pulumi.OutputState }

One of the methods which provide a way for you to quickly identify when a deployment has failed, and then to optionally roll back the failure to the last working deployment. 

When the alarms are generated, Amazon ECS sets the service deployment to failed. Set the rollback parameter to have Amazon ECS to roll back your service to the last completed deployment after a failure.
You can only use the ``DeploymentAlarms`` method to detect failures when the ``DeploymentController`` is set to ``ECS`` (rolling update).
For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceDeploymentAlarmsOutput) AlarmNames added in v0.45.0 

func (o ServiceDeploymentAlarmsOutput) AlarmNames() pulumi.StringArrayOutput

One or more CloudWatch alarm names. Use a "," to separate the alarms.

func (ServiceDeploymentAlarmsOutput) ElementType added in v0.45.0 

func (ServiceDeploymentAlarmsOutput) ElementType() reflect.Type

func (ServiceDeploymentAlarmsOutput) Enable added in v0.45.0 

func (o ServiceDeploymentAlarmsOutput) Enable() pulumi.BoolOutput

Determines whether to use the CloudWatch alarm option in the service deployment process.

func (ServiceDeploymentAlarmsOutput) Rollback added in v0.45.0 

func (o ServiceDeploymentAlarmsOutput) Rollback() pulumi.BoolOutput

Determines whether to configure Amazon ECS to roll back the service if a service deployment fails. If rollback is used, when a service deployment fails, the service is rolled back to the last deployment that completed successfully.

func (ServiceDeploymentAlarmsOutput) ToServiceDeploymentAlarmsOutput added in v0.45.0 

func (o ServiceDeploymentAlarmsOutput) ToServiceDeploymentAlarmsOutput() ServiceDeploymentAlarmsOutput

func (ServiceDeploymentAlarmsOutput) ToServiceDeploymentAlarmsOutputWithContext added in v0.45.0 

func (o ServiceDeploymentAlarmsOutput) ToServiceDeploymentAlarmsOutputWithContext(ctx context.Context) ServiceDeploymentAlarmsOutput

func (ServiceDeploymentAlarmsOutput) ToServiceDeploymentAlarmsPtrOutput added in v0.45.0 

func (o ServiceDeploymentAlarmsOutput) ToServiceDeploymentAlarmsPtrOutput() ServiceDeploymentAlarmsPtrOutput

func (ServiceDeploymentAlarmsOutput) ToServiceDeploymentAlarmsPtrOutputWithContext added in v0.45.0 

func (o ServiceDeploymentAlarmsOutput) ToServiceDeploymentAlarmsPtrOutputWithContext(ctx context.Context) ServiceDeploymentAlarmsPtrOutput

type ServiceDeploymentAlarmsPtrInput added in v0.45.0 

type ServiceDeploymentAlarmsPtrInput interface {
	pulumi.Input

	ToServiceDeploymentAlarmsPtrOutput() ServiceDeploymentAlarmsPtrOutput
	ToServiceDeploymentAlarmsPtrOutputWithContext(context.Context) ServiceDeploymentAlarmsPtrOutput
}

ServiceDeploymentAlarmsPtrInput is an input type that accepts ServiceDeploymentAlarmsArgs, ServiceDeploymentAlarmsPtr and ServiceDeploymentAlarmsPtrOutput values. You can construct a concrete instance of `ServiceDeploymentAlarmsPtrInput` via: 

        ServiceDeploymentAlarmsArgs{...}

or:

        nil

func ServiceDeploymentAlarmsPtr added in v0.45.0 

func ServiceDeploymentAlarmsPtr(v *ServiceDeploymentAlarmsArgs) ServiceDeploymentAlarmsPtrInput

type ServiceDeploymentAlarmsPtrOutput added in v0.45.0 

type ServiceDeploymentAlarmsPtrOutput struct{ *pulumi.OutputState }

func (ServiceDeploymentAlarmsPtrOutput) AlarmNames added in v0.45.0 

func (o ServiceDeploymentAlarmsPtrOutput) AlarmNames() pulumi.StringArrayOutput

One or more CloudWatch alarm names. Use a "," to separate the alarms.

func (ServiceDeploymentAlarmsPtrOutput) Elem added in v0.45.0 

func (o ServiceDeploymentAlarmsPtrOutput) Elem() ServiceDeploymentAlarmsOutput

func (ServiceDeploymentAlarmsPtrOutput) ElementType added in v0.45.0 

func (ServiceDeploymentAlarmsPtrOutput) ElementType() reflect.Type

func (ServiceDeploymentAlarmsPtrOutput) Enable added in v0.45.0 

func (o ServiceDeploymentAlarmsPtrOutput) Enable() pulumi.BoolPtrOutput

Determines whether to use the CloudWatch alarm option in the service deployment process.

func (ServiceDeploymentAlarmsPtrOutput) Rollback added in v0.45.0 

func (o ServiceDeploymentAlarmsPtrOutput) Rollback() pulumi.BoolPtrOutput

Determines whether to configure Amazon ECS to roll back the service if a service deployment fails. If rollback is used, when a service deployment fails, the service is rolled back to the last deployment that completed successfully.

func (ServiceDeploymentAlarmsPtrOutput) ToServiceDeploymentAlarmsPtrOutput added in v0.45.0 

func (o ServiceDeploymentAlarmsPtrOutput) ToServiceDeploymentAlarmsPtrOutput() ServiceDeploymentAlarmsPtrOutput

func (ServiceDeploymentAlarmsPtrOutput) ToServiceDeploymentAlarmsPtrOutputWithContext added in v0.45.0 

func (o ServiceDeploymentAlarmsPtrOutput) ToServiceDeploymentAlarmsPtrOutputWithContext(ctx context.Context) ServiceDeploymentAlarmsPtrOutput

type ServiceDeploymentCircuitBreaker 

type ServiceDeploymentCircuitBreaker struct {
	// Determines whether to use the deployment circuit breaker logic for the service.
	Enable bool `pulumi:"enable"`
	// Determines whether to configure Amazon ECS to roll back the service if a service deployment fails. If rollback is on, when a service deployment fails, the service is rolled back to the last deployment that completed successfully.
	Rollback bool `pulumi:"rollback"`
}

The deployment circuit breaker can only be used for services using the rolling update (“ECS“) deployment type. 

 The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If it is turned on, a service deployment will transition to a failed state and stop launching new tasks. You can also configure Amazon ECS to roll back your service to the last completed deployment after a failure. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*.
For more information about API failure reasons, see [API failure reasons](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServiceDeploymentCircuitBreakerArgs 

type ServiceDeploymentCircuitBreakerArgs struct {
	// Determines whether to use the deployment circuit breaker logic for the service.
	Enable pulumi.BoolInput `pulumi:"enable"`
	// Determines whether to configure Amazon ECS to roll back the service if a service deployment fails. If rollback is on, when a service deployment fails, the service is rolled back to the last deployment that completed successfully.
	Rollback pulumi.BoolInput `pulumi:"rollback"`
}

The deployment circuit breaker can only be used for services using the rolling update (“ECS“) deployment type. 

 The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If it is turned on, a service deployment will transition to a failed state and stop launching new tasks. You can also configure Amazon ECS to roll back your service to the last completed deployment after a failure. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*.
For more information about API failure reasons, see [API failure reasons](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceDeploymentCircuitBreakerArgs) ElementType 

func (ServiceDeploymentCircuitBreakerArgs) ElementType() reflect.Type

func (ServiceDeploymentCircuitBreakerArgs) ToServiceDeploymentCircuitBreakerOutput 

func (i ServiceDeploymentCircuitBreakerArgs) ToServiceDeploymentCircuitBreakerOutput() ServiceDeploymentCircuitBreakerOutput

func (ServiceDeploymentCircuitBreakerArgs) ToServiceDeploymentCircuitBreakerOutputWithContext 

func (i ServiceDeploymentCircuitBreakerArgs) ToServiceDeploymentCircuitBreakerOutputWithContext(ctx context.Context) ServiceDeploymentCircuitBreakerOutput

func (ServiceDeploymentCircuitBreakerArgs) ToServiceDeploymentCircuitBreakerPtrOutput 

func (i ServiceDeploymentCircuitBreakerArgs) ToServiceDeploymentCircuitBreakerPtrOutput() ServiceDeploymentCircuitBreakerPtrOutput

func (ServiceDeploymentCircuitBreakerArgs) ToServiceDeploymentCircuitBreakerPtrOutputWithContext 

func (i ServiceDeploymentCircuitBreakerArgs) ToServiceDeploymentCircuitBreakerPtrOutputWithContext(ctx context.Context) ServiceDeploymentCircuitBreakerPtrOutput

type ServiceDeploymentCircuitBreakerInput 

type ServiceDeploymentCircuitBreakerInput interface {
	pulumi.Input

	ToServiceDeploymentCircuitBreakerOutput() ServiceDeploymentCircuitBreakerOutput
	ToServiceDeploymentCircuitBreakerOutputWithContext(context.Context) ServiceDeploymentCircuitBreakerOutput
}

ServiceDeploymentCircuitBreakerInput is an input type that accepts ServiceDeploymentCircuitBreakerArgs and ServiceDeploymentCircuitBreakerOutput values. You can construct a concrete instance of `ServiceDeploymentCircuitBreakerInput` via: 

ServiceDeploymentCircuitBreakerArgs{...}

type ServiceDeploymentCircuitBreakerOutput 

type ServiceDeploymentCircuitBreakerOutput struct{ *pulumi.OutputState }

The deployment circuit breaker can only be used for services using the rolling update (“ECS“) deployment type. 

 The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If it is turned on, a service deployment will transition to a failed state and stop launching new tasks. You can also configure Amazon ECS to roll back your service to the last completed deployment after a failure. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*.
For more information about API failure reasons, see [API failure reasons](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/api_failures_messages.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceDeploymentCircuitBreakerOutput) ElementType 

func (ServiceDeploymentCircuitBreakerOutput) ElementType() reflect.Type

func (ServiceDeploymentCircuitBreakerOutput) Enable 

func (o ServiceDeploymentCircuitBreakerOutput) Enable() pulumi.BoolOutput

Determines whether to use the deployment circuit breaker logic for the service.

func (ServiceDeploymentCircuitBreakerOutput) Rollback 

func (o ServiceDeploymentCircuitBreakerOutput) Rollback() pulumi.BoolOutput

Determines whether to configure Amazon ECS to roll back the service if a service deployment fails. If rollback is on, when a service deployment fails, the service is rolled back to the last deployment that completed successfully.

func (ServiceDeploymentCircuitBreakerOutput) ToServiceDeploymentCircuitBreakerOutput 

func (o ServiceDeploymentCircuitBreakerOutput) ToServiceDeploymentCircuitBreakerOutput() ServiceDeploymentCircuitBreakerOutput

func (ServiceDeploymentCircuitBreakerOutput) ToServiceDeploymentCircuitBreakerOutputWithContext 

func (o ServiceDeploymentCircuitBreakerOutput) ToServiceDeploymentCircuitBreakerOutputWithContext(ctx context.Context) ServiceDeploymentCircuitBreakerOutput

func (ServiceDeploymentCircuitBreakerOutput) ToServiceDeploymentCircuitBreakerPtrOutput 

func (o ServiceDeploymentCircuitBreakerOutput) ToServiceDeploymentCircuitBreakerPtrOutput() ServiceDeploymentCircuitBreakerPtrOutput

func (ServiceDeploymentCircuitBreakerOutput) ToServiceDeploymentCircuitBreakerPtrOutputWithContext 

func (o ServiceDeploymentCircuitBreakerOutput) ToServiceDeploymentCircuitBreakerPtrOutputWithContext(ctx context.Context) ServiceDeploymentCircuitBreakerPtrOutput

type ServiceDeploymentCircuitBreakerPtrInput 

type ServiceDeploymentCircuitBreakerPtrInput interface {
	pulumi.Input

	ToServiceDeploymentCircuitBreakerPtrOutput() ServiceDeploymentCircuitBreakerPtrOutput
	ToServiceDeploymentCircuitBreakerPtrOutputWithContext(context.Context) ServiceDeploymentCircuitBreakerPtrOutput
}

ServiceDeploymentCircuitBreakerPtrInput is an input type that accepts ServiceDeploymentCircuitBreakerArgs, ServiceDeploymentCircuitBreakerPtr and ServiceDeploymentCircuitBreakerPtrOutput values. You can construct a concrete instance of `ServiceDeploymentCircuitBreakerPtrInput` via: 

        ServiceDeploymentCircuitBreakerArgs{...}

or:

        nil

func ServiceDeploymentCircuitBreakerPtr 

func ServiceDeploymentCircuitBreakerPtr(v *ServiceDeploymentCircuitBreakerArgs) ServiceDeploymentCircuitBreakerPtrInput

type ServiceDeploymentCircuitBreakerPtrOutput 

type ServiceDeploymentCircuitBreakerPtrOutput struct{ *pulumi.OutputState }

func (ServiceDeploymentCircuitBreakerPtrOutput) Elem 

func (o ServiceDeploymentCircuitBreakerPtrOutput) Elem() ServiceDeploymentCircuitBreakerOutput

func (ServiceDeploymentCircuitBreakerPtrOutput) ElementType 

func (ServiceDeploymentCircuitBreakerPtrOutput) ElementType() reflect.Type

func (ServiceDeploymentCircuitBreakerPtrOutput) Enable 

func (o ServiceDeploymentCircuitBreakerPtrOutput) Enable() pulumi.BoolPtrOutput

Determines whether to use the deployment circuit breaker logic for the service.

func (ServiceDeploymentCircuitBreakerPtrOutput) Rollback 

func (o ServiceDeploymentCircuitBreakerPtrOutput) Rollback() pulumi.BoolPtrOutput

Determines whether to configure Amazon ECS to roll back the service if a service deployment fails. If rollback is on, when a service deployment fails, the service is rolled back to the last deployment that completed successfully.

func (ServiceDeploymentCircuitBreakerPtrOutput) ToServiceDeploymentCircuitBreakerPtrOutput 

func (o ServiceDeploymentCircuitBreakerPtrOutput) ToServiceDeploymentCircuitBreakerPtrOutput() ServiceDeploymentCircuitBreakerPtrOutput

func (ServiceDeploymentCircuitBreakerPtrOutput) ToServiceDeploymentCircuitBreakerPtrOutputWithContext 

func (o ServiceDeploymentCircuitBreakerPtrOutput) ToServiceDeploymentCircuitBreakerPtrOutputWithContext(ctx context.Context) ServiceDeploymentCircuitBreakerPtrOutput

type ServiceDeploymentConfiguration 

type ServiceDeploymentConfiguration struct {
	// Information about the CloudWatch alarms.
	Alarms *ServiceDeploymentAlarms `pulumi:"alarms"`
	// The deployment circuit breaker can only be used for services using the rolling update (“ECS“) deployment type.
	//   The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*
	DeploymentCircuitBreaker *ServiceDeploymentCircuitBreaker `pulumi:"deploymentCircuitBreaker"`
	// If a service is using the rolling update (“ECS“) deployment type, the “maximumPercent“ parameter represents an upper limit on the number of your service's tasks that are allowed in the “RUNNING“ or “PENDING“ state during a deployment, as a percentage of the “desiredCount“ (rounded down to the nearest integer). This parameter enables you to define the deployment batch size. For example, if your service is using the “REPLICA“ service scheduler and has a “desiredCount“ of four tasks and a “maximumPercent“ value of 200%, the scheduler may start four new tasks before stopping the four older tasks (provided that the cluster resources required to do this are available). The default “maximumPercent“ value for a service using the “REPLICA“ service scheduler is 200%.
	//  If a service is using either the blue/green (“CODE_DEPLOY“) or “EXTERNAL“ deployment types and tasks that use the EC2 launch type, the *maximum percent* value is set to the default value and is used to define the upper limit on the number of the tasks in the service that remain in the “RUNNING“ state while the container instances are in the “DRAINING“ state. If the tasks in the service use the Fargate launch type, the maximum percent value is not used, although it is returned when describing your service.
	MaximumPercent *int `pulumi:"maximumPercent"`
	// If a service is using the rolling update (“ECS“) deployment type, the “minimumHealthyPercent“ represents a lower limit on the number of your service's tasks that must remain in the “RUNNING“ state during a deployment, as a percentage of the “desiredCount“ (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a “desiredCount“ of four tasks and a “minimumHealthyPercent“ of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks.
	//  For services that *do not* use a load balancer, the following should be noted:
	//   +  A service is considered healthy if all essential containers within the tasks in the service pass their health checks.
	//   +  If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a “RUNNING“ state before the task is counted towards the minimum healthy percent total.
	//   +  If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings.
	//
	//  For services that *do* use a load balancer, the following should be noted:
	//   +  If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
	//   +  If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
	//
	//  If a service is using either the blue/green (“CODE_DEPLOY“) or “EXTERNAL“ deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the “RUNNING“ state while the container instances are in the “DRAINING“ state. If a service is using either the blue/green (“CODE_DEPLOY“) or “EXTERNAL“ deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
	MinimumHealthyPercent *int `pulumi:"minimumHealthyPercent"`
}

The “DeploymentConfiguration“ property specifies optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.

type ServiceDeploymentConfigurationArgs 

type ServiceDeploymentConfigurationArgs struct {
	// Information about the CloudWatch alarms.
	Alarms ServiceDeploymentAlarmsPtrInput `pulumi:"alarms"`
	// The deployment circuit breaker can only be used for services using the rolling update (“ECS“) deployment type.
	//   The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*
	DeploymentCircuitBreaker ServiceDeploymentCircuitBreakerPtrInput `pulumi:"deploymentCircuitBreaker"`
	// If a service is using the rolling update (“ECS“) deployment type, the “maximumPercent“ parameter represents an upper limit on the number of your service's tasks that are allowed in the “RUNNING“ or “PENDING“ state during a deployment, as a percentage of the “desiredCount“ (rounded down to the nearest integer). This parameter enables you to define the deployment batch size. For example, if your service is using the “REPLICA“ service scheduler and has a “desiredCount“ of four tasks and a “maximumPercent“ value of 200%, the scheduler may start four new tasks before stopping the four older tasks (provided that the cluster resources required to do this are available). The default “maximumPercent“ value for a service using the “REPLICA“ service scheduler is 200%.
	//  If a service is using either the blue/green (“CODE_DEPLOY“) or “EXTERNAL“ deployment types and tasks that use the EC2 launch type, the *maximum percent* value is set to the default value and is used to define the upper limit on the number of the tasks in the service that remain in the “RUNNING“ state while the container instances are in the “DRAINING“ state. If the tasks in the service use the Fargate launch type, the maximum percent value is not used, although it is returned when describing your service.
	MaximumPercent pulumi.IntPtrInput `pulumi:"maximumPercent"`
	// If a service is using the rolling update (“ECS“) deployment type, the “minimumHealthyPercent“ represents a lower limit on the number of your service's tasks that must remain in the “RUNNING“ state during a deployment, as a percentage of the “desiredCount“ (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a “desiredCount“ of four tasks and a “minimumHealthyPercent“ of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks.
	//  For services that *do not* use a load balancer, the following should be noted:
	//   +  A service is considered healthy if all essential containers within the tasks in the service pass their health checks.
	//   +  If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a “RUNNING“ state before the task is counted towards the minimum healthy percent total.
	//   +  If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings.
	//
	//  For services that *do* use a load balancer, the following should be noted:
	//   +  If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
	//   +  If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
	//
	//  If a service is using either the blue/green (“CODE_DEPLOY“) or “EXTERNAL“ deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the “RUNNING“ state while the container instances are in the “DRAINING“ state. If a service is using either the blue/green (“CODE_DEPLOY“) or “EXTERNAL“ deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
	MinimumHealthyPercent pulumi.IntPtrInput `pulumi:"minimumHealthyPercent"`
}

The “DeploymentConfiguration“ property specifies optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.

func (ServiceDeploymentConfigurationArgs) ElementType 

func (ServiceDeploymentConfigurationArgs) ElementType() reflect.Type

func (ServiceDeploymentConfigurationArgs) ToServiceDeploymentConfigurationOutput 

func (i ServiceDeploymentConfigurationArgs) ToServiceDeploymentConfigurationOutput() ServiceDeploymentConfigurationOutput

func (ServiceDeploymentConfigurationArgs) ToServiceDeploymentConfigurationOutputWithContext 

func (i ServiceDeploymentConfigurationArgs) ToServiceDeploymentConfigurationOutputWithContext(ctx context.Context) ServiceDeploymentConfigurationOutput

func (ServiceDeploymentConfigurationArgs) ToServiceDeploymentConfigurationPtrOutput 

func (i ServiceDeploymentConfigurationArgs) ToServiceDeploymentConfigurationPtrOutput() ServiceDeploymentConfigurationPtrOutput

func (ServiceDeploymentConfigurationArgs) ToServiceDeploymentConfigurationPtrOutputWithContext 

func (i ServiceDeploymentConfigurationArgs) ToServiceDeploymentConfigurationPtrOutputWithContext(ctx context.Context) ServiceDeploymentConfigurationPtrOutput

type ServiceDeploymentConfigurationInput 

type ServiceDeploymentConfigurationInput interface {
	pulumi.Input

	ToServiceDeploymentConfigurationOutput() ServiceDeploymentConfigurationOutput
	ToServiceDeploymentConfigurationOutputWithContext(context.Context) ServiceDeploymentConfigurationOutput
}

ServiceDeploymentConfigurationInput is an input type that accepts ServiceDeploymentConfigurationArgs and ServiceDeploymentConfigurationOutput values. You can construct a concrete instance of `ServiceDeploymentConfigurationInput` via: 

ServiceDeploymentConfigurationArgs{...}

type ServiceDeploymentConfigurationOutput 

type ServiceDeploymentConfigurationOutput struct{ *pulumi.OutputState }

The “DeploymentConfiguration“ property specifies optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.

func (ServiceDeploymentConfigurationOutput) Alarms added in v0.45.0 

func (o ServiceDeploymentConfigurationOutput) Alarms() ServiceDeploymentAlarmsPtrOutput

Information about the CloudWatch alarms.

func (ServiceDeploymentConfigurationOutput) DeploymentCircuitBreaker 

func (o ServiceDeploymentConfigurationOutput) DeploymentCircuitBreaker() ServiceDeploymentCircuitBreakerPtrOutput

The deployment circuit breaker can only be used for services using the rolling update (“ECS“) deployment type. 

The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*

func (ServiceDeploymentConfigurationOutput) ElementType 

func (ServiceDeploymentConfigurationOutput) ElementType() reflect.Type

func (ServiceDeploymentConfigurationOutput) MaximumPercent 

func (o ServiceDeploymentConfigurationOutput) MaximumPercent() pulumi.IntPtrOutput

If a service is using the rolling update (“ECS“) deployment type, the “maximumPercent“ parameter represents an upper limit on the number of your service's tasks that are allowed in the “RUNNING“ or “PENDING“ state during a deployment, as a percentage of the “desiredCount“ (rounded down to the nearest integer). This parameter enables you to define the deployment batch size. For example, if your service is using the “REPLICA“ service scheduler and has a “desiredCount“ of four tasks and a “maximumPercent“ value of 200%, the scheduler may start four new tasks before stopping the four older tasks (provided that the cluster resources required to do this are available). The default “maximumPercent“ value for a service using the “REPLICA“ service scheduler is 200%. 

If a service is using either the blue/green (``CODE_DEPLOY``) or ``EXTERNAL`` deployment types and tasks that use the EC2 launch type, the *maximum percent* value is set to the default value and is used to define the upper limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If the tasks in the service use the Fargate launch type, the maximum percent value is not used, although it is returned when describing your service.

func (ServiceDeploymentConfigurationOutput) MinimumHealthyPercent 

func (o ServiceDeploymentConfigurationOutput) MinimumHealthyPercent() pulumi.IntPtrOutput

If a service is using the rolling update (“ECS“) deployment type, the “minimumHealthyPercent“ represents a lower limit on the number of your service's tasks that must remain in the “RUNNING“ state during a deployment, as a percentage of the “desiredCount“ (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a “desiredCount“ of four tasks and a “minimumHealthyPercent“ of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks. 

For services that *do not* use a load balancer, the following should be noted:
 +  A service is considered healthy if all essential containers within the tasks in the service pass their health checks.
 +  If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a ``RUNNING`` state before the task is counted towards the minimum healthy percent total.
 +  If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings.

For services that *do* use a load balancer, the following should be noted:
 +  If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
 +  If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.

If a service is using either the blue/green (``CODE_DEPLOY``) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If a service is using either the blue/green (``CODE_DEPLOY``) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.

func (ServiceDeploymentConfigurationOutput) ToServiceDeploymentConfigurationOutput 

func (o ServiceDeploymentConfigurationOutput) ToServiceDeploymentConfigurationOutput() ServiceDeploymentConfigurationOutput

func (ServiceDeploymentConfigurationOutput) ToServiceDeploymentConfigurationOutputWithContext 

func (o ServiceDeploymentConfigurationOutput) ToServiceDeploymentConfigurationOutputWithContext(ctx context.Context) ServiceDeploymentConfigurationOutput

func (ServiceDeploymentConfigurationOutput) ToServiceDeploymentConfigurationPtrOutput 

func (o ServiceDeploymentConfigurationOutput) ToServiceDeploymentConfigurationPtrOutput() ServiceDeploymentConfigurationPtrOutput

func (ServiceDeploymentConfigurationOutput) ToServiceDeploymentConfigurationPtrOutputWithContext 

func (o ServiceDeploymentConfigurationOutput) ToServiceDeploymentConfigurationPtrOutputWithContext(ctx context.Context) ServiceDeploymentConfigurationPtrOutput

type ServiceDeploymentConfigurationPtrInput 

type ServiceDeploymentConfigurationPtrInput interface {
	pulumi.Input

	ToServiceDeploymentConfigurationPtrOutput() ServiceDeploymentConfigurationPtrOutput
	ToServiceDeploymentConfigurationPtrOutputWithContext(context.Context) ServiceDeploymentConfigurationPtrOutput
}

ServiceDeploymentConfigurationPtrInput is an input type that accepts ServiceDeploymentConfigurationArgs, ServiceDeploymentConfigurationPtr and ServiceDeploymentConfigurationPtrOutput values. You can construct a concrete instance of `ServiceDeploymentConfigurationPtrInput` via: 

        ServiceDeploymentConfigurationArgs{...}

or:

        nil

func ServiceDeploymentConfigurationPtr 

func ServiceDeploymentConfigurationPtr(v *ServiceDeploymentConfigurationArgs) ServiceDeploymentConfigurationPtrInput

type ServiceDeploymentConfigurationPtrOutput 

type ServiceDeploymentConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceDeploymentConfigurationPtrOutput) Alarms added in v0.45.0 

func (o ServiceDeploymentConfigurationPtrOutput) Alarms() ServiceDeploymentAlarmsPtrOutput

Information about the CloudWatch alarms.

func (ServiceDeploymentConfigurationPtrOutput) DeploymentCircuitBreaker 

func (o ServiceDeploymentConfigurationPtrOutput) DeploymentCircuitBreaker() ServiceDeploymentCircuitBreakerPtrOutput

The deployment circuit breaker can only be used for services using the rolling update (“ECS“) deployment type. 

The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*

func (ServiceDeploymentConfigurationPtrOutput) Elem 

func (o ServiceDeploymentConfigurationPtrOutput) Elem() ServiceDeploymentConfigurationOutput

func (ServiceDeploymentConfigurationPtrOutput) ElementType 

func (ServiceDeploymentConfigurationPtrOutput) ElementType() reflect.Type

func (ServiceDeploymentConfigurationPtrOutput) MaximumPercent 

func (o ServiceDeploymentConfigurationPtrOutput) MaximumPercent() pulumi.IntPtrOutput

If a service is using the rolling update (“ECS“) deployment type, the “maximumPercent“ parameter represents an upper limit on the number of your service's tasks that are allowed in the “RUNNING“ or “PENDING“ state during a deployment, as a percentage of the “desiredCount“ (rounded down to the nearest integer). This parameter enables you to define the deployment batch size. For example, if your service is using the “REPLICA“ service scheduler and has a “desiredCount“ of four tasks and a “maximumPercent“ value of 200%, the scheduler may start four new tasks before stopping the four older tasks (provided that the cluster resources required to do this are available). The default “maximumPercent“ value for a service using the “REPLICA“ service scheduler is 200%. 

If a service is using either the blue/green (``CODE_DEPLOY``) or ``EXTERNAL`` deployment types and tasks that use the EC2 launch type, the *maximum percent* value is set to the default value and is used to define the upper limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If the tasks in the service use the Fargate launch type, the maximum percent value is not used, although it is returned when describing your service.

func (ServiceDeploymentConfigurationPtrOutput) MinimumHealthyPercent 

func (o ServiceDeploymentConfigurationPtrOutput) MinimumHealthyPercent() pulumi.IntPtrOutput

If a service is using the rolling update (“ECS“) deployment type, the “minimumHealthyPercent“ represents a lower limit on the number of your service's tasks that must remain in the “RUNNING“ state during a deployment, as a percentage of the “desiredCount“ (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a “desiredCount“ of four tasks and a “minimumHealthyPercent“ of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks. 

For services that *do not* use a load balancer, the following should be noted:
 +  A service is considered healthy if all essential containers within the tasks in the service pass their health checks.
 +  If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a ``RUNNING`` state before the task is counted towards the minimum healthy percent total.
 +  If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings.

For services that *do* use a load balancer, the following should be noted:
 +  If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
 +  If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.

If a service is using either the blue/green (``CODE_DEPLOY``) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If a service is using either the blue/green (``CODE_DEPLOY``) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.

func (ServiceDeploymentConfigurationPtrOutput) ToServiceDeploymentConfigurationPtrOutput 

func (o ServiceDeploymentConfigurationPtrOutput) ToServiceDeploymentConfigurationPtrOutput() ServiceDeploymentConfigurationPtrOutput

func (ServiceDeploymentConfigurationPtrOutput) ToServiceDeploymentConfigurationPtrOutputWithContext 

func (o ServiceDeploymentConfigurationPtrOutput) ToServiceDeploymentConfigurationPtrOutputWithContext(ctx context.Context) ServiceDeploymentConfigurationPtrOutput

type ServiceDeploymentController 

type ServiceDeploymentController struct {
	// The deployment controller type to use. There are three deployment controller types available:
	//   + ECS The rolling update (ECS) deployment type involves replacing the current running version of the container with the latest version. The number of containers Amazon ECS adds or removes from the service during a rolling update is controlled by adjusting the minimum and maximum number of healthy tasks allowed during a service deployment, as specified in the DeploymentConfiguration. + CODE_DEPLOY The blue/green (CODE_DEPLOY) deployment type uses the blue/green deployment model powered by , which allows you to verify a new deployment of a service before sending production traffic to it. + EXTERNAL The external (EXTERNAL) deployment type enables you to use any third-party deployment controller for full control over the deployment process for an Amazon ECS service.
	Type *ServiceDeploymentControllerType `pulumi:"type"`
}

The deployment controller to use for the service. For more information, see [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServiceDeploymentControllerArgs 

type ServiceDeploymentControllerArgs struct {
	// The deployment controller type to use. There are three deployment controller types available:
	//   + ECS The rolling update (ECS) deployment type involves replacing the current running version of the container with the latest version. The number of containers Amazon ECS adds or removes from the service during a rolling update is controlled by adjusting the minimum and maximum number of healthy tasks allowed during a service deployment, as specified in the DeploymentConfiguration. + CODE_DEPLOY The blue/green (CODE_DEPLOY) deployment type uses the blue/green deployment model powered by , which allows you to verify a new deployment of a service before sending production traffic to it. + EXTERNAL The external (EXTERNAL) deployment type enables you to use any third-party deployment controller for full control over the deployment process for an Amazon ECS service.
	Type ServiceDeploymentControllerTypePtrInput `pulumi:"type"`
}

The deployment controller to use for the service. For more information, see [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceDeploymentControllerArgs) ElementType 

func (ServiceDeploymentControllerArgs) ElementType() reflect.Type

func (ServiceDeploymentControllerArgs) ToServiceDeploymentControllerOutput 

func (i ServiceDeploymentControllerArgs) ToServiceDeploymentControllerOutput() ServiceDeploymentControllerOutput

func (ServiceDeploymentControllerArgs) ToServiceDeploymentControllerOutputWithContext 

func (i ServiceDeploymentControllerArgs) ToServiceDeploymentControllerOutputWithContext(ctx context.Context) ServiceDeploymentControllerOutput

func (ServiceDeploymentControllerArgs) ToServiceDeploymentControllerPtrOutput 

func (i ServiceDeploymentControllerArgs) ToServiceDeploymentControllerPtrOutput() ServiceDeploymentControllerPtrOutput

func (ServiceDeploymentControllerArgs) ToServiceDeploymentControllerPtrOutputWithContext 

func (i ServiceDeploymentControllerArgs) ToServiceDeploymentControllerPtrOutputWithContext(ctx context.Context) ServiceDeploymentControllerPtrOutput

type ServiceDeploymentControllerInput 

type ServiceDeploymentControllerInput interface {
	pulumi.Input

	ToServiceDeploymentControllerOutput() ServiceDeploymentControllerOutput
	ToServiceDeploymentControllerOutputWithContext(context.Context) ServiceDeploymentControllerOutput
}

ServiceDeploymentControllerInput is an input type that accepts ServiceDeploymentControllerArgs and ServiceDeploymentControllerOutput values. You can construct a concrete instance of `ServiceDeploymentControllerInput` via: 

ServiceDeploymentControllerArgs{...}

type ServiceDeploymentControllerOutput 

type ServiceDeploymentControllerOutput struct{ *pulumi.OutputState }

The deployment controller to use for the service. For more information, see [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceDeploymentControllerOutput) ElementType 

func (ServiceDeploymentControllerOutput) ElementType() reflect.Type

func (ServiceDeploymentControllerOutput) ToServiceDeploymentControllerOutput 

func (o ServiceDeploymentControllerOutput) ToServiceDeploymentControllerOutput() ServiceDeploymentControllerOutput

func (ServiceDeploymentControllerOutput) ToServiceDeploymentControllerOutputWithContext 

func (o ServiceDeploymentControllerOutput) ToServiceDeploymentControllerOutputWithContext(ctx context.Context) ServiceDeploymentControllerOutput

func (ServiceDeploymentControllerOutput) ToServiceDeploymentControllerPtrOutput 

func (o ServiceDeploymentControllerOutput) ToServiceDeploymentControllerPtrOutput() ServiceDeploymentControllerPtrOutput

func (ServiceDeploymentControllerOutput) ToServiceDeploymentControllerPtrOutputWithContext 

func (o ServiceDeploymentControllerOutput) ToServiceDeploymentControllerPtrOutputWithContext(ctx context.Context) ServiceDeploymentControllerPtrOutput

func (ServiceDeploymentControllerOutput) Type 

func (o ServiceDeploymentControllerOutput) Type() ServiceDeploymentControllerTypePtrOutput

The deployment controller type to use. There are three deployment controller types available:

  • ECS The rolling update (ECS) deployment type involves replacing the current running version of the container with the latest version. The number of containers Amazon ECS adds or removes from the service during a rolling update is controlled by adjusting the minimum and maximum number of healthy tasks allowed during a service deployment, as specified in the DeploymentConfiguration. + CODE_DEPLOY The blue/green (CODE_DEPLOY) deployment type uses the blue/green deployment model powered by , which allows you to verify a new deployment of a service before sending production traffic to it. + EXTERNAL The external (EXTERNAL) deployment type enables you to use any third-party deployment controller for full control over the deployment process for an Amazon ECS service.

type ServiceDeploymentControllerPtrInput 

type ServiceDeploymentControllerPtrInput interface {
	pulumi.Input

	ToServiceDeploymentControllerPtrOutput() ServiceDeploymentControllerPtrOutput
	ToServiceDeploymentControllerPtrOutputWithContext(context.Context) ServiceDeploymentControllerPtrOutput
}

ServiceDeploymentControllerPtrInput is an input type that accepts ServiceDeploymentControllerArgs, ServiceDeploymentControllerPtr and ServiceDeploymentControllerPtrOutput values. You can construct a concrete instance of `ServiceDeploymentControllerPtrInput` via: 

        ServiceDeploymentControllerArgs{...}

or:

        nil

func ServiceDeploymentControllerPtr 

func ServiceDeploymentControllerPtr(v *ServiceDeploymentControllerArgs) ServiceDeploymentControllerPtrInput

type ServiceDeploymentControllerPtrOutput 

type ServiceDeploymentControllerPtrOutput struct{ *pulumi.OutputState }

func (ServiceDeploymentControllerPtrOutput) Elem 

func (o ServiceDeploymentControllerPtrOutput) Elem() ServiceDeploymentControllerOutput

func (ServiceDeploymentControllerPtrOutput) ElementType 

func (ServiceDeploymentControllerPtrOutput) ElementType() reflect.Type

func (ServiceDeploymentControllerPtrOutput) ToServiceDeploymentControllerPtrOutput 

func (o ServiceDeploymentControllerPtrOutput) ToServiceDeploymentControllerPtrOutput() ServiceDeploymentControllerPtrOutput

func (ServiceDeploymentControllerPtrOutput) ToServiceDeploymentControllerPtrOutputWithContext 

func (o ServiceDeploymentControllerPtrOutput) ToServiceDeploymentControllerPtrOutputWithContext(ctx context.Context) ServiceDeploymentControllerPtrOutput

func (ServiceDeploymentControllerPtrOutput) Type 

func (o ServiceDeploymentControllerPtrOutput) Type() ServiceDeploymentControllerTypePtrOutput

The deployment controller type to use. There are three deployment controller types available:

  • ECS The rolling update (ECS) deployment type involves replacing the current running version of the container with the latest version. The number of containers Amazon ECS adds or removes from the service during a rolling update is controlled by adjusting the minimum and maximum number of healthy tasks allowed during a service deployment, as specified in the DeploymentConfiguration. + CODE_DEPLOY The blue/green (CODE_DEPLOY) deployment type uses the blue/green deployment model powered by , which allows you to verify a new deployment of a service before sending production traffic to it. + EXTERNAL The external (EXTERNAL) deployment type enables you to use any third-party deployment controller for full control over the deployment process for an Amazon ECS service.

type ServiceDeploymentControllerType 

type ServiceDeploymentControllerType string

The deployment controller type to use. There are three deployment controller types available:

  • ECS The rolling update (ECS) deployment type involves replacing the current running version of the container with the latest version. The number of containers Amazon ECS adds or removes from the service during a rolling update is controlled by adjusting the minimum and maximum number of healthy tasks allowed during a service deployment, as specified in the DeploymentConfiguration. + CODE_DEPLOY The blue/green (CODE_DEPLOY) deployment type uses the blue/green deployment model powered by , which allows you to verify a new deployment of a service before sending production traffic to it. + EXTERNAL The external (EXTERNAL) deployment type enables you to use any third-party deployment controller for full control over the deployment process for an Amazon ECS service.

func (ServiceDeploymentControllerType) ElementType 

func (ServiceDeploymentControllerType) ElementType() reflect.Type

func (ServiceDeploymentControllerType) ToServiceDeploymentControllerTypeOutput 

func (e ServiceDeploymentControllerType) ToServiceDeploymentControllerTypeOutput() ServiceDeploymentControllerTypeOutput

func (ServiceDeploymentControllerType) ToServiceDeploymentControllerTypeOutputWithContext 

func (e ServiceDeploymentControllerType) ToServiceDeploymentControllerTypeOutputWithContext(ctx context.Context) ServiceDeploymentControllerTypeOutput

func (ServiceDeploymentControllerType) ToServiceDeploymentControllerTypePtrOutput 

func (e ServiceDeploymentControllerType) ToServiceDeploymentControllerTypePtrOutput() ServiceDeploymentControllerTypePtrOutput

func (ServiceDeploymentControllerType) ToServiceDeploymentControllerTypePtrOutputWithContext 

func (e ServiceDeploymentControllerType) ToServiceDeploymentControllerTypePtrOutputWithContext(ctx context.Context) ServiceDeploymentControllerTypePtrOutput

func (ServiceDeploymentControllerType) ToStringOutput 

func (e ServiceDeploymentControllerType) ToStringOutput() pulumi.StringOutput

func (ServiceDeploymentControllerType) ToStringOutputWithContext 

func (e ServiceDeploymentControllerType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceDeploymentControllerType) ToStringPtrOutput 

func (e ServiceDeploymentControllerType) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceDeploymentControllerType) ToStringPtrOutputWithContext 

func (e ServiceDeploymentControllerType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceDeploymentControllerTypeInput 

type ServiceDeploymentControllerTypeInput interface {
	pulumi.Input

	ToServiceDeploymentControllerTypeOutput() ServiceDeploymentControllerTypeOutput
	ToServiceDeploymentControllerTypeOutputWithContext(context.Context) ServiceDeploymentControllerTypeOutput
}

ServiceDeploymentControllerTypeInput is an input type that accepts values of the ServiceDeploymentControllerType enum A concrete instance of `ServiceDeploymentControllerTypeInput` can be one of the following: 

ServiceDeploymentControllerTypeCodeDeploy
ServiceDeploymentControllerTypeEcs
ServiceDeploymentControllerTypeExternal

type ServiceDeploymentControllerTypeOutput 

type ServiceDeploymentControllerTypeOutput struct{ *pulumi.OutputState }

func (ServiceDeploymentControllerTypeOutput) ElementType 

func (ServiceDeploymentControllerTypeOutput) ElementType() reflect.Type

func (ServiceDeploymentControllerTypeOutput) ToServiceDeploymentControllerTypeOutput 

func (o ServiceDeploymentControllerTypeOutput) ToServiceDeploymentControllerTypeOutput() ServiceDeploymentControllerTypeOutput

func (ServiceDeploymentControllerTypeOutput) ToServiceDeploymentControllerTypeOutputWithContext 

func (o ServiceDeploymentControllerTypeOutput) ToServiceDeploymentControllerTypeOutputWithContext(ctx context.Context) ServiceDeploymentControllerTypeOutput

func (ServiceDeploymentControllerTypeOutput) ToServiceDeploymentControllerTypePtrOutput 

func (o ServiceDeploymentControllerTypeOutput) ToServiceDeploymentControllerTypePtrOutput() ServiceDeploymentControllerTypePtrOutput

func (ServiceDeploymentControllerTypeOutput) ToServiceDeploymentControllerTypePtrOutputWithContext 

func (o ServiceDeploymentControllerTypeOutput) ToServiceDeploymentControllerTypePtrOutputWithContext(ctx context.Context) ServiceDeploymentControllerTypePtrOutput

func (ServiceDeploymentControllerTypeOutput) ToStringOutput 

func (o ServiceDeploymentControllerTypeOutput) ToStringOutput() pulumi.StringOutput

func (ServiceDeploymentControllerTypeOutput) ToStringOutputWithContext 

func (o ServiceDeploymentControllerTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceDeploymentControllerTypeOutput) ToStringPtrOutput 

func (o ServiceDeploymentControllerTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceDeploymentControllerTypeOutput) ToStringPtrOutputWithContext 

func (o ServiceDeploymentControllerTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceDeploymentControllerTypePtrInput 

type ServiceDeploymentControllerTypePtrInput interface {
	pulumi.Input

	ToServiceDeploymentControllerTypePtrOutput() ServiceDeploymentControllerTypePtrOutput
	ToServiceDeploymentControllerTypePtrOutputWithContext(context.Context) ServiceDeploymentControllerTypePtrOutput
}

func ServiceDeploymentControllerTypePtr 

func ServiceDeploymentControllerTypePtr(v string) ServiceDeploymentControllerTypePtrInput

type ServiceDeploymentControllerTypePtrOutput 

type ServiceDeploymentControllerTypePtrOutput struct{ *pulumi.OutputState }

func (ServiceDeploymentControllerTypePtrOutput) Elem 

func (o ServiceDeploymentControllerTypePtrOutput) Elem() ServiceDeploymentControllerTypeOutput

func (ServiceDeploymentControllerTypePtrOutput) ElementType 

func (ServiceDeploymentControllerTypePtrOutput) ElementType() reflect.Type

func (ServiceDeploymentControllerTypePtrOutput) ToServiceDeploymentControllerTypePtrOutput 

func (o ServiceDeploymentControllerTypePtrOutput) ToServiceDeploymentControllerTypePtrOutput() ServiceDeploymentControllerTypePtrOutput

func (ServiceDeploymentControllerTypePtrOutput) ToServiceDeploymentControllerTypePtrOutputWithContext 

func (o ServiceDeploymentControllerTypePtrOutput) ToServiceDeploymentControllerTypePtrOutputWithContext(ctx context.Context) ServiceDeploymentControllerTypePtrOutput

func (ServiceDeploymentControllerTypePtrOutput) ToStringPtrOutput 

func (o ServiceDeploymentControllerTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceDeploymentControllerTypePtrOutput) ToStringPtrOutputWithContext 

func (o ServiceDeploymentControllerTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceEbsTagSpecification added in v0.91.0 

type ServiceEbsTagSpecification struct {
	// Determines whether to propagate the tags from the task definition to
	// the Amazon EBS volume. Tags can only propagate to a “SERVICE“ specified in
	// “ServiceVolumeConfiguration“. If no value is specified, the tags aren't
	// propagated.
	PropagateTags *ServiceEbsTagSpecificationPropagateTags `pulumi:"propagateTags"`
	// The type of volume resource.
	ResourceType string `pulumi:"resourceType"`
	// The tags applied to this Amazon EBS volume. “AmazonECSCreated“ and “AmazonECSManaged“ are reserved tags that can't be used.
	Tags []ServiceTag `pulumi:"tags"`
}

The tag specifications of an Amazon EBS volume.

type ServiceEbsTagSpecificationArgs added in v0.91.0 

type ServiceEbsTagSpecificationArgs struct {
	// Determines whether to propagate the tags from the task definition to
	// the Amazon EBS volume. Tags can only propagate to a “SERVICE“ specified in
	// “ServiceVolumeConfiguration“. If no value is specified, the tags aren't
	// propagated.
	PropagateTags ServiceEbsTagSpecificationPropagateTagsPtrInput `pulumi:"propagateTags"`
	// The type of volume resource.
	ResourceType pulumi.StringInput `pulumi:"resourceType"`
	// The tags applied to this Amazon EBS volume. “AmazonECSCreated“ and “AmazonECSManaged“ are reserved tags that can't be used.
	Tags ServiceTagArrayInput `pulumi:"tags"`
}

The tag specifications of an Amazon EBS volume.

func (ServiceEbsTagSpecificationArgs) ElementType added in v0.91.0 

func (ServiceEbsTagSpecificationArgs) ElementType() reflect.Type

func (ServiceEbsTagSpecificationArgs) ToServiceEbsTagSpecificationOutput added in v0.91.0 

func (i ServiceEbsTagSpecificationArgs) ToServiceEbsTagSpecificationOutput() ServiceEbsTagSpecificationOutput

func (ServiceEbsTagSpecificationArgs) ToServiceEbsTagSpecificationOutputWithContext added in v0.91.0 

func (i ServiceEbsTagSpecificationArgs) ToServiceEbsTagSpecificationOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationOutput

type ServiceEbsTagSpecificationArray added in v0.91.0 

type ServiceEbsTagSpecificationArray []ServiceEbsTagSpecificationInput

func (ServiceEbsTagSpecificationArray) ElementType added in v0.91.0 

func (ServiceEbsTagSpecificationArray) ElementType() reflect.Type

func (ServiceEbsTagSpecificationArray) ToServiceEbsTagSpecificationArrayOutput added in v0.91.0 

func (i ServiceEbsTagSpecificationArray) ToServiceEbsTagSpecificationArrayOutput() ServiceEbsTagSpecificationArrayOutput

func (ServiceEbsTagSpecificationArray) ToServiceEbsTagSpecificationArrayOutputWithContext added in v0.91.0 

func (i ServiceEbsTagSpecificationArray) ToServiceEbsTagSpecificationArrayOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationArrayOutput

type ServiceEbsTagSpecificationArrayInput added in v0.91.0 

type ServiceEbsTagSpecificationArrayInput interface {
	pulumi.Input

	ToServiceEbsTagSpecificationArrayOutput() ServiceEbsTagSpecificationArrayOutput
	ToServiceEbsTagSpecificationArrayOutputWithContext(context.Context) ServiceEbsTagSpecificationArrayOutput
}

ServiceEbsTagSpecificationArrayInput is an input type that accepts ServiceEbsTagSpecificationArray and ServiceEbsTagSpecificationArrayOutput values. You can construct a concrete instance of `ServiceEbsTagSpecificationArrayInput` via: 

ServiceEbsTagSpecificationArray{ ServiceEbsTagSpecificationArgs{...} }

type ServiceEbsTagSpecificationArrayOutput added in v0.91.0 

type ServiceEbsTagSpecificationArrayOutput struct{ *pulumi.OutputState }

func (ServiceEbsTagSpecificationArrayOutput) ElementType added in v0.91.0 

func (ServiceEbsTagSpecificationArrayOutput) ElementType() reflect.Type

func (ServiceEbsTagSpecificationArrayOutput) Index added in v0.91.0 

func (o ServiceEbsTagSpecificationArrayOutput) Index(i pulumi.IntInput) ServiceEbsTagSpecificationOutput

func (ServiceEbsTagSpecificationArrayOutput) ToServiceEbsTagSpecificationArrayOutput added in v0.91.0 

func (o ServiceEbsTagSpecificationArrayOutput) ToServiceEbsTagSpecificationArrayOutput() ServiceEbsTagSpecificationArrayOutput

func (ServiceEbsTagSpecificationArrayOutput) ToServiceEbsTagSpecificationArrayOutputWithContext added in v0.91.0 

func (o ServiceEbsTagSpecificationArrayOutput) ToServiceEbsTagSpecificationArrayOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationArrayOutput

type ServiceEbsTagSpecificationInput added in v0.91.0 

type ServiceEbsTagSpecificationInput interface {
	pulumi.Input

	ToServiceEbsTagSpecificationOutput() ServiceEbsTagSpecificationOutput
	ToServiceEbsTagSpecificationOutputWithContext(context.Context) ServiceEbsTagSpecificationOutput
}

ServiceEbsTagSpecificationInput is an input type that accepts ServiceEbsTagSpecificationArgs and ServiceEbsTagSpecificationOutput values. You can construct a concrete instance of `ServiceEbsTagSpecificationInput` via: 

ServiceEbsTagSpecificationArgs{...}

type ServiceEbsTagSpecificationOutput added in v0.91.0 

type ServiceEbsTagSpecificationOutput struct{ *pulumi.OutputState }

The tag specifications of an Amazon EBS volume.

func (ServiceEbsTagSpecificationOutput) ElementType added in v0.91.0 

func (ServiceEbsTagSpecificationOutput) ElementType() reflect.Type

func (ServiceEbsTagSpecificationOutput) PropagateTags added in v0.91.0 

func (o ServiceEbsTagSpecificationOutput) PropagateTags() ServiceEbsTagSpecificationPropagateTagsPtrOutput

Determines whether to propagate the tags from the task definition to the Amazon EBS volume. Tags can only propagate to a “SERVICE“ specified in “ServiceVolumeConfiguration“. If no value is specified, the tags aren't propagated.

func (ServiceEbsTagSpecificationOutput) ResourceType added in v0.91.0 

func (o ServiceEbsTagSpecificationOutput) ResourceType() pulumi.StringOutput

The type of volume resource.

func (ServiceEbsTagSpecificationOutput) Tags added in v0.91.0 

func (o ServiceEbsTagSpecificationOutput) Tags() ServiceTagArrayOutput

The tags applied to this Amazon EBS volume. “AmazonECSCreated“ and “AmazonECSManaged“ are reserved tags that can't be used.

func (ServiceEbsTagSpecificationOutput) ToServiceEbsTagSpecificationOutput added in v0.91.0 

func (o ServiceEbsTagSpecificationOutput) ToServiceEbsTagSpecificationOutput() ServiceEbsTagSpecificationOutput

func (ServiceEbsTagSpecificationOutput) ToServiceEbsTagSpecificationOutputWithContext added in v0.91.0 

func (o ServiceEbsTagSpecificationOutput) ToServiceEbsTagSpecificationOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationOutput

type ServiceEbsTagSpecificationPropagateTags added in v0.91.0 

type ServiceEbsTagSpecificationPropagateTags string

Determines whether to propagate the tags from the task definition to the Amazon EBS volume. Tags can only propagate to a “SERVICE“ specified in “ServiceVolumeConfiguration“. If no value is specified, the tags aren't propagated.

func (ServiceEbsTagSpecificationPropagateTags) ElementType added in v0.91.0 

func (ServiceEbsTagSpecificationPropagateTags) ElementType() reflect.Type

func (ServiceEbsTagSpecificationPropagateTags) ToServiceEbsTagSpecificationPropagateTagsOutput added in v0.91.0 

func (e ServiceEbsTagSpecificationPropagateTags) ToServiceEbsTagSpecificationPropagateTagsOutput() ServiceEbsTagSpecificationPropagateTagsOutput

func (ServiceEbsTagSpecificationPropagateTags) ToServiceEbsTagSpecificationPropagateTagsOutputWithContext added in v0.91.0 

func (e ServiceEbsTagSpecificationPropagateTags) ToServiceEbsTagSpecificationPropagateTagsOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationPropagateTagsOutput

func (ServiceEbsTagSpecificationPropagateTags) ToServiceEbsTagSpecificationPropagateTagsPtrOutput added in v0.91.0 

func (e ServiceEbsTagSpecificationPropagateTags) ToServiceEbsTagSpecificationPropagateTagsPtrOutput() ServiceEbsTagSpecificationPropagateTagsPtrOutput

func (ServiceEbsTagSpecificationPropagateTags) ToServiceEbsTagSpecificationPropagateTagsPtrOutputWithContext added in v0.91.0 

func (e ServiceEbsTagSpecificationPropagateTags) ToServiceEbsTagSpecificationPropagateTagsPtrOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationPropagateTagsPtrOutput

func (ServiceEbsTagSpecificationPropagateTags) ToStringOutput added in v0.91.0 

func (e ServiceEbsTagSpecificationPropagateTags) ToStringOutput() pulumi.StringOutput

func (ServiceEbsTagSpecificationPropagateTags) ToStringOutputWithContext added in v0.91.0 

func (e ServiceEbsTagSpecificationPropagateTags) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceEbsTagSpecificationPropagateTags) ToStringPtrOutput added in v0.91.0 

func (e ServiceEbsTagSpecificationPropagateTags) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceEbsTagSpecificationPropagateTags) ToStringPtrOutputWithContext added in v0.91.0 

func (e ServiceEbsTagSpecificationPropagateTags) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceEbsTagSpecificationPropagateTagsInput added in v0.91.0 

type ServiceEbsTagSpecificationPropagateTagsInput interface {
	pulumi.Input

	ToServiceEbsTagSpecificationPropagateTagsOutput() ServiceEbsTagSpecificationPropagateTagsOutput
	ToServiceEbsTagSpecificationPropagateTagsOutputWithContext(context.Context) ServiceEbsTagSpecificationPropagateTagsOutput
}

ServiceEbsTagSpecificationPropagateTagsInput is an input type that accepts values of the ServiceEbsTagSpecificationPropagateTags enum A concrete instance of `ServiceEbsTagSpecificationPropagateTagsInput` can be one of the following: 

ServiceEbsTagSpecificationPropagateTagsService
ServiceEbsTagSpecificationPropagateTagsTaskDefinition

type ServiceEbsTagSpecificationPropagateTagsOutput added in v0.91.0 

type ServiceEbsTagSpecificationPropagateTagsOutput struct{ *pulumi.OutputState }

func (ServiceEbsTagSpecificationPropagateTagsOutput) ElementType added in v0.91.0 

func (ServiceEbsTagSpecificationPropagateTagsOutput) ElementType() reflect.Type

func (ServiceEbsTagSpecificationPropagateTagsOutput) ToServiceEbsTagSpecificationPropagateTagsOutput added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsOutput) ToServiceEbsTagSpecificationPropagateTagsOutput() ServiceEbsTagSpecificationPropagateTagsOutput

func (ServiceEbsTagSpecificationPropagateTagsOutput) ToServiceEbsTagSpecificationPropagateTagsOutputWithContext added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsOutput) ToServiceEbsTagSpecificationPropagateTagsOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationPropagateTagsOutput

func (ServiceEbsTagSpecificationPropagateTagsOutput) ToServiceEbsTagSpecificationPropagateTagsPtrOutput added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsOutput) ToServiceEbsTagSpecificationPropagateTagsPtrOutput() ServiceEbsTagSpecificationPropagateTagsPtrOutput

func (ServiceEbsTagSpecificationPropagateTagsOutput) ToServiceEbsTagSpecificationPropagateTagsPtrOutputWithContext added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsOutput) ToServiceEbsTagSpecificationPropagateTagsPtrOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationPropagateTagsPtrOutput

func (ServiceEbsTagSpecificationPropagateTagsOutput) ToStringOutput added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsOutput) ToStringOutput() pulumi.StringOutput

func (ServiceEbsTagSpecificationPropagateTagsOutput) ToStringOutputWithContext added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceEbsTagSpecificationPropagateTagsOutput) ToStringPtrOutput added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceEbsTagSpecificationPropagateTagsOutput) ToStringPtrOutputWithContext added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceEbsTagSpecificationPropagateTagsPtrInput added in v0.91.0 

type ServiceEbsTagSpecificationPropagateTagsPtrInput interface {
	pulumi.Input

	ToServiceEbsTagSpecificationPropagateTagsPtrOutput() ServiceEbsTagSpecificationPropagateTagsPtrOutput
	ToServiceEbsTagSpecificationPropagateTagsPtrOutputWithContext(context.Context) ServiceEbsTagSpecificationPropagateTagsPtrOutput
}

func ServiceEbsTagSpecificationPropagateTagsPtr added in v0.91.0 

func ServiceEbsTagSpecificationPropagateTagsPtr(v string) ServiceEbsTagSpecificationPropagateTagsPtrInput

type ServiceEbsTagSpecificationPropagateTagsPtrOutput added in v0.91.0 

type ServiceEbsTagSpecificationPropagateTagsPtrOutput struct{ *pulumi.OutputState }

func (ServiceEbsTagSpecificationPropagateTagsPtrOutput) Elem added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsPtrOutput) Elem() ServiceEbsTagSpecificationPropagateTagsOutput

func (ServiceEbsTagSpecificationPropagateTagsPtrOutput) ElementType added in v0.91.0 

func (ServiceEbsTagSpecificationPropagateTagsPtrOutput) ElementType() reflect.Type

func (ServiceEbsTagSpecificationPropagateTagsPtrOutput) ToServiceEbsTagSpecificationPropagateTagsPtrOutput added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsPtrOutput) ToServiceEbsTagSpecificationPropagateTagsPtrOutput() ServiceEbsTagSpecificationPropagateTagsPtrOutput

func (ServiceEbsTagSpecificationPropagateTagsPtrOutput) ToServiceEbsTagSpecificationPropagateTagsPtrOutputWithContext added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsPtrOutput) ToServiceEbsTagSpecificationPropagateTagsPtrOutputWithContext(ctx context.Context) ServiceEbsTagSpecificationPropagateTagsPtrOutput

func (ServiceEbsTagSpecificationPropagateTagsPtrOutput) ToStringPtrOutput added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceEbsTagSpecificationPropagateTagsPtrOutput) ToStringPtrOutputWithContext added in v0.91.0 

func (o ServiceEbsTagSpecificationPropagateTagsPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceInput 

type ServiceInput interface {
	pulumi.Input

	ToServiceOutput() ServiceOutput
	ToServiceOutputWithContext(ctx context.Context) ServiceOutput
}

type ServiceLaunchType 

type ServiceLaunchType string

The launch type on which to run your service. For more information, see [Amazon ECS Launch Types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceLaunchType) ElementType 

func (ServiceLaunchType) ElementType() reflect.Type

func (ServiceLaunchType) ToServiceLaunchTypeOutput 

func (e ServiceLaunchType) ToServiceLaunchTypeOutput() ServiceLaunchTypeOutput

func (ServiceLaunchType) ToServiceLaunchTypeOutputWithContext 

func (e ServiceLaunchType) ToServiceLaunchTypeOutputWithContext(ctx context.Context) ServiceLaunchTypeOutput

func (ServiceLaunchType) ToServiceLaunchTypePtrOutput 

func (e ServiceLaunchType) ToServiceLaunchTypePtrOutput() ServiceLaunchTypePtrOutput

func (ServiceLaunchType) ToServiceLaunchTypePtrOutputWithContext 

func (e ServiceLaunchType) ToServiceLaunchTypePtrOutputWithContext(ctx context.Context) ServiceLaunchTypePtrOutput

func (ServiceLaunchType) ToStringOutput 

func (e ServiceLaunchType) ToStringOutput() pulumi.StringOutput

func (ServiceLaunchType) ToStringOutputWithContext 

func (e ServiceLaunchType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceLaunchType) ToStringPtrOutput 

func (e ServiceLaunchType) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceLaunchType) ToStringPtrOutputWithContext 

func (e ServiceLaunchType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceLaunchTypeInput 

type ServiceLaunchTypeInput interface {
	pulumi.Input

	ToServiceLaunchTypeOutput() ServiceLaunchTypeOutput
	ToServiceLaunchTypeOutputWithContext(context.Context) ServiceLaunchTypeOutput
}

ServiceLaunchTypeInput is an input type that accepts values of the ServiceLaunchType enum A concrete instance of `ServiceLaunchTypeInput` can be one of the following: 

ServiceLaunchTypeEc2
ServiceLaunchTypeFargate
ServiceLaunchTypeExternal

type ServiceLaunchTypeOutput 

type ServiceLaunchTypeOutput struct{ *pulumi.OutputState }

func (ServiceLaunchTypeOutput) ElementType 

func (ServiceLaunchTypeOutput) ElementType() reflect.Type

func (ServiceLaunchTypeOutput) ToServiceLaunchTypeOutput 

func (o ServiceLaunchTypeOutput) ToServiceLaunchTypeOutput() ServiceLaunchTypeOutput

func (ServiceLaunchTypeOutput) ToServiceLaunchTypeOutputWithContext 

func (o ServiceLaunchTypeOutput) ToServiceLaunchTypeOutputWithContext(ctx context.Context) ServiceLaunchTypeOutput

func (ServiceLaunchTypeOutput) ToServiceLaunchTypePtrOutput 

func (o ServiceLaunchTypeOutput) ToServiceLaunchTypePtrOutput() ServiceLaunchTypePtrOutput

func (ServiceLaunchTypeOutput) ToServiceLaunchTypePtrOutputWithContext 

func (o ServiceLaunchTypeOutput) ToServiceLaunchTypePtrOutputWithContext(ctx context.Context) ServiceLaunchTypePtrOutput

func (ServiceLaunchTypeOutput) ToStringOutput 

func (o ServiceLaunchTypeOutput) ToStringOutput() pulumi.StringOutput

func (ServiceLaunchTypeOutput) ToStringOutputWithContext 

func (o ServiceLaunchTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceLaunchTypeOutput) ToStringPtrOutput 

func (o ServiceLaunchTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceLaunchTypeOutput) ToStringPtrOutputWithContext 

func (o ServiceLaunchTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceLaunchTypePtrInput 

type ServiceLaunchTypePtrInput interface {
	pulumi.Input

	ToServiceLaunchTypePtrOutput() ServiceLaunchTypePtrOutput
	ToServiceLaunchTypePtrOutputWithContext(context.Context) ServiceLaunchTypePtrOutput
}

func ServiceLaunchTypePtr 

func ServiceLaunchTypePtr(v string) ServiceLaunchTypePtrInput

type ServiceLaunchTypePtrOutput 

type ServiceLaunchTypePtrOutput struct{ *pulumi.OutputState }

func (ServiceLaunchTypePtrOutput) Elem 

func (o ServiceLaunchTypePtrOutput) Elem() ServiceLaunchTypeOutput

func (ServiceLaunchTypePtrOutput) ElementType 

func (ServiceLaunchTypePtrOutput) ElementType() reflect.Type

func (ServiceLaunchTypePtrOutput) ToServiceLaunchTypePtrOutput 

func (o ServiceLaunchTypePtrOutput) ToServiceLaunchTypePtrOutput() ServiceLaunchTypePtrOutput

func (ServiceLaunchTypePtrOutput) ToServiceLaunchTypePtrOutputWithContext 

func (o ServiceLaunchTypePtrOutput) ToServiceLaunchTypePtrOutputWithContext(ctx context.Context) ServiceLaunchTypePtrOutput

func (ServiceLaunchTypePtrOutput) ToStringPtrOutput 

func (o ServiceLaunchTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceLaunchTypePtrOutput) ToStringPtrOutputWithContext 

func (o ServiceLaunchTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceLoadBalancer 

type ServiceLoadBalancer struct {
	// The name of the container (as it appears in a container definition) to associate with the load balancer.
	//  You need to specify the container name when configuring the target group for an Amazon ECS load balancer.
	ContainerName *string `pulumi:"containerName"`
	// The port on the container to associate with the load balancer. This port must correspond to a “containerPort“ in the task definition the tasks in the service are using. For tasks that use the EC2 launch type, the container instance they're launched on must allow ingress traffic on the “hostPort“ of the port mapping.
	ContainerPort *int `pulumi:"containerPort"`
	// The name of the load balancer to associate with the Amazon ECS service or task set.
	//  If you are using an Application Load Balancer or a Network Load Balancer the load balancer name parameter should be omitted.
	LoadBalancerName *string `pulumi:"loadBalancerName"`
	// The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group or groups associated with a service or task set.
	//  A target group ARN is only specified when using an Application Load Balancer or Network Load Balancer.
	//  For services using the “ECS“ deployment controller, you can specify one or multiple target groups. For more information, see [Registering multiple target groups with a service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  For services using the “CODE_DEPLOY“ deployment controller, you're required to define two target groups for the load balancer. For more information, see [Blue/green deployment with CodeDeploy](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   If your service's task definition uses the “awsvpc“ network mode, you must choose “ip“ as the target type, not “instance“. Do this when creating your target groups because tasks that use the “awsvpc“ network mode are associated with an elastic network interface, not an Amazon EC2 instance. This network mode is required for the Fargate launch type.
	TargetGroupArn *string `pulumi:"targetGroupArn"`
}

The “LoadBalancer“ property specifies details on a load balancer that is used with a service. 

If the service is using the ``CODE_DEPLOY`` deployment controller, the service is required to use either an Application Load Balancer or Network Load Balancer. When you are creating an ACDlong deployment group, you specify two target groups (referred to as a ``targetGroupPair``). Each target group binds to a separate task set in the deployment. The load balancer can also have up to two listeners, a required listener for production traffic and an optional listener that allows you to test new revisions of the service before routing production traffic to it.
Services with tasks that use the ``awsvpc`` network mode (for example, those with the Fargate launch type) only support Application Load Balancers and Network Load Balancers. Classic Load Balancers are not supported. Also, when you create any target groups for these services, you must choose ``ip`` as the target type, not ``instance``. Tasks that use the ``awsvpc`` network mode are associated with an elastic network interface, not an Amazon EC2 instance.

type ServiceLoadBalancerArgs 

type ServiceLoadBalancerArgs struct {
	// The name of the container (as it appears in a container definition) to associate with the load balancer.
	//  You need to specify the container name when configuring the target group for an Amazon ECS load balancer.
	ContainerName pulumi.StringPtrInput `pulumi:"containerName"`
	// The port on the container to associate with the load balancer. This port must correspond to a “containerPort“ in the task definition the tasks in the service are using. For tasks that use the EC2 launch type, the container instance they're launched on must allow ingress traffic on the “hostPort“ of the port mapping.
	ContainerPort pulumi.IntPtrInput `pulumi:"containerPort"`
	// The name of the load balancer to associate with the Amazon ECS service or task set.
	//  If you are using an Application Load Balancer or a Network Load Balancer the load balancer name parameter should be omitted.
	LoadBalancerName pulumi.StringPtrInput `pulumi:"loadBalancerName"`
	// The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group or groups associated with a service or task set.
	//  A target group ARN is only specified when using an Application Load Balancer or Network Load Balancer.
	//  For services using the “ECS“ deployment controller, you can specify one or multiple target groups. For more information, see [Registering multiple target groups with a service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  For services using the “CODE_DEPLOY“ deployment controller, you're required to define two target groups for the load balancer. For more information, see [Blue/green deployment with CodeDeploy](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   If your service's task definition uses the “awsvpc“ network mode, you must choose “ip“ as the target type, not “instance“. Do this when creating your target groups because tasks that use the “awsvpc“ network mode are associated with an elastic network interface, not an Amazon EC2 instance. This network mode is required for the Fargate launch type.
	TargetGroupArn pulumi.StringPtrInput `pulumi:"targetGroupArn"`
}

The “LoadBalancer“ property specifies details on a load balancer that is used with a service. 

If the service is using the ``CODE_DEPLOY`` deployment controller, the service is required to use either an Application Load Balancer or Network Load Balancer. When you are creating an ACDlong deployment group, you specify two target groups (referred to as a ``targetGroupPair``). Each target group binds to a separate task set in the deployment. The load balancer can also have up to two listeners, a required listener for production traffic and an optional listener that allows you to test new revisions of the service before routing production traffic to it.
Services with tasks that use the ``awsvpc`` network mode (for example, those with the Fargate launch type) only support Application Load Balancers and Network Load Balancers. Classic Load Balancers are not supported. Also, when you create any target groups for these services, you must choose ``ip`` as the target type, not ``instance``. Tasks that use the ``awsvpc`` network mode are associated with an elastic network interface, not an Amazon EC2 instance.

func (ServiceLoadBalancerArgs) ElementType 

func (ServiceLoadBalancerArgs) ElementType() reflect.Type

func (ServiceLoadBalancerArgs) ToServiceLoadBalancerOutput 

func (i ServiceLoadBalancerArgs) ToServiceLoadBalancerOutput() ServiceLoadBalancerOutput

func (ServiceLoadBalancerArgs) ToServiceLoadBalancerOutputWithContext 

func (i ServiceLoadBalancerArgs) ToServiceLoadBalancerOutputWithContext(ctx context.Context) ServiceLoadBalancerOutput

type ServiceLoadBalancerArray 

type ServiceLoadBalancerArray []ServiceLoadBalancerInput

func (ServiceLoadBalancerArray) ElementType 

func (ServiceLoadBalancerArray) ElementType() reflect.Type

func (ServiceLoadBalancerArray) ToServiceLoadBalancerArrayOutput 

func (i ServiceLoadBalancerArray) ToServiceLoadBalancerArrayOutput() ServiceLoadBalancerArrayOutput

func (ServiceLoadBalancerArray) ToServiceLoadBalancerArrayOutputWithContext 

func (i ServiceLoadBalancerArray) ToServiceLoadBalancerArrayOutputWithContext(ctx context.Context) ServiceLoadBalancerArrayOutput

type ServiceLoadBalancerArrayInput 

type ServiceLoadBalancerArrayInput interface {
	pulumi.Input

	ToServiceLoadBalancerArrayOutput() ServiceLoadBalancerArrayOutput
	ToServiceLoadBalancerArrayOutputWithContext(context.Context) ServiceLoadBalancerArrayOutput
}

ServiceLoadBalancerArrayInput is an input type that accepts ServiceLoadBalancerArray and ServiceLoadBalancerArrayOutput values. You can construct a concrete instance of `ServiceLoadBalancerArrayInput` via: 

ServiceLoadBalancerArray{ ServiceLoadBalancerArgs{...} }

type ServiceLoadBalancerArrayOutput 

type ServiceLoadBalancerArrayOutput struct{ *pulumi.OutputState }

func (ServiceLoadBalancerArrayOutput) ElementType 

func (ServiceLoadBalancerArrayOutput) ElementType() reflect.Type

func (ServiceLoadBalancerArrayOutput) Index 

func (o ServiceLoadBalancerArrayOutput) Index(i pulumi.IntInput) ServiceLoadBalancerOutput

func (ServiceLoadBalancerArrayOutput) ToServiceLoadBalancerArrayOutput 

func (o ServiceLoadBalancerArrayOutput) ToServiceLoadBalancerArrayOutput() ServiceLoadBalancerArrayOutput

func (ServiceLoadBalancerArrayOutput) ToServiceLoadBalancerArrayOutputWithContext 

func (o ServiceLoadBalancerArrayOutput) ToServiceLoadBalancerArrayOutputWithContext(ctx context.Context) ServiceLoadBalancerArrayOutput

type ServiceLoadBalancerInput 

type ServiceLoadBalancerInput interface {
	pulumi.Input

	ToServiceLoadBalancerOutput() ServiceLoadBalancerOutput
	ToServiceLoadBalancerOutputWithContext(context.Context) ServiceLoadBalancerOutput
}

ServiceLoadBalancerInput is an input type that accepts ServiceLoadBalancerArgs and ServiceLoadBalancerOutput values. You can construct a concrete instance of `ServiceLoadBalancerInput` via: 

ServiceLoadBalancerArgs{...}

type ServiceLoadBalancerOutput 

type ServiceLoadBalancerOutput struct{ *pulumi.OutputState }

The “LoadBalancer“ property specifies details on a load balancer that is used with a service. 

If the service is using the ``CODE_DEPLOY`` deployment controller, the service is required to use either an Application Load Balancer or Network Load Balancer. When you are creating an ACDlong deployment group, you specify two target groups (referred to as a ``targetGroupPair``). Each target group binds to a separate task set in the deployment. The load balancer can also have up to two listeners, a required listener for production traffic and an optional listener that allows you to test new revisions of the service before routing production traffic to it.
Services with tasks that use the ``awsvpc`` network mode (for example, those with the Fargate launch type) only support Application Load Balancers and Network Load Balancers. Classic Load Balancers are not supported. Also, when you create any target groups for these services, you must choose ``ip`` as the target type, not ``instance``. Tasks that use the ``awsvpc`` network mode are associated with an elastic network interface, not an Amazon EC2 instance.

func (ServiceLoadBalancerOutput) ContainerName 

func (o ServiceLoadBalancerOutput) ContainerName() pulumi.StringPtrOutput

The name of the container (as it appears in a container definition) to associate with the load balancer. 

You need to specify the container name when configuring the target group for an Amazon ECS load balancer.

func (ServiceLoadBalancerOutput) ContainerPort 

func (o ServiceLoadBalancerOutput) ContainerPort() pulumi.IntPtrOutput

The port on the container to associate with the load balancer. This port must correspond to a “containerPort“ in the task definition the tasks in the service are using. For tasks that use the EC2 launch type, the container instance they're launched on must allow ingress traffic on the “hostPort“ of the port mapping.

func (ServiceLoadBalancerOutput) ElementType 

func (ServiceLoadBalancerOutput) ElementType() reflect.Type

func (ServiceLoadBalancerOutput) LoadBalancerName 

func (o ServiceLoadBalancerOutput) LoadBalancerName() pulumi.StringPtrOutput

The name of the load balancer to associate with the Amazon ECS service or task set. 

If you are using an Application Load Balancer or a Network Load Balancer the load balancer name parameter should be omitted.

func (ServiceLoadBalancerOutput) TargetGroupArn 

func (o ServiceLoadBalancerOutput) TargetGroupArn() pulumi.StringPtrOutput

The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group or groups associated with a service or task set. 

A target group ARN is only specified when using an Application Load Balancer or Network Load Balancer.
For services using the ``ECS`` deployment controller, you can specify one or multiple target groups. For more information, see [Registering multiple target groups with a service](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html) in the *Amazon Elastic Container Service Developer Guide*.
For services using the ``CODE_DEPLOY`` deployment controller, you're required to define two target groups for the load balancer. For more information, see [Blue/green deployment with CodeDeploy](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html) in the *Amazon Elastic Container Service Developer Guide*.
 If your service's task definition uses the ``awsvpc`` network mode, you must choose ``ip`` as the target type, not ``instance``. Do this when creating your target groups because tasks that use the ``awsvpc`` network mode are associated with an elastic network interface, not an Amazon EC2 instance. This network mode is required for the Fargate launch type.

func (ServiceLoadBalancerOutput) ToServiceLoadBalancerOutput 

func (o ServiceLoadBalancerOutput) ToServiceLoadBalancerOutput() ServiceLoadBalancerOutput

func (ServiceLoadBalancerOutput) ToServiceLoadBalancerOutputWithContext 

func (o ServiceLoadBalancerOutput) ToServiceLoadBalancerOutputWithContext(ctx context.Context) ServiceLoadBalancerOutput

type ServiceLogConfiguration added in v0.41.0 

type ServiceLogConfiguration struct {
	// The log driver to use for the container.
	//  For tasks on FARGATElong, the supported log drivers are “awslogs“, “splunk“, and “awsfirelens“.
	//  For tasks hosted on Amazon EC2 instances, the supported log drivers are “awslogs“, “fluentd“, “gelf“, “json-file“, “journald“, “logentries“,“syslog“, “splunk“, and “awsfirelens“.
	//  For more information about using the “awslogs“ log driver, see [Using the awslogs log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  For more information about using the “awsfirelens“ log driver, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.
	LogDriver *string `pulumi:"logDriver"`
	// The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	Options map[string]string `pulumi:"options"`
	// The secrets to pass to the log configuration. For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.
	SecretOptions []ServiceSecret `pulumi:"secretOptions"`
}

The log configuration for the container. This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/run/). 

By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition. For more information about the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
Understand the following when specifying a log configuration for your containers.
 +  Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.
     For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
     For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
 +  This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.
 +  For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the ``ECS_AVAILABLE_LOGGING_DRIVERS`` environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS container agent configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
 +  For tasks that are on FARGATElong, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.

type ServiceLogConfigurationArgs added in v0.41.0 

type ServiceLogConfigurationArgs struct {
	// The log driver to use for the container.
	//  For tasks on FARGATElong, the supported log drivers are “awslogs“, “splunk“, and “awsfirelens“.
	//  For tasks hosted on Amazon EC2 instances, the supported log drivers are “awslogs“, “fluentd“, “gelf“, “json-file“, “journald“, “logentries“,“syslog“, “splunk“, and “awsfirelens“.
	//  For more information about using the “awslogs“ log driver, see [Using the awslogs log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  For more information about using the “awsfirelens“ log driver, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.
	LogDriver pulumi.StringPtrInput `pulumi:"logDriver"`
	// The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	Options pulumi.StringMapInput `pulumi:"options"`
	// The secrets to pass to the log configuration. For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.
	SecretOptions ServiceSecretArrayInput `pulumi:"secretOptions"`
}

The log configuration for the container. This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/run/). 

By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition. For more information about the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
Understand the following when specifying a log configuration for your containers.
 +  Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.
     For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
     For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
 +  This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.
 +  For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the ``ECS_AVAILABLE_LOGGING_DRIVERS`` environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS container agent configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
 +  For tasks that are on FARGATElong, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.

func (ServiceLogConfigurationArgs) ElementType added in v0.41.0 

func (ServiceLogConfigurationArgs) ElementType() reflect.Type

func (ServiceLogConfigurationArgs) ToServiceLogConfigurationOutput added in v0.41.0 

func (i ServiceLogConfigurationArgs) ToServiceLogConfigurationOutput() ServiceLogConfigurationOutput

func (ServiceLogConfigurationArgs) ToServiceLogConfigurationOutputWithContext added in v0.41.0 

func (i ServiceLogConfigurationArgs) ToServiceLogConfigurationOutputWithContext(ctx context.Context) ServiceLogConfigurationOutput

func (ServiceLogConfigurationArgs) ToServiceLogConfigurationPtrOutput added in v0.41.0 

func (i ServiceLogConfigurationArgs) ToServiceLogConfigurationPtrOutput() ServiceLogConfigurationPtrOutput

func (ServiceLogConfigurationArgs) ToServiceLogConfigurationPtrOutputWithContext added in v0.41.0 

func (i ServiceLogConfigurationArgs) ToServiceLogConfigurationPtrOutputWithContext(ctx context.Context) ServiceLogConfigurationPtrOutput

type ServiceLogConfigurationInput added in v0.41.0 

type ServiceLogConfigurationInput interface {
	pulumi.Input

	ToServiceLogConfigurationOutput() ServiceLogConfigurationOutput
	ToServiceLogConfigurationOutputWithContext(context.Context) ServiceLogConfigurationOutput
}

ServiceLogConfigurationInput is an input type that accepts ServiceLogConfigurationArgs and ServiceLogConfigurationOutput values. You can construct a concrete instance of `ServiceLogConfigurationInput` via: 

ServiceLogConfigurationArgs{...}

type ServiceLogConfigurationOutput added in v0.41.0 

type ServiceLogConfigurationOutput struct{ *pulumi.OutputState }

The log configuration for the container. This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/run/). 

By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition. For more information about the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
Understand the following when specifying a log configuration for your containers.
 +  Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.
     For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
     For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
 +  This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.
 +  For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the ``ECS_AVAILABLE_LOGGING_DRIVERS`` environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS container agent configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
 +  For tasks that are on FARGATElong, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.

func (ServiceLogConfigurationOutput) ElementType added in v0.41.0 

func (ServiceLogConfigurationOutput) ElementType() reflect.Type

func (ServiceLogConfigurationOutput) LogDriver added in v0.41.0 

func (o ServiceLogConfigurationOutput) LogDriver() pulumi.StringPtrOutput

The log driver to use for the container. 

For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
For more information about using the ``awslogs`` log driver, see [Using the awslogs log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.
For more information about using the ``awsfirelens`` log driver, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
 If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.

func (ServiceLogConfigurationOutput) Options added in v0.41.0 

func (o ServiceLogConfigurationOutput) Options() pulumi.StringMapOutput

The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“

func (ServiceLogConfigurationOutput) SecretOptions added in v0.41.0 

func (o ServiceLogConfigurationOutput) SecretOptions() ServiceSecretArrayOutput

The secrets to pass to the log configuration. For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceLogConfigurationOutput) ToServiceLogConfigurationOutput added in v0.41.0 

func (o ServiceLogConfigurationOutput) ToServiceLogConfigurationOutput() ServiceLogConfigurationOutput

func (ServiceLogConfigurationOutput) ToServiceLogConfigurationOutputWithContext added in v0.41.0 

func (o ServiceLogConfigurationOutput) ToServiceLogConfigurationOutputWithContext(ctx context.Context) ServiceLogConfigurationOutput

func (ServiceLogConfigurationOutput) ToServiceLogConfigurationPtrOutput added in v0.41.0 

func (o ServiceLogConfigurationOutput) ToServiceLogConfigurationPtrOutput() ServiceLogConfigurationPtrOutput

func (ServiceLogConfigurationOutput) ToServiceLogConfigurationPtrOutputWithContext added in v0.41.0 

func (o ServiceLogConfigurationOutput) ToServiceLogConfigurationPtrOutputWithContext(ctx context.Context) ServiceLogConfigurationPtrOutput

type ServiceLogConfigurationPtrInput added in v0.41.0 

type ServiceLogConfigurationPtrInput interface {
	pulumi.Input

	ToServiceLogConfigurationPtrOutput() ServiceLogConfigurationPtrOutput
	ToServiceLogConfigurationPtrOutputWithContext(context.Context) ServiceLogConfigurationPtrOutput
}

ServiceLogConfigurationPtrInput is an input type that accepts ServiceLogConfigurationArgs, ServiceLogConfigurationPtr and ServiceLogConfigurationPtrOutput values. You can construct a concrete instance of `ServiceLogConfigurationPtrInput` via: 

        ServiceLogConfigurationArgs{...}

or:

        nil

func ServiceLogConfigurationPtr added in v0.41.0 

func ServiceLogConfigurationPtr(v *ServiceLogConfigurationArgs) ServiceLogConfigurationPtrInput

type ServiceLogConfigurationPtrOutput added in v0.41.0 

type ServiceLogConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceLogConfigurationPtrOutput) Elem added in v0.41.0 

func (o ServiceLogConfigurationPtrOutput) Elem() ServiceLogConfigurationOutput

func (ServiceLogConfigurationPtrOutput) ElementType added in v0.41.0 

func (ServiceLogConfigurationPtrOutput) ElementType() reflect.Type

func (ServiceLogConfigurationPtrOutput) LogDriver added in v0.41.0 

func (o ServiceLogConfigurationPtrOutput) LogDriver() pulumi.StringPtrOutput

The log driver to use for the container. 

For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
For more information about using the ``awslogs`` log driver, see [Using the awslogs log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.
For more information about using the ``awsfirelens`` log driver, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
 If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.

func (ServiceLogConfigurationPtrOutput) Options added in v0.41.0 

func (o ServiceLogConfigurationPtrOutput) Options() pulumi.StringMapOutput

The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“

func (ServiceLogConfigurationPtrOutput) SecretOptions added in v0.41.0 

func (o ServiceLogConfigurationPtrOutput) SecretOptions() ServiceSecretArrayOutput

The secrets to pass to the log configuration. For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceLogConfigurationPtrOutput) ToServiceLogConfigurationPtrOutput added in v0.41.0 

func (o ServiceLogConfigurationPtrOutput) ToServiceLogConfigurationPtrOutput() ServiceLogConfigurationPtrOutput

func (ServiceLogConfigurationPtrOutput) ToServiceLogConfigurationPtrOutputWithContext added in v0.41.0 

func (o ServiceLogConfigurationPtrOutput) ToServiceLogConfigurationPtrOutputWithContext(ctx context.Context) ServiceLogConfigurationPtrOutput

type ServiceManagedEbsVolumeConfiguration added in v0.91.0 

type ServiceManagedEbsVolumeConfiguration struct {
	// Indicates whether the volume should be encrypted. If no value is specified, encryption is turned on by default. This parameter maps 1:1 with the “Encrypted“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	Encrypted *bool `pulumi:"encrypted"`
	// The Linux filesystem type for the volume. For volumes created from a snapshot, you must specify the same filesystem type that the volume was using when the snapshot was created. If there is a filesystem type mismatch, the task will fail to start.
	//  The available filesystem types are
	//  “ext3“, “ext4“, and “xfs“. If no value is specified, the “xfs“ filesystem type is used by default.
	FilesystemType *string `pulumi:"filesystemType"`
	// The number of I/O operations per second (IOPS). For “gp3“, “io1“, and “io2“ volumes, this represents the number of IOPS that are provisioned for the volume. For “gp2“ volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting.
	//  The following are the supported values for each volume type.
	//   +   “gp3“: 3,000 - 16,000 IOPS
	//   +   “io1“: 100 - 64,000 IOPS
	//   +   “io2“: 100 - 256,000 IOPS
	//
	//  This parameter is required for “io1“ and “io2“ volume types. The default for “gp3“ volumes is “3,000 IOPS“. This parameter is not supported for “st1“, “sc1“, or “standard“ volume types.
	//  This parameter maps 1:1 with the “Iops“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	Iops *int `pulumi:"iops"`
	// The Amazon Resource Name (ARN) identifier of the AWS Key Management Service key to use for Amazon EBS encryption. When encryption is turned on and no AWS Key Management Service key is specified, the default AWS managed key for Amazon EBS volumes is used. This parameter maps 1:1 with the “KmsKeyId“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	//    AWS authenticates the AWS Key Management Service key asynchronously. Therefore, if you specify an ID, alias, or ARN that is invalid, the action can appear to complete, but eventually fails.
	KmsKeyId *string `pulumi:"kmsKeyId"`
	// The ARN of the IAM role to associate with this volume. This is the Amazon ECS infrastructure IAM role that is used to manage your AWS infrastructure. We recommend using the Amazon ECS-managed “AmazonECSInfrastructureRolePolicyForVolumes“ IAM policy with this role. For more information, see [Amazon ECS infrastructure IAM role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html) in the *Amazon ECS Developer Guide*.
	RoleArn string `pulumi:"roleArn"`
	// The size of the volume in GiB. You must specify either a volume size or a snapshot ID. If you specify a snapshot ID, the snapshot size is used for the volume size by default. You can optionally specify a volume size greater than or equal to the snapshot size. This parameter maps 1:1 with the “Size“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	//  The following are the supported volume size values for each volume type.
	//   +   “gp2“ and “gp3“: 1-16,384
	//   +   “io1“ and “io2“: 4-16,384
	//   +   “st1“ and “sc1“: 125-16,384
	//   +   “standard“: 1-1,024
	SizeInGiB *int `pulumi:"sizeInGiB"`
	// The snapshot that Amazon ECS uses to create the volume. You must specify either a snapshot ID or a volume size. This parameter maps 1:1 with the “SnapshotId“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	SnapshotId *string `pulumi:"snapshotId"`
	// The tags to apply to the volume. Amazon ECS applies service-managed tags by default. This parameter maps 1:1 with the “TagSpecifications.N“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	TagSpecifications []ServiceEbsTagSpecification `pulumi:"tagSpecifications"`
	// The throughput to provision for a volume, in MiB/s, with a maximum of 1,000 MiB/s. This parameter maps 1:1 with the “Throughput“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	//   This parameter is only supported for the “gp3“ volume type.
	Throughput *int `pulumi:"throughput"`
	// The volume type. This parameter maps 1:1 with the “VolumeType“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. For more information, see [Amazon EBS volume types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html) in the *Amazon EC2 User Guide*.
	//  The following are the supported volume types.
	//   +  General Purpose SSD: “gp2“|“gp3“
	//   +  Provisioned IOPS SSD: “io1“|“io2“
	//   +  Throughput Optimized HDD: “st1“
	//   +  Cold HDD: “sc1“
	//   +  Magnetic: “standard“
	//        The magnetic volume type is not supported on Fargate.
	VolumeType *string `pulumi:"volumeType"`
}

The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf. These settings are used to create each Amazon EBS volume, with one volume created for each task in the service. 

Many of these parameters map 1:1 with the Amazon EBS ``CreateVolume`` API request parameters.

type ServiceManagedEbsVolumeConfigurationArgs added in v0.91.0 

type ServiceManagedEbsVolumeConfigurationArgs struct {
	// Indicates whether the volume should be encrypted. If no value is specified, encryption is turned on by default. This parameter maps 1:1 with the “Encrypted“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	Encrypted pulumi.BoolPtrInput `pulumi:"encrypted"`
	// The Linux filesystem type for the volume. For volumes created from a snapshot, you must specify the same filesystem type that the volume was using when the snapshot was created. If there is a filesystem type mismatch, the task will fail to start.
	//  The available filesystem types are
	//  “ext3“, “ext4“, and “xfs“. If no value is specified, the “xfs“ filesystem type is used by default.
	FilesystemType pulumi.StringPtrInput `pulumi:"filesystemType"`
	// The number of I/O operations per second (IOPS). For “gp3“, “io1“, and “io2“ volumes, this represents the number of IOPS that are provisioned for the volume. For “gp2“ volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting.
	//  The following are the supported values for each volume type.
	//   +   “gp3“: 3,000 - 16,000 IOPS
	//   +   “io1“: 100 - 64,000 IOPS
	//   +   “io2“: 100 - 256,000 IOPS
	//
	//  This parameter is required for “io1“ and “io2“ volume types. The default for “gp3“ volumes is “3,000 IOPS“. This parameter is not supported for “st1“, “sc1“, or “standard“ volume types.
	//  This parameter maps 1:1 with the “Iops“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	Iops pulumi.IntPtrInput `pulumi:"iops"`
	// The Amazon Resource Name (ARN) identifier of the AWS Key Management Service key to use for Amazon EBS encryption. When encryption is turned on and no AWS Key Management Service key is specified, the default AWS managed key for Amazon EBS volumes is used. This parameter maps 1:1 with the “KmsKeyId“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	//    AWS authenticates the AWS Key Management Service key asynchronously. Therefore, if you specify an ID, alias, or ARN that is invalid, the action can appear to complete, but eventually fails.
	KmsKeyId pulumi.StringPtrInput `pulumi:"kmsKeyId"`
	// The ARN of the IAM role to associate with this volume. This is the Amazon ECS infrastructure IAM role that is used to manage your AWS infrastructure. We recommend using the Amazon ECS-managed “AmazonECSInfrastructureRolePolicyForVolumes“ IAM policy with this role. For more information, see [Amazon ECS infrastructure IAM role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html) in the *Amazon ECS Developer Guide*.
	RoleArn pulumi.StringInput `pulumi:"roleArn"`
	// The size of the volume in GiB. You must specify either a volume size or a snapshot ID. If you specify a snapshot ID, the snapshot size is used for the volume size by default. You can optionally specify a volume size greater than or equal to the snapshot size. This parameter maps 1:1 with the “Size“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	//  The following are the supported volume size values for each volume type.
	//   +   “gp2“ and “gp3“: 1-16,384
	//   +   “io1“ and “io2“: 4-16,384
	//   +   “st1“ and “sc1“: 125-16,384
	//   +   “standard“: 1-1,024
	SizeInGiB pulumi.IntPtrInput `pulumi:"sizeInGiB"`
	// The snapshot that Amazon ECS uses to create the volume. You must specify either a snapshot ID or a volume size. This parameter maps 1:1 with the “SnapshotId“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	SnapshotId pulumi.StringPtrInput `pulumi:"snapshotId"`
	// The tags to apply to the volume. Amazon ECS applies service-managed tags by default. This parameter maps 1:1 with the “TagSpecifications.N“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	TagSpecifications ServiceEbsTagSpecificationArrayInput `pulumi:"tagSpecifications"`
	// The throughput to provision for a volume, in MiB/s, with a maximum of 1,000 MiB/s. This parameter maps 1:1 with the “Throughput“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.
	//   This parameter is only supported for the “gp3“ volume type.
	Throughput pulumi.IntPtrInput `pulumi:"throughput"`
	// The volume type. This parameter maps 1:1 with the “VolumeType“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. For more information, see [Amazon EBS volume types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html) in the *Amazon EC2 User Guide*.
	//  The following are the supported volume types.
	//   +  General Purpose SSD: “gp2“|“gp3“
	//   +  Provisioned IOPS SSD: “io1“|“io2“
	//   +  Throughput Optimized HDD: “st1“
	//   +  Cold HDD: “sc1“
	//   +  Magnetic: “standard“
	//        The magnetic volume type is not supported on Fargate.
	VolumeType pulumi.StringPtrInput `pulumi:"volumeType"`
}

The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf. These settings are used to create each Amazon EBS volume, with one volume created for each task in the service. 

Many of these parameters map 1:1 with the Amazon EBS ``CreateVolume`` API request parameters.

func (ServiceManagedEbsVolumeConfigurationArgs) ElementType added in v0.91.0 

func (ServiceManagedEbsVolumeConfigurationArgs) ElementType() reflect.Type

func (ServiceManagedEbsVolumeConfigurationArgs) ToServiceManagedEbsVolumeConfigurationOutput added in v0.91.0 

func (i ServiceManagedEbsVolumeConfigurationArgs) ToServiceManagedEbsVolumeConfigurationOutput() ServiceManagedEbsVolumeConfigurationOutput

func (ServiceManagedEbsVolumeConfigurationArgs) ToServiceManagedEbsVolumeConfigurationOutputWithContext added in v0.91.0 

func (i ServiceManagedEbsVolumeConfigurationArgs) ToServiceManagedEbsVolumeConfigurationOutputWithContext(ctx context.Context) ServiceManagedEbsVolumeConfigurationOutput

func (ServiceManagedEbsVolumeConfigurationArgs) ToServiceManagedEbsVolumeConfigurationPtrOutput added in v0.91.0 

func (i ServiceManagedEbsVolumeConfigurationArgs) ToServiceManagedEbsVolumeConfigurationPtrOutput() ServiceManagedEbsVolumeConfigurationPtrOutput

func (ServiceManagedEbsVolumeConfigurationArgs) ToServiceManagedEbsVolumeConfigurationPtrOutputWithContext added in v0.91.0 

func (i ServiceManagedEbsVolumeConfigurationArgs) ToServiceManagedEbsVolumeConfigurationPtrOutputWithContext(ctx context.Context) ServiceManagedEbsVolumeConfigurationPtrOutput

type ServiceManagedEbsVolumeConfigurationInput added in v0.91.0 

type ServiceManagedEbsVolumeConfigurationInput interface {
	pulumi.Input

	ToServiceManagedEbsVolumeConfigurationOutput() ServiceManagedEbsVolumeConfigurationOutput
	ToServiceManagedEbsVolumeConfigurationOutputWithContext(context.Context) ServiceManagedEbsVolumeConfigurationOutput
}

ServiceManagedEbsVolumeConfigurationInput is an input type that accepts ServiceManagedEbsVolumeConfigurationArgs and ServiceManagedEbsVolumeConfigurationOutput values. You can construct a concrete instance of `ServiceManagedEbsVolumeConfigurationInput` via: 

ServiceManagedEbsVolumeConfigurationArgs{...}

type ServiceManagedEbsVolumeConfigurationOutput added in v0.91.0 

type ServiceManagedEbsVolumeConfigurationOutput struct{ *pulumi.OutputState }

The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf. These settings are used to create each Amazon EBS volume, with one volume created for each task in the service. 

Many of these parameters map 1:1 with the Amazon EBS ``CreateVolume`` API request parameters.

func (ServiceManagedEbsVolumeConfigurationOutput) ElementType added in v0.91.0 

func (ServiceManagedEbsVolumeConfigurationOutput) ElementType() reflect.Type

func (ServiceManagedEbsVolumeConfigurationOutput) Encrypted added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) Encrypted() pulumi.BoolPtrOutput

Indicates whether the volume should be encrypted. If no value is specified, encryption is turned on by default. This parameter maps 1:1 with the “Encrypted“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.

func (ServiceManagedEbsVolumeConfigurationOutput) FilesystemType added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) FilesystemType() pulumi.StringPtrOutput

The Linux filesystem type for the volume. For volumes created from a snapshot, you must specify the same filesystem type that the volume was using when the snapshot was created. If there is a filesystem type mismatch, the task will fail to start. 

The available filesystem types are
``ext3``, ``ext4``, and ``xfs``. If no value is specified, the ``xfs`` filesystem type is used by default.

func (ServiceManagedEbsVolumeConfigurationOutput) Iops added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) Iops() pulumi.IntPtrOutput

The number of I/O operations per second (IOPS). For “gp3“, “io1“, and “io2“ volumes, this represents the number of IOPS that are provisioned for the volume. For “gp2“ volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting. 

The following are the supported values for each volume type.
 +   ``gp3``: 3,000 - 16,000 IOPS
 +   ``io1``: 100 - 64,000 IOPS
 +   ``io2``: 100 - 256,000 IOPS

This parameter is required for ``io1`` and ``io2`` volume types. The default for ``gp3`` volumes is ``3,000 IOPS``. This parameter is not supported for ``st1``, ``sc1``, or ``standard`` volume types.
This parameter maps 1:1 with the ``Iops`` parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.

func (ServiceManagedEbsVolumeConfigurationOutput) KmsKeyId added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) KmsKeyId() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) identifier of the AWS Key Management Service key to use for Amazon EBS encryption. When encryption is turned on and no AWS Key Management Service key is specified, the default AWS managed key for Amazon EBS volumes is used. This parameter maps 1:1 with the “KmsKeyId“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. 

AWS authenticates the AWS Key Management Service key asynchronously. Therefore, if you specify an ID, alias, or ARN that is invalid, the action can appear to complete, but eventually fails.

func (ServiceManagedEbsVolumeConfigurationOutput) RoleArn added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) RoleArn() pulumi.StringOutput

The ARN of the IAM role to associate with this volume. This is the Amazon ECS infrastructure IAM role that is used to manage your AWS infrastructure. We recommend using the Amazon ECS-managed “AmazonECSInfrastructureRolePolicyForVolumes“ IAM policy with this role. For more information, see [Amazon ECS infrastructure IAM role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html) in the *Amazon ECS Developer Guide*.

func (ServiceManagedEbsVolumeConfigurationOutput) SizeInGiB added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) SizeInGiB() pulumi.IntPtrOutput

The size of the volume in GiB. You must specify either a volume size or a snapshot ID. If you specify a snapshot ID, the snapshot size is used for the volume size by default. You can optionally specify a volume size greater than or equal to the snapshot size. This parameter maps 1:1 with the “Size“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. 

The following are the supported volume size values for each volume type.
 +   ``gp2`` and ``gp3``: 1-16,384
 +   ``io1`` and ``io2``: 4-16,384
 +   ``st1`` and ``sc1``: 125-16,384
 +   ``standard``: 1-1,024

func (ServiceManagedEbsVolumeConfigurationOutput) SnapshotId added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) SnapshotId() pulumi.StringPtrOutput

The snapshot that Amazon ECS uses to create the volume. You must specify either a snapshot ID or a volume size. This parameter maps 1:1 with the “SnapshotId“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.

func (ServiceManagedEbsVolumeConfigurationOutput) TagSpecifications added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) TagSpecifications() ServiceEbsTagSpecificationArrayOutput

The tags to apply to the volume. Amazon ECS applies service-managed tags by default. This parameter maps 1:1 with the “TagSpecifications.N“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.

func (ServiceManagedEbsVolumeConfigurationOutput) Throughput added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) Throughput() pulumi.IntPtrOutput

The throughput to provision for a volume, in MiB/s, with a maximum of 1,000 MiB/s. This parameter maps 1:1 with the “Throughput“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. 

This parameter is only supported for the ``gp3`` volume type.

func (ServiceManagedEbsVolumeConfigurationOutput) ToServiceManagedEbsVolumeConfigurationOutput added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) ToServiceManagedEbsVolumeConfigurationOutput() ServiceManagedEbsVolumeConfigurationOutput

func (ServiceManagedEbsVolumeConfigurationOutput) ToServiceManagedEbsVolumeConfigurationOutputWithContext added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) ToServiceManagedEbsVolumeConfigurationOutputWithContext(ctx context.Context) ServiceManagedEbsVolumeConfigurationOutput

func (ServiceManagedEbsVolumeConfigurationOutput) ToServiceManagedEbsVolumeConfigurationPtrOutput added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) ToServiceManagedEbsVolumeConfigurationPtrOutput() ServiceManagedEbsVolumeConfigurationPtrOutput

func (ServiceManagedEbsVolumeConfigurationOutput) ToServiceManagedEbsVolumeConfigurationPtrOutputWithContext added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) ToServiceManagedEbsVolumeConfigurationPtrOutputWithContext(ctx context.Context) ServiceManagedEbsVolumeConfigurationPtrOutput

func (ServiceManagedEbsVolumeConfigurationOutput) VolumeType added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationOutput) VolumeType() pulumi.StringPtrOutput

The volume type. This parameter maps 1:1 with the “VolumeType“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. For more information, see [Amazon EBS volume types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html) in the *Amazon EC2 User Guide*. 

The following are the supported volume types.
 +  General Purpose SSD: ``gp2``|``gp3``
 +  Provisioned IOPS SSD: ``io1``|``io2``
 +  Throughput Optimized HDD: ``st1``
 +  Cold HDD: ``sc1``
 +  Magnetic: ``standard``
      The magnetic volume type is not supported on Fargate.

type ServiceManagedEbsVolumeConfigurationPtrInput added in v0.91.0 

type ServiceManagedEbsVolumeConfigurationPtrInput interface {
	pulumi.Input

	ToServiceManagedEbsVolumeConfigurationPtrOutput() ServiceManagedEbsVolumeConfigurationPtrOutput
	ToServiceManagedEbsVolumeConfigurationPtrOutputWithContext(context.Context) ServiceManagedEbsVolumeConfigurationPtrOutput
}

ServiceManagedEbsVolumeConfigurationPtrInput is an input type that accepts ServiceManagedEbsVolumeConfigurationArgs, ServiceManagedEbsVolumeConfigurationPtr and ServiceManagedEbsVolumeConfigurationPtrOutput values. You can construct a concrete instance of `ServiceManagedEbsVolumeConfigurationPtrInput` via: 

        ServiceManagedEbsVolumeConfigurationArgs{...}

or:

        nil

func ServiceManagedEbsVolumeConfigurationPtr added in v0.91.0 

func ServiceManagedEbsVolumeConfigurationPtr(v *ServiceManagedEbsVolumeConfigurationArgs) ServiceManagedEbsVolumeConfigurationPtrInput

type ServiceManagedEbsVolumeConfigurationPtrOutput added in v0.91.0 

type ServiceManagedEbsVolumeConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceManagedEbsVolumeConfigurationPtrOutput) Elem added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) Elem() ServiceManagedEbsVolumeConfigurationOutput

func (ServiceManagedEbsVolumeConfigurationPtrOutput) ElementType added in v0.91.0 

func (ServiceManagedEbsVolumeConfigurationPtrOutput) ElementType() reflect.Type

func (ServiceManagedEbsVolumeConfigurationPtrOutput) Encrypted added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) Encrypted() pulumi.BoolPtrOutput

Indicates whether the volume should be encrypted. If no value is specified, encryption is turned on by default. This parameter maps 1:1 with the “Encrypted“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.

func (ServiceManagedEbsVolumeConfigurationPtrOutput) FilesystemType added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) FilesystemType() pulumi.StringPtrOutput

The Linux filesystem type for the volume. For volumes created from a snapshot, you must specify the same filesystem type that the volume was using when the snapshot was created. If there is a filesystem type mismatch, the task will fail to start. 

The available filesystem types are
``ext3``, ``ext4``, and ``xfs``. If no value is specified, the ``xfs`` filesystem type is used by default.

func (ServiceManagedEbsVolumeConfigurationPtrOutput) Iops added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) Iops() pulumi.IntPtrOutput

The number of I/O operations per second (IOPS). For “gp3“, “io1“, and “io2“ volumes, this represents the number of IOPS that are provisioned for the volume. For “gp2“ volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting. 

The following are the supported values for each volume type.
 +   ``gp3``: 3,000 - 16,000 IOPS
 +   ``io1``: 100 - 64,000 IOPS
 +   ``io2``: 100 - 256,000 IOPS

This parameter is required for ``io1`` and ``io2`` volume types. The default for ``gp3`` volumes is ``3,000 IOPS``. This parameter is not supported for ``st1``, ``sc1``, or ``standard`` volume types.
This parameter maps 1:1 with the ``Iops`` parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.

func (ServiceManagedEbsVolumeConfigurationPtrOutput) KmsKeyId added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) KmsKeyId() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) identifier of the AWS Key Management Service key to use for Amazon EBS encryption. When encryption is turned on and no AWS Key Management Service key is specified, the default AWS managed key for Amazon EBS volumes is used. This parameter maps 1:1 with the “KmsKeyId“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. 

AWS authenticates the AWS Key Management Service key asynchronously. Therefore, if you specify an ID, alias, or ARN that is invalid, the action can appear to complete, but eventually fails.

func (ServiceManagedEbsVolumeConfigurationPtrOutput) RoleArn added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) RoleArn() pulumi.StringPtrOutput

The ARN of the IAM role to associate with this volume. This is the Amazon ECS infrastructure IAM role that is used to manage your AWS infrastructure. We recommend using the Amazon ECS-managed “AmazonECSInfrastructureRolePolicyForVolumes“ IAM policy with this role. For more information, see [Amazon ECS infrastructure IAM role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html) in the *Amazon ECS Developer Guide*.

func (ServiceManagedEbsVolumeConfigurationPtrOutput) SizeInGiB added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) SizeInGiB() pulumi.IntPtrOutput

The size of the volume in GiB. You must specify either a volume size or a snapshot ID. If you specify a snapshot ID, the snapshot size is used for the volume size by default. You can optionally specify a volume size greater than or equal to the snapshot size. This parameter maps 1:1 with the “Size“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. 

The following are the supported volume size values for each volume type.
 +   ``gp2`` and ``gp3``: 1-16,384
 +   ``io1`` and ``io2``: 4-16,384
 +   ``st1`` and ``sc1``: 125-16,384
 +   ``standard``: 1-1,024

func (ServiceManagedEbsVolumeConfigurationPtrOutput) SnapshotId added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) SnapshotId() pulumi.StringPtrOutput

The snapshot that Amazon ECS uses to create the volume. You must specify either a snapshot ID or a volume size. This parameter maps 1:1 with the “SnapshotId“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.

func (ServiceManagedEbsVolumeConfigurationPtrOutput) TagSpecifications added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) TagSpecifications() ServiceEbsTagSpecificationArrayOutput

The tags to apply to the volume. Amazon ECS applies service-managed tags by default. This parameter maps 1:1 with the “TagSpecifications.N“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*.

func (ServiceManagedEbsVolumeConfigurationPtrOutput) Throughput added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) Throughput() pulumi.IntPtrOutput

The throughput to provision for a volume, in MiB/s, with a maximum of 1,000 MiB/s. This parameter maps 1:1 with the “Throughput“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. 

This parameter is only supported for the ``gp3`` volume type.

func (ServiceManagedEbsVolumeConfigurationPtrOutput) ToServiceManagedEbsVolumeConfigurationPtrOutput added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) ToServiceManagedEbsVolumeConfigurationPtrOutput() ServiceManagedEbsVolumeConfigurationPtrOutput

func (ServiceManagedEbsVolumeConfigurationPtrOutput) ToServiceManagedEbsVolumeConfigurationPtrOutputWithContext added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) ToServiceManagedEbsVolumeConfigurationPtrOutputWithContext(ctx context.Context) ServiceManagedEbsVolumeConfigurationPtrOutput

func (ServiceManagedEbsVolumeConfigurationPtrOutput) VolumeType added in v0.91.0 

func (o ServiceManagedEbsVolumeConfigurationPtrOutput) VolumeType() pulumi.StringPtrOutput

The volume type. This parameter maps 1:1 with the “VolumeType“ parameter of the [CreateVolume API](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateVolume.html) in the *Amazon EC2 API Reference*. For more information, see [Amazon EBS volume types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html) in the *Amazon EC2 User Guide*. 

The following are the supported volume types.
 +  General Purpose SSD: ``gp2``|``gp3``
 +  Provisioned IOPS SSD: ``io1``|``io2``
 +  Throughput Optimized HDD: ``st1``
 +  Cold HDD: ``sc1``
 +  Magnetic: ``standard``
      The magnetic volume type is not supported on Fargate.

type ServiceNetworkConfiguration 

type ServiceNetworkConfiguration struct {
	// The VPC subnets and security groups that are associated with a task.
	//   All specified subnets and security groups must be from the same VPC.
	AwsvpcConfiguration *ServiceAwsVpcConfiguration `pulumi:"awsvpcConfiguration"`
}

The “NetworkConfiguration“ property specifies an object representing the network configuration for a task or service.

type ServiceNetworkConfigurationArgs 

type ServiceNetworkConfigurationArgs struct {
	// The VPC subnets and security groups that are associated with a task.
	//   All specified subnets and security groups must be from the same VPC.
	AwsvpcConfiguration ServiceAwsVpcConfigurationPtrInput `pulumi:"awsvpcConfiguration"`
}

The “NetworkConfiguration“ property specifies an object representing the network configuration for a task or service.

func (ServiceNetworkConfigurationArgs) ElementType 

func (ServiceNetworkConfigurationArgs) ElementType() reflect.Type

func (ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationOutput 

func (i ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationOutput() ServiceNetworkConfigurationOutput

func (ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationOutputWithContext 

func (i ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationOutputWithContext(ctx context.Context) ServiceNetworkConfigurationOutput

func (ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationPtrOutput 

func (i ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput

func (ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationPtrOutputWithContext 

func (i ServiceNetworkConfigurationArgs) ToServiceNetworkConfigurationPtrOutputWithContext(ctx context.Context) ServiceNetworkConfigurationPtrOutput

type ServiceNetworkConfigurationInput 

type ServiceNetworkConfigurationInput interface {
	pulumi.Input

	ToServiceNetworkConfigurationOutput() ServiceNetworkConfigurationOutput
	ToServiceNetworkConfigurationOutputWithContext(context.Context) ServiceNetworkConfigurationOutput
}

ServiceNetworkConfigurationInput is an input type that accepts ServiceNetworkConfigurationArgs and ServiceNetworkConfigurationOutput values. You can construct a concrete instance of `ServiceNetworkConfigurationInput` via: 

ServiceNetworkConfigurationArgs{...}

type ServiceNetworkConfigurationOutput 

type ServiceNetworkConfigurationOutput struct{ *pulumi.OutputState }

The “NetworkConfiguration“ property specifies an object representing the network configuration for a task or service.

func (ServiceNetworkConfigurationOutput) AwsvpcConfiguration 

func (o ServiceNetworkConfigurationOutput) AwsvpcConfiguration() ServiceAwsVpcConfigurationPtrOutput

The VPC subnets and security groups that are associated with a task. 

All specified subnets and security groups must be from the same VPC.

func (ServiceNetworkConfigurationOutput) ElementType 

func (ServiceNetworkConfigurationOutput) ElementType() reflect.Type

func (ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationOutput 

func (o ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationOutput() ServiceNetworkConfigurationOutput

func (ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationOutputWithContext 

func (o ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationOutputWithContext(ctx context.Context) ServiceNetworkConfigurationOutput

func (ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationPtrOutput 

func (o ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput

func (ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationPtrOutputWithContext 

func (o ServiceNetworkConfigurationOutput) ToServiceNetworkConfigurationPtrOutputWithContext(ctx context.Context) ServiceNetworkConfigurationPtrOutput

type ServiceNetworkConfigurationPtrInput 

type ServiceNetworkConfigurationPtrInput interface {
	pulumi.Input

	ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput
	ToServiceNetworkConfigurationPtrOutputWithContext(context.Context) ServiceNetworkConfigurationPtrOutput
}

ServiceNetworkConfigurationPtrInput is an input type that accepts ServiceNetworkConfigurationArgs, ServiceNetworkConfigurationPtr and ServiceNetworkConfigurationPtrOutput values. You can construct a concrete instance of `ServiceNetworkConfigurationPtrInput` via: 

        ServiceNetworkConfigurationArgs{...}

or:

        nil

func ServiceNetworkConfigurationPtr 

func ServiceNetworkConfigurationPtr(v *ServiceNetworkConfigurationArgs) ServiceNetworkConfigurationPtrInput

type ServiceNetworkConfigurationPtrOutput 

type ServiceNetworkConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceNetworkConfigurationPtrOutput) AwsvpcConfiguration 

func (o ServiceNetworkConfigurationPtrOutput) AwsvpcConfiguration() ServiceAwsVpcConfigurationPtrOutput

The VPC subnets and security groups that are associated with a task. 

All specified subnets and security groups must be from the same VPC.

func (ServiceNetworkConfigurationPtrOutput) Elem 

func (o ServiceNetworkConfigurationPtrOutput) Elem() ServiceNetworkConfigurationOutput

func (ServiceNetworkConfigurationPtrOutput) ElementType 

func (ServiceNetworkConfigurationPtrOutput) ElementType() reflect.Type

func (ServiceNetworkConfigurationPtrOutput) ToServiceNetworkConfigurationPtrOutput 

func (o ServiceNetworkConfigurationPtrOutput) ToServiceNetworkConfigurationPtrOutput() ServiceNetworkConfigurationPtrOutput

func (ServiceNetworkConfigurationPtrOutput) ToServiceNetworkConfigurationPtrOutputWithContext 

func (o ServiceNetworkConfigurationPtrOutput) ToServiceNetworkConfigurationPtrOutputWithContext(ctx context.Context) ServiceNetworkConfigurationPtrOutput

type ServiceOutput 

type ServiceOutput struct{ *pulumi.OutputState }

func (ServiceOutput) CapacityProviderStrategy added in v0.17.0 

func (o ServiceOutput) CapacityProviderStrategy() ServiceCapacityProviderStrategyItemArrayOutput

The capacity provider strategy to use for the service. 

If a ``capacityProviderStrategy`` is specified, the ``launchType`` parameter must be omitted. If no ``capacityProviderStrategy`` or ``launchType`` is specified, the ``defaultCapacityProviderStrategy`` for the cluster is used.
A capacity provider strategy may contain a maximum of 6 capacity providers.

func (ServiceOutput) Cluster added in v0.17.0 

func (o ServiceOutput) Cluster() pulumi.StringPtrOutput

The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.

func (ServiceOutput) DeploymentConfiguration added in v0.17.0 

func (o ServiceOutput) DeploymentConfiguration() ServiceDeploymentConfigurationPtrOutput

Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.

func (ServiceOutput) DeploymentController added in v0.17.0 

func (o ServiceOutput) DeploymentController() ServiceDeploymentControllerPtrOutput

The deployment controller to use for the service. If no deployment controller is specified, the default value of “ECS“ is used.

func (ServiceOutput) DesiredCount added in v0.17.0 

func (o ServiceOutput) DesiredCount() pulumi.IntPtrOutput

The number of instantiations of the specified task definition to place and keep running in your service. 

For new services, if a desired count is not specified, a default value of ``1`` is used. When using the ``DAEMON`` scheduling strategy, the desired count is not required.
For existing services, if a desired count is not specified, it is omitted from the operation.

func (ServiceOutput) ElementType 

func (ServiceOutput) ElementType() reflect.Type

func (ServiceOutput) EnableEcsManagedTags added in v0.72.0 

func (o ServiceOutput) EnableEcsManagedTags() pulumi.BoolPtrOutput

Specifies whether to turn on Amazon ECS managed tags for the tasks within the service. For more information, see [Tagging your Amazon ECS resources](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html) in the *Amazon Elastic Container Service Developer Guide*. 

When you use Amazon ECS managed tags, you need to set the ``propagateTags`` request parameter.

func (ServiceOutput) EnableExecuteCommand added in v0.17.0 

func (o ServiceOutput) EnableExecuteCommand() pulumi.BoolPtrOutput

Determines whether the execute command functionality is turned on for the service. If “true“, the execute command functionality is turned on for all containers in tasks as part of the service.

func (ServiceOutput) HealthCheckGracePeriodSeconds added in v0.17.0 

func (o ServiceOutput) HealthCheckGracePeriodSeconds() pulumi.IntPtrOutput

The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. This is only used when your service is configured to use a load balancer. If your service has a load balancer defined and you don't specify a health check grace period value, the default value of “0“ is used. 

If you do not use an Elastic Load Balancing, we recommend that you use the ``startPeriod`` in the task definition health check parameters. For more information, see [Health check](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html).
If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.

func (ServiceOutput) LaunchType added in v0.17.0 

func (o ServiceOutput) LaunchType() ServiceLaunchTypePtrOutput

The launch type on which to run your service. For more information, see [Amazon ECS Launch Types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceOutput) LoadBalancers added in v0.17.0 

func (o ServiceOutput) LoadBalancers() ServiceLoadBalancerArrayOutput

A list of load balancer objects to associate with the service. If you specify the “Role“ property, “LoadBalancers“ must be specified as well. For information about the number of load balancers that you can specify per service, see [Service Load Balancing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceOutput) Name added in v0.17.0 

func (o ServiceOutput) Name() pulumi.StringOutput

func (ServiceOutput) NetworkConfiguration added in v0.17.0 

func (o ServiceOutput) NetworkConfiguration() ServiceNetworkConfigurationPtrOutput

The network configuration for the service. This parameter is required for task definitions that use the “awsvpc“ network mode to receive their own elastic network interface, and it is not supported for other network modes. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceOutput) PlacementConstraints added in v0.17.0 

func (o ServiceOutput) PlacementConstraints() ServicePlacementConstraintArrayOutput

An array of placement constraint objects to use for tasks in your service. You can specify a maximum of 10 constraints for each task. This limit includes constraints in the task definition and those specified at runtime.

func (ServiceOutput) PlacementStrategies added in v0.17.0 

func (o ServiceOutput) PlacementStrategies() ServicePlacementStrategyArrayOutput

The placement strategy objects to use for tasks in your service. You can specify a maximum of 5 strategy rules for each service.

func (ServiceOutput) PlatformVersion added in v0.17.0 

func (o ServiceOutput) PlatformVersion() pulumi.StringPtrOutput

The platform version that your tasks in the service are running on. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the “LATEST“ platform version is used. For more information, see [platform versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceOutput) PropagateTags added in v0.17.0 

func (o ServiceOutput) PropagateTags() ServicePropagateTagsPtrOutput

Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the task during task creation. To add tags to a task after task creation, use the [TagResource](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html) API action. 

The default is ``NONE``.

func (ServiceOutput) Role added in v0.17.0 

func (o ServiceOutput) Role() pulumi.StringPtrOutput

The name or full Amazon Resource Name (ARN) of the IAM role that allows Amazon ECS to make calls to your load balancer on your behalf. This parameter is only permitted if you are using a load balancer with your service and your task definition doesn't use the “awsvpc“ network mode. If you specify the “role“ parameter, you must also specify a load balancer object with the “loadBalancers“ parameter. 

If your account has already created the Amazon ECS service-linked role, that role is used for your service unless you specify a role here. The service-linked role is required if your task definition uses the ``awsvpc`` network mode or if the service is configured to use service discovery, an external deployment controller, multiple target groups, or Elastic Inference accelerators in which case you don't specify a role here. For more information, see [Using service-linked roles for Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using-service-linked-roles.html) in the *Amazon Elastic Container Service Developer Guide*.
If your specified role has a path other than ``/``, then you must either specify the full role ARN (this is recommended) or prefix the role name with the path. For example, if a role with the name ``bar`` has a path of ``/foo/`` then you would specify ``/foo/bar`` as the role name. For more information, see [Friendly names and paths](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names) in the *IAM User Guide*.

func (ServiceOutput) SchedulingStrategy added in v0.17.0 

func (o ServiceOutput) SchedulingStrategy() ServiceSchedulingStrategyPtrOutput

The scheduling strategy to use for the service. For more information, see [Services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html). 

There are two service scheduler strategies available:
 +   ``REPLICA``-The replica scheduling strategy places and maintains the desired number of tasks across your cluster. By default, the service scheduler spreads tasks across Availability Zones. You can use task placement strategies and constraints to customize task placement decisions. This scheduler strategy is required if the service uses the ``CODE_DEPLOY`` or ``EXTERNAL`` deployment controller types.
 +   ``DAEMON``-The daemon scheduling strategy deploys exactly one task on each active container instance that meets all of the task placement constraints that you specify in your cluster. The service scheduler also evaluates the task placement constraints for running tasks and will stop tasks that don't meet the placement constraints. When you're using this strategy, you don't need to specify a desired number of tasks, a task placement strategy, or use Service Auto Scaling policies.
       Tasks using the Fargate launch type or the ``CODE_DEPLOY`` or ``EXTERNAL`` deployment controller types don't support the ``DAEMON`` scheduling strategy.

func (ServiceOutput) ServiceArn added in v0.17.0 

func (o ServiceOutput) ServiceArn() pulumi.StringOutput

func (ServiceOutput) ServiceConnectConfiguration added in v0.41.0 

func (o ServiceOutput) ServiceConnectConfiguration() ServiceConnectConfigurationPtrOutput

The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace. 

Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceOutput) ServiceName added in v0.17.0 

func (o ServiceOutput) ServiceName() pulumi.StringPtrOutput

The name of your service. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. Service names must be unique within a cluster, but you can have similarly named services in multiple clusters within a Region or across multiple Regions. 

The stack update fails if you change any properties that require replacement and the ``ServiceName`` is configured. This is because AWS CloudFormation creates the replacement service first, but each ``ServiceName`` must be unique in the cluster.

func (ServiceOutput) ServiceRegistries added in v0.17.0 

func (o ServiceOutput) ServiceRegistries() ServiceRegistryArrayOutput

The details of the service discovery registry to associate with this service. For more information, see [Service discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). 

Each service may be associated with one service registry. Multiple service registries for each service isn't supported.

func (ServiceOutput) Tags added in v0.17.0 

func (o ServiceOutput) Tags() aws.TagArrayOutput

The metadata that you apply to the service to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. When a service is deleted, the tags are deleted as well. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

func (ServiceOutput) TaskDefinition added in v0.17.0 

func (o ServiceOutput) TaskDefinition() pulumi.StringPtrOutput

The “family“ and “revision“ (“family:revision“) or full ARN of the task definition to run in your service. If a “revision“ isn't specified, the latest “ACTIVE“ revision is used. 

A task definition must be specified if the service uses either the ``ECS`` or ``CODE_DEPLOY`` deployment controllers.
For more information about deployment types, see [Amazon ECS deployment types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html).

func (ServiceOutput) ToServiceOutput 

func (o ServiceOutput) ToServiceOutput() ServiceOutput

func (ServiceOutput) ToServiceOutputWithContext 

func (o ServiceOutput) ToServiceOutputWithContext(ctx context.Context) ServiceOutput

func (ServiceOutput) VolumeConfigurations added in v0.91.0 

func (o ServiceOutput) VolumeConfigurations() ServiceVolumeConfigurationArrayOutput

The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.

type ServicePlacementConstraint 

type ServicePlacementConstraint struct {
	// A cluster query language expression to apply to the constraint. The expression can have a maximum length of 2000 characters. You can't specify an expression if the constraint type is “distinctInstance“. For more information, see [Cluster query language](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html) in the *Amazon Elastic Container Service Developer Guide*.
	Expression *string `pulumi:"expression"`
	// The type of constraint. Use “distinctInstance“ to ensure that each task in a particular group is running on a different container instance. Use “memberOf“ to restrict the selection to a group of valid candidates.
	Type ServicePlacementConstraintType `pulumi:"type"`
}

The “PlacementConstraint“ property specifies an object representing a constraint on task placement in the task definition. For more information, see [Task Placement Constraints](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServicePlacementConstraintArgs 

type ServicePlacementConstraintArgs struct {
	// A cluster query language expression to apply to the constraint. The expression can have a maximum length of 2000 characters. You can't specify an expression if the constraint type is “distinctInstance“. For more information, see [Cluster query language](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html) in the *Amazon Elastic Container Service Developer Guide*.
	Expression pulumi.StringPtrInput `pulumi:"expression"`
	// The type of constraint. Use “distinctInstance“ to ensure that each task in a particular group is running on a different container instance. Use “memberOf“ to restrict the selection to a group of valid candidates.
	Type ServicePlacementConstraintTypeInput `pulumi:"type"`
}

The “PlacementConstraint“ property specifies an object representing a constraint on task placement in the task definition. For more information, see [Task Placement Constraints](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServicePlacementConstraintArgs) ElementType 

func (ServicePlacementConstraintArgs) ElementType() reflect.Type

func (ServicePlacementConstraintArgs) ToServicePlacementConstraintOutput 

func (i ServicePlacementConstraintArgs) ToServicePlacementConstraintOutput() ServicePlacementConstraintOutput

func (ServicePlacementConstraintArgs) ToServicePlacementConstraintOutputWithContext 

func (i ServicePlacementConstraintArgs) ToServicePlacementConstraintOutputWithContext(ctx context.Context) ServicePlacementConstraintOutput

type ServicePlacementConstraintArray 

type ServicePlacementConstraintArray []ServicePlacementConstraintInput

func (ServicePlacementConstraintArray) ElementType 

func (ServicePlacementConstraintArray) ElementType() reflect.Type

func (ServicePlacementConstraintArray) ToServicePlacementConstraintArrayOutput 

func (i ServicePlacementConstraintArray) ToServicePlacementConstraintArrayOutput() ServicePlacementConstraintArrayOutput

func (ServicePlacementConstraintArray) ToServicePlacementConstraintArrayOutputWithContext 

func (i ServicePlacementConstraintArray) ToServicePlacementConstraintArrayOutputWithContext(ctx context.Context) ServicePlacementConstraintArrayOutput

type ServicePlacementConstraintArrayInput 

type ServicePlacementConstraintArrayInput interface {
	pulumi.Input

	ToServicePlacementConstraintArrayOutput() ServicePlacementConstraintArrayOutput
	ToServicePlacementConstraintArrayOutputWithContext(context.Context) ServicePlacementConstraintArrayOutput
}

ServicePlacementConstraintArrayInput is an input type that accepts ServicePlacementConstraintArray and ServicePlacementConstraintArrayOutput values. You can construct a concrete instance of `ServicePlacementConstraintArrayInput` via: 

ServicePlacementConstraintArray{ ServicePlacementConstraintArgs{...} }

type ServicePlacementConstraintArrayOutput 

type ServicePlacementConstraintArrayOutput struct{ *pulumi.OutputState }

func (ServicePlacementConstraintArrayOutput) ElementType 

func (ServicePlacementConstraintArrayOutput) ElementType() reflect.Type

func (ServicePlacementConstraintArrayOutput) Index 

func (o ServicePlacementConstraintArrayOutput) Index(i pulumi.IntInput) ServicePlacementConstraintOutput

func (ServicePlacementConstraintArrayOutput) ToServicePlacementConstraintArrayOutput 

func (o ServicePlacementConstraintArrayOutput) ToServicePlacementConstraintArrayOutput() ServicePlacementConstraintArrayOutput

func (ServicePlacementConstraintArrayOutput) ToServicePlacementConstraintArrayOutputWithContext 

func (o ServicePlacementConstraintArrayOutput) ToServicePlacementConstraintArrayOutputWithContext(ctx context.Context) ServicePlacementConstraintArrayOutput

type ServicePlacementConstraintInput 

type ServicePlacementConstraintInput interface {
	pulumi.Input

	ToServicePlacementConstraintOutput() ServicePlacementConstraintOutput
	ToServicePlacementConstraintOutputWithContext(context.Context) ServicePlacementConstraintOutput
}

ServicePlacementConstraintInput is an input type that accepts ServicePlacementConstraintArgs and ServicePlacementConstraintOutput values. You can construct a concrete instance of `ServicePlacementConstraintInput` via: 

ServicePlacementConstraintArgs{...}

type ServicePlacementConstraintOutput 

type ServicePlacementConstraintOutput struct{ *pulumi.OutputState }

The “PlacementConstraint“ property specifies an object representing a constraint on task placement in the task definition. For more information, see [Task Placement Constraints](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServicePlacementConstraintOutput) ElementType 

func (ServicePlacementConstraintOutput) ElementType() reflect.Type

func (ServicePlacementConstraintOutput) Expression 

func (o ServicePlacementConstraintOutput) Expression() pulumi.StringPtrOutput

A cluster query language expression to apply to the constraint. The expression can have a maximum length of 2000 characters. You can't specify an expression if the constraint type is “distinctInstance“. For more information, see [Cluster query language](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServicePlacementConstraintOutput) ToServicePlacementConstraintOutput 

func (o ServicePlacementConstraintOutput) ToServicePlacementConstraintOutput() ServicePlacementConstraintOutput

func (ServicePlacementConstraintOutput) ToServicePlacementConstraintOutputWithContext 

func (o ServicePlacementConstraintOutput) ToServicePlacementConstraintOutputWithContext(ctx context.Context) ServicePlacementConstraintOutput

func (ServicePlacementConstraintOutput) Type 

func (o ServicePlacementConstraintOutput) Type() ServicePlacementConstraintTypeOutput

The type of constraint. Use “distinctInstance“ to ensure that each task in a particular group is running on a different container instance. Use “memberOf“ to restrict the selection to a group of valid candidates.

type ServicePlacementConstraintType 

type ServicePlacementConstraintType string

The type of constraint. Use “distinctInstance“ to ensure that each task in a particular group is running on a different container instance. Use “memberOf“ to restrict the selection to a group of valid candidates.

func (ServicePlacementConstraintType) ElementType 

func (ServicePlacementConstraintType) ElementType() reflect.Type

func (ServicePlacementConstraintType) ToServicePlacementConstraintTypeOutput 

func (e ServicePlacementConstraintType) ToServicePlacementConstraintTypeOutput() ServicePlacementConstraintTypeOutput

func (ServicePlacementConstraintType) ToServicePlacementConstraintTypeOutputWithContext 

func (e ServicePlacementConstraintType) ToServicePlacementConstraintTypeOutputWithContext(ctx context.Context) ServicePlacementConstraintTypeOutput

func (ServicePlacementConstraintType) ToServicePlacementConstraintTypePtrOutput 

func (e ServicePlacementConstraintType) ToServicePlacementConstraintTypePtrOutput() ServicePlacementConstraintTypePtrOutput

func (ServicePlacementConstraintType) ToServicePlacementConstraintTypePtrOutputWithContext 

func (e ServicePlacementConstraintType) ToServicePlacementConstraintTypePtrOutputWithContext(ctx context.Context) ServicePlacementConstraintTypePtrOutput

func (ServicePlacementConstraintType) ToStringOutput 

func (e ServicePlacementConstraintType) ToStringOutput() pulumi.StringOutput

func (ServicePlacementConstraintType) ToStringOutputWithContext 

func (e ServicePlacementConstraintType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServicePlacementConstraintType) ToStringPtrOutput 

func (e ServicePlacementConstraintType) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePlacementConstraintType) ToStringPtrOutputWithContext 

func (e ServicePlacementConstraintType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServicePlacementConstraintTypeInput 

type ServicePlacementConstraintTypeInput interface {
	pulumi.Input

	ToServicePlacementConstraintTypeOutput() ServicePlacementConstraintTypeOutput
	ToServicePlacementConstraintTypeOutputWithContext(context.Context) ServicePlacementConstraintTypeOutput
}

ServicePlacementConstraintTypeInput is an input type that accepts values of the ServicePlacementConstraintType enum A concrete instance of `ServicePlacementConstraintTypeInput` can be one of the following: 

ServicePlacementConstraintTypeDistinctInstance
ServicePlacementConstraintTypeMemberOf

type ServicePlacementConstraintTypeOutput 

type ServicePlacementConstraintTypeOutput struct{ *pulumi.OutputState }

func (ServicePlacementConstraintTypeOutput) ElementType 

func (ServicePlacementConstraintTypeOutput) ElementType() reflect.Type

func (ServicePlacementConstraintTypeOutput) ToServicePlacementConstraintTypeOutput 

func (o ServicePlacementConstraintTypeOutput) ToServicePlacementConstraintTypeOutput() ServicePlacementConstraintTypeOutput

func (ServicePlacementConstraintTypeOutput) ToServicePlacementConstraintTypeOutputWithContext 

func (o ServicePlacementConstraintTypeOutput) ToServicePlacementConstraintTypeOutputWithContext(ctx context.Context) ServicePlacementConstraintTypeOutput

func (ServicePlacementConstraintTypeOutput) ToServicePlacementConstraintTypePtrOutput 

func (o ServicePlacementConstraintTypeOutput) ToServicePlacementConstraintTypePtrOutput() ServicePlacementConstraintTypePtrOutput

func (ServicePlacementConstraintTypeOutput) ToServicePlacementConstraintTypePtrOutputWithContext 

func (o ServicePlacementConstraintTypeOutput) ToServicePlacementConstraintTypePtrOutputWithContext(ctx context.Context) ServicePlacementConstraintTypePtrOutput

func (ServicePlacementConstraintTypeOutput) ToStringOutput 

func (o ServicePlacementConstraintTypeOutput) ToStringOutput() pulumi.StringOutput

func (ServicePlacementConstraintTypeOutput) ToStringOutputWithContext 

func (o ServicePlacementConstraintTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServicePlacementConstraintTypeOutput) ToStringPtrOutput 

func (o ServicePlacementConstraintTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePlacementConstraintTypeOutput) ToStringPtrOutputWithContext 

func (o ServicePlacementConstraintTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServicePlacementConstraintTypePtrInput 

type ServicePlacementConstraintTypePtrInput interface {
	pulumi.Input

	ToServicePlacementConstraintTypePtrOutput() ServicePlacementConstraintTypePtrOutput
	ToServicePlacementConstraintTypePtrOutputWithContext(context.Context) ServicePlacementConstraintTypePtrOutput
}

func ServicePlacementConstraintTypePtr 

func ServicePlacementConstraintTypePtr(v string) ServicePlacementConstraintTypePtrInput

type ServicePlacementConstraintTypePtrOutput 

type ServicePlacementConstraintTypePtrOutput struct{ *pulumi.OutputState }

func (ServicePlacementConstraintTypePtrOutput) Elem 

func (o ServicePlacementConstraintTypePtrOutput) Elem() ServicePlacementConstraintTypeOutput

func (ServicePlacementConstraintTypePtrOutput) ElementType 

func (ServicePlacementConstraintTypePtrOutput) ElementType() reflect.Type

func (ServicePlacementConstraintTypePtrOutput) ToServicePlacementConstraintTypePtrOutput 

func (o ServicePlacementConstraintTypePtrOutput) ToServicePlacementConstraintTypePtrOutput() ServicePlacementConstraintTypePtrOutput

func (ServicePlacementConstraintTypePtrOutput) ToServicePlacementConstraintTypePtrOutputWithContext 

func (o ServicePlacementConstraintTypePtrOutput) ToServicePlacementConstraintTypePtrOutputWithContext(ctx context.Context) ServicePlacementConstraintTypePtrOutput

func (ServicePlacementConstraintTypePtrOutput) ToStringPtrOutput 

func (o ServicePlacementConstraintTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePlacementConstraintTypePtrOutput) ToStringPtrOutputWithContext 

func (o ServicePlacementConstraintTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServicePlacementStrategy 

type ServicePlacementStrategy struct {
	// The field to apply the placement strategy against. For the “spread“ placement strategy, valid values are “instanceId“ (or “host“, which has the same effect), or any platform or custom attribute that is applied to a container instance, such as “attribute:ecs.availability-zone“. For the “binpack“ placement strategy, valid values are “CPU“ and “MEMORY“. For the “random“ placement strategy, this field is not used.
	Field *string `pulumi:"field"`
	// The type of placement strategy. The “random“ placement strategy randomly places tasks on available candidates. The “spread“ placement strategy spreads placement across available candidates evenly based on the “field“ parameter. The “binpack“ strategy places tasks on available candidates that have the least available amount of the resource that's specified with the “field“ parameter. For example, if you binpack on memory, a task is placed on the instance with the least amount of remaining memory but still enough to run the task.
	Type ServicePlacementStrategyType `pulumi:"type"`
}

The “PlacementStrategy“ property specifies the task placement strategy for a task or service. For more information, see [Task Placement Strategies](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-strategies.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServicePlacementStrategyArgs 

type ServicePlacementStrategyArgs struct {
	// The field to apply the placement strategy against. For the “spread“ placement strategy, valid values are “instanceId“ (or “host“, which has the same effect), or any platform or custom attribute that is applied to a container instance, such as “attribute:ecs.availability-zone“. For the “binpack“ placement strategy, valid values are “CPU“ and “MEMORY“. For the “random“ placement strategy, this field is not used.
	Field pulumi.StringPtrInput `pulumi:"field"`
	// The type of placement strategy. The “random“ placement strategy randomly places tasks on available candidates. The “spread“ placement strategy spreads placement across available candidates evenly based on the “field“ parameter. The “binpack“ strategy places tasks on available candidates that have the least available amount of the resource that's specified with the “field“ parameter. For example, if you binpack on memory, a task is placed on the instance with the least amount of remaining memory but still enough to run the task.
	Type ServicePlacementStrategyTypeInput `pulumi:"type"`
}

The “PlacementStrategy“ property specifies the task placement strategy for a task or service. For more information, see [Task Placement Strategies](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-strategies.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServicePlacementStrategyArgs) ElementType 

func (ServicePlacementStrategyArgs) ElementType() reflect.Type

func (ServicePlacementStrategyArgs) ToServicePlacementStrategyOutput 

func (i ServicePlacementStrategyArgs) ToServicePlacementStrategyOutput() ServicePlacementStrategyOutput

func (ServicePlacementStrategyArgs) ToServicePlacementStrategyOutputWithContext 

func (i ServicePlacementStrategyArgs) ToServicePlacementStrategyOutputWithContext(ctx context.Context) ServicePlacementStrategyOutput

type ServicePlacementStrategyArray 

type ServicePlacementStrategyArray []ServicePlacementStrategyInput

func (ServicePlacementStrategyArray) ElementType 

func (ServicePlacementStrategyArray) ElementType() reflect.Type

func (ServicePlacementStrategyArray) ToServicePlacementStrategyArrayOutput 

func (i ServicePlacementStrategyArray) ToServicePlacementStrategyArrayOutput() ServicePlacementStrategyArrayOutput

func (ServicePlacementStrategyArray) ToServicePlacementStrategyArrayOutputWithContext 

func (i ServicePlacementStrategyArray) ToServicePlacementStrategyArrayOutputWithContext(ctx context.Context) ServicePlacementStrategyArrayOutput

type ServicePlacementStrategyArrayInput 

type ServicePlacementStrategyArrayInput interface {
	pulumi.Input

	ToServicePlacementStrategyArrayOutput() ServicePlacementStrategyArrayOutput
	ToServicePlacementStrategyArrayOutputWithContext(context.Context) ServicePlacementStrategyArrayOutput
}

ServicePlacementStrategyArrayInput is an input type that accepts ServicePlacementStrategyArray and ServicePlacementStrategyArrayOutput values. You can construct a concrete instance of `ServicePlacementStrategyArrayInput` via: 

ServicePlacementStrategyArray{ ServicePlacementStrategyArgs{...} }

type ServicePlacementStrategyArrayOutput 

type ServicePlacementStrategyArrayOutput struct{ *pulumi.OutputState }

func (ServicePlacementStrategyArrayOutput) ElementType 

func (ServicePlacementStrategyArrayOutput) ElementType() reflect.Type

func (ServicePlacementStrategyArrayOutput) Index 

func (o ServicePlacementStrategyArrayOutput) Index(i pulumi.IntInput) ServicePlacementStrategyOutput

func (ServicePlacementStrategyArrayOutput) ToServicePlacementStrategyArrayOutput 

func (o ServicePlacementStrategyArrayOutput) ToServicePlacementStrategyArrayOutput() ServicePlacementStrategyArrayOutput

func (ServicePlacementStrategyArrayOutput) ToServicePlacementStrategyArrayOutputWithContext 

func (o ServicePlacementStrategyArrayOutput) ToServicePlacementStrategyArrayOutputWithContext(ctx context.Context) ServicePlacementStrategyArrayOutput

type ServicePlacementStrategyInput 

type ServicePlacementStrategyInput interface {
	pulumi.Input

	ToServicePlacementStrategyOutput() ServicePlacementStrategyOutput
	ToServicePlacementStrategyOutputWithContext(context.Context) ServicePlacementStrategyOutput
}

ServicePlacementStrategyInput is an input type that accepts ServicePlacementStrategyArgs and ServicePlacementStrategyOutput values. You can construct a concrete instance of `ServicePlacementStrategyInput` via: 

ServicePlacementStrategyArgs{...}

type ServicePlacementStrategyOutput 

type ServicePlacementStrategyOutput struct{ *pulumi.OutputState }

The “PlacementStrategy“ property specifies the task placement strategy for a task or service. For more information, see [Task Placement Strategies](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-strategies.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServicePlacementStrategyOutput) ElementType 

func (ServicePlacementStrategyOutput) ElementType() reflect.Type

func (ServicePlacementStrategyOutput) Field 

func (o ServicePlacementStrategyOutput) Field() pulumi.StringPtrOutput

The field to apply the placement strategy against. For the “spread“ placement strategy, valid values are “instanceId“ (or “host“, which has the same effect), or any platform or custom attribute that is applied to a container instance, such as “attribute:ecs.availability-zone“. For the “binpack“ placement strategy, valid values are “CPU“ and “MEMORY“. For the “random“ placement strategy, this field is not used.

func (ServicePlacementStrategyOutput) ToServicePlacementStrategyOutput 

func (o ServicePlacementStrategyOutput) ToServicePlacementStrategyOutput() ServicePlacementStrategyOutput

func (ServicePlacementStrategyOutput) ToServicePlacementStrategyOutputWithContext 

func (o ServicePlacementStrategyOutput) ToServicePlacementStrategyOutputWithContext(ctx context.Context) ServicePlacementStrategyOutput

func (ServicePlacementStrategyOutput) Type 

func (o ServicePlacementStrategyOutput) Type() ServicePlacementStrategyTypeOutput

The type of placement strategy. The “random“ placement strategy randomly places tasks on available candidates. The “spread“ placement strategy spreads placement across available candidates evenly based on the “field“ parameter. The “binpack“ strategy places tasks on available candidates that have the least available amount of the resource that's specified with the “field“ parameter. For example, if you binpack on memory, a task is placed on the instance with the least amount of remaining memory but still enough to run the task.

type ServicePlacementStrategyType 

type ServicePlacementStrategyType string

The type of placement strategy. The “random“ placement strategy randomly places tasks on available candidates. The “spread“ placement strategy spreads placement across available candidates evenly based on the “field“ parameter. The “binpack“ strategy places tasks on available candidates that have the least available amount of the resource that's specified with the “field“ parameter. For example, if you binpack on memory, a task is placed on the instance with the least amount of remaining memory but still enough to run the task.

func (ServicePlacementStrategyType) ElementType 

func (ServicePlacementStrategyType) ElementType() reflect.Type

func (ServicePlacementStrategyType) ToServicePlacementStrategyTypeOutput 

func (e ServicePlacementStrategyType) ToServicePlacementStrategyTypeOutput() ServicePlacementStrategyTypeOutput

func (ServicePlacementStrategyType) ToServicePlacementStrategyTypeOutputWithContext 

func (e ServicePlacementStrategyType) ToServicePlacementStrategyTypeOutputWithContext(ctx context.Context) ServicePlacementStrategyTypeOutput

func (ServicePlacementStrategyType) ToServicePlacementStrategyTypePtrOutput 

func (e ServicePlacementStrategyType) ToServicePlacementStrategyTypePtrOutput() ServicePlacementStrategyTypePtrOutput

func (ServicePlacementStrategyType) ToServicePlacementStrategyTypePtrOutputWithContext 

func (e ServicePlacementStrategyType) ToServicePlacementStrategyTypePtrOutputWithContext(ctx context.Context) ServicePlacementStrategyTypePtrOutput

func (ServicePlacementStrategyType) ToStringOutput 

func (e ServicePlacementStrategyType) ToStringOutput() pulumi.StringOutput

func (ServicePlacementStrategyType) ToStringOutputWithContext 

func (e ServicePlacementStrategyType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServicePlacementStrategyType) ToStringPtrOutput 

func (e ServicePlacementStrategyType) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePlacementStrategyType) ToStringPtrOutputWithContext 

func (e ServicePlacementStrategyType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServicePlacementStrategyTypeInput 

type ServicePlacementStrategyTypeInput interface {
	pulumi.Input

	ToServicePlacementStrategyTypeOutput() ServicePlacementStrategyTypeOutput
	ToServicePlacementStrategyTypeOutputWithContext(context.Context) ServicePlacementStrategyTypeOutput
}

ServicePlacementStrategyTypeInput is an input type that accepts values of the ServicePlacementStrategyType enum A concrete instance of `ServicePlacementStrategyTypeInput` can be one of the following: 

ServicePlacementStrategyTypeBinpack
ServicePlacementStrategyTypeRandom
ServicePlacementStrategyTypeSpread

type ServicePlacementStrategyTypeOutput 

type ServicePlacementStrategyTypeOutput struct{ *pulumi.OutputState }

func (ServicePlacementStrategyTypeOutput) ElementType 

func (ServicePlacementStrategyTypeOutput) ElementType() reflect.Type

func (ServicePlacementStrategyTypeOutput) ToServicePlacementStrategyTypeOutput 

func (o ServicePlacementStrategyTypeOutput) ToServicePlacementStrategyTypeOutput() ServicePlacementStrategyTypeOutput

func (ServicePlacementStrategyTypeOutput) ToServicePlacementStrategyTypeOutputWithContext 

func (o ServicePlacementStrategyTypeOutput) ToServicePlacementStrategyTypeOutputWithContext(ctx context.Context) ServicePlacementStrategyTypeOutput

func (ServicePlacementStrategyTypeOutput) ToServicePlacementStrategyTypePtrOutput 

func (o ServicePlacementStrategyTypeOutput) ToServicePlacementStrategyTypePtrOutput() ServicePlacementStrategyTypePtrOutput

func (ServicePlacementStrategyTypeOutput) ToServicePlacementStrategyTypePtrOutputWithContext 

func (o ServicePlacementStrategyTypeOutput) ToServicePlacementStrategyTypePtrOutputWithContext(ctx context.Context) ServicePlacementStrategyTypePtrOutput

func (ServicePlacementStrategyTypeOutput) ToStringOutput 

func (o ServicePlacementStrategyTypeOutput) ToStringOutput() pulumi.StringOutput

func (ServicePlacementStrategyTypeOutput) ToStringOutputWithContext 

func (o ServicePlacementStrategyTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServicePlacementStrategyTypeOutput) ToStringPtrOutput 

func (o ServicePlacementStrategyTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePlacementStrategyTypeOutput) ToStringPtrOutputWithContext 

func (o ServicePlacementStrategyTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServicePlacementStrategyTypePtrInput 

type ServicePlacementStrategyTypePtrInput interface {
	pulumi.Input

	ToServicePlacementStrategyTypePtrOutput() ServicePlacementStrategyTypePtrOutput
	ToServicePlacementStrategyTypePtrOutputWithContext(context.Context) ServicePlacementStrategyTypePtrOutput
}

func ServicePlacementStrategyTypePtr 

func ServicePlacementStrategyTypePtr(v string) ServicePlacementStrategyTypePtrInput

type ServicePlacementStrategyTypePtrOutput 

type ServicePlacementStrategyTypePtrOutput struct{ *pulumi.OutputState }

func (ServicePlacementStrategyTypePtrOutput) Elem 

func (o ServicePlacementStrategyTypePtrOutput) Elem() ServicePlacementStrategyTypeOutput

func (ServicePlacementStrategyTypePtrOutput) ElementType 

func (ServicePlacementStrategyTypePtrOutput) ElementType() reflect.Type

func (ServicePlacementStrategyTypePtrOutput) ToServicePlacementStrategyTypePtrOutput 

func (o ServicePlacementStrategyTypePtrOutput) ToServicePlacementStrategyTypePtrOutput() ServicePlacementStrategyTypePtrOutput

func (ServicePlacementStrategyTypePtrOutput) ToServicePlacementStrategyTypePtrOutputWithContext 

func (o ServicePlacementStrategyTypePtrOutput) ToServicePlacementStrategyTypePtrOutputWithContext(ctx context.Context) ServicePlacementStrategyTypePtrOutput

func (ServicePlacementStrategyTypePtrOutput) ToStringPtrOutput 

func (o ServicePlacementStrategyTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePlacementStrategyTypePtrOutput) ToStringPtrOutputWithContext 

func (o ServicePlacementStrategyTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServicePropagateTags 

type ServicePropagateTags string

Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the task during task creation. To add tags to a task after task creation, use the [TagResource](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TagResource.html) API action. 

The default is ``NONE``.

func (ServicePropagateTags) ElementType 

func (ServicePropagateTags) ElementType() reflect.Type

func (ServicePropagateTags) ToServicePropagateTagsOutput 

func (e ServicePropagateTags) ToServicePropagateTagsOutput() ServicePropagateTagsOutput

func (ServicePropagateTags) ToServicePropagateTagsOutputWithContext 

func (e ServicePropagateTags) ToServicePropagateTagsOutputWithContext(ctx context.Context) ServicePropagateTagsOutput

func (ServicePropagateTags) ToServicePropagateTagsPtrOutput 

func (e ServicePropagateTags) ToServicePropagateTagsPtrOutput() ServicePropagateTagsPtrOutput

func (ServicePropagateTags) ToServicePropagateTagsPtrOutputWithContext 

func (e ServicePropagateTags) ToServicePropagateTagsPtrOutputWithContext(ctx context.Context) ServicePropagateTagsPtrOutput

func (ServicePropagateTags) ToStringOutput 

func (e ServicePropagateTags) ToStringOutput() pulumi.StringOutput

func (ServicePropagateTags) ToStringOutputWithContext 

func (e ServicePropagateTags) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServicePropagateTags) ToStringPtrOutput 

func (e ServicePropagateTags) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePropagateTags) ToStringPtrOutputWithContext 

func (e ServicePropagateTags) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServicePropagateTagsInput 

type ServicePropagateTagsInput interface {
	pulumi.Input

	ToServicePropagateTagsOutput() ServicePropagateTagsOutput
	ToServicePropagateTagsOutputWithContext(context.Context) ServicePropagateTagsOutput
}

ServicePropagateTagsInput is an input type that accepts values of the ServicePropagateTags enum A concrete instance of `ServicePropagateTagsInput` can be one of the following: 

ServicePropagateTagsService
ServicePropagateTagsTaskDefinition

type ServicePropagateTagsOutput 

type ServicePropagateTagsOutput struct{ *pulumi.OutputState }

func (ServicePropagateTagsOutput) ElementType 

func (ServicePropagateTagsOutput) ElementType() reflect.Type

func (ServicePropagateTagsOutput) ToServicePropagateTagsOutput 

func (o ServicePropagateTagsOutput) ToServicePropagateTagsOutput() ServicePropagateTagsOutput

func (ServicePropagateTagsOutput) ToServicePropagateTagsOutputWithContext 

func (o ServicePropagateTagsOutput) ToServicePropagateTagsOutputWithContext(ctx context.Context) ServicePropagateTagsOutput

func (ServicePropagateTagsOutput) ToServicePropagateTagsPtrOutput 

func (o ServicePropagateTagsOutput) ToServicePropagateTagsPtrOutput() ServicePropagateTagsPtrOutput

func (ServicePropagateTagsOutput) ToServicePropagateTagsPtrOutputWithContext 

func (o ServicePropagateTagsOutput) ToServicePropagateTagsPtrOutputWithContext(ctx context.Context) ServicePropagateTagsPtrOutput

func (ServicePropagateTagsOutput) ToStringOutput 

func (o ServicePropagateTagsOutput) ToStringOutput() pulumi.StringOutput

func (ServicePropagateTagsOutput) ToStringOutputWithContext 

func (o ServicePropagateTagsOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServicePropagateTagsOutput) ToStringPtrOutput 

func (o ServicePropagateTagsOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePropagateTagsOutput) ToStringPtrOutputWithContext 

func (o ServicePropagateTagsOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServicePropagateTagsPtrInput 

type ServicePropagateTagsPtrInput interface {
	pulumi.Input

	ToServicePropagateTagsPtrOutput() ServicePropagateTagsPtrOutput
	ToServicePropagateTagsPtrOutputWithContext(context.Context) ServicePropagateTagsPtrOutput
}

func ServicePropagateTagsPtr 

func ServicePropagateTagsPtr(v string) ServicePropagateTagsPtrInput

type ServicePropagateTagsPtrOutput 

type ServicePropagateTagsPtrOutput struct{ *pulumi.OutputState }

func (ServicePropagateTagsPtrOutput) Elem 

func (o ServicePropagateTagsPtrOutput) Elem() ServicePropagateTagsOutput

func (ServicePropagateTagsPtrOutput) ElementType 

func (ServicePropagateTagsPtrOutput) ElementType() reflect.Type

func (ServicePropagateTagsPtrOutput) ToServicePropagateTagsPtrOutput 

func (o ServicePropagateTagsPtrOutput) ToServicePropagateTagsPtrOutput() ServicePropagateTagsPtrOutput

func (ServicePropagateTagsPtrOutput) ToServicePropagateTagsPtrOutputWithContext 

func (o ServicePropagateTagsPtrOutput) ToServicePropagateTagsPtrOutputWithContext(ctx context.Context) ServicePropagateTagsPtrOutput

func (ServicePropagateTagsPtrOutput) ToStringPtrOutput 

func (o ServicePropagateTagsPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServicePropagateTagsPtrOutput) ToStringPtrOutputWithContext 

func (o ServicePropagateTagsPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceRegistry added in v0.2.0 

type ServiceRegistry struct {
	// The container name value to be used for your service discovery service. It's already specified in the task definition. If the task definition that your service task specifies uses the “bridge“ or “host“ network mode, you must specify a “containerName“ and “containerPort“ combination from the task definition. If the task definition that your service task specifies uses the “awsvpc“ network mode and a type SRV DNS record is used, you must specify either a “containerName“ and “containerPort“ combination or a “port“ value. However, you can't specify both.
	ContainerName *string `pulumi:"containerName"`
	// The port value to be used for your service discovery service. It's already specified in the task definition. If the task definition your service task specifies uses the “bridge“ or “host“ network mode, you must specify a “containerName“ and “containerPort“ combination from the task definition. If the task definition your service task specifies uses the “awsvpc“ network mode and a type SRV DNS record is used, you must specify either a “containerName“ and “containerPort“ combination or a “port“ value. However, you can't specify both.
	ContainerPort *int `pulumi:"containerPort"`
	// The port value used if your service discovery service specified an SRV record. This field might be used if both the “awsvpc“ network mode and SRV records are used.
	Port *int `pulumi:"port"`
	// The Amazon Resource Name (ARN) of the service registry. The currently supported service registry is CMAP. For more information, see [CreateService](https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html).
	RegistryArn *string `pulumi:"registryArn"`
}

The “ServiceRegistry“ property specifies details of the service registry. For more information, see [Service Discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServiceRegistryArgs added in v0.2.0 

type ServiceRegistryArgs struct {
	// The container name value to be used for your service discovery service. It's already specified in the task definition. If the task definition that your service task specifies uses the “bridge“ or “host“ network mode, you must specify a “containerName“ and “containerPort“ combination from the task definition. If the task definition that your service task specifies uses the “awsvpc“ network mode and a type SRV DNS record is used, you must specify either a “containerName“ and “containerPort“ combination or a “port“ value. However, you can't specify both.
	ContainerName pulumi.StringPtrInput `pulumi:"containerName"`
	// The port value to be used for your service discovery service. It's already specified in the task definition. If the task definition your service task specifies uses the “bridge“ or “host“ network mode, you must specify a “containerName“ and “containerPort“ combination from the task definition. If the task definition your service task specifies uses the “awsvpc“ network mode and a type SRV DNS record is used, you must specify either a “containerName“ and “containerPort“ combination or a “port“ value. However, you can't specify both.
	ContainerPort pulumi.IntPtrInput `pulumi:"containerPort"`
	// The port value used if your service discovery service specified an SRV record. This field might be used if both the “awsvpc“ network mode and SRV records are used.
	Port pulumi.IntPtrInput `pulumi:"port"`
	// The Amazon Resource Name (ARN) of the service registry. The currently supported service registry is CMAP. For more information, see [CreateService](https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html).
	RegistryArn pulumi.StringPtrInput `pulumi:"registryArn"`
}

The “ServiceRegistry“ property specifies details of the service registry. For more information, see [Service Discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceRegistryArgs) ElementType added in v0.2.0 

func (ServiceRegistryArgs) ElementType() reflect.Type

func (ServiceRegistryArgs) ToServiceRegistryOutput added in v0.2.0 

func (i ServiceRegistryArgs) ToServiceRegistryOutput() ServiceRegistryOutput

func (ServiceRegistryArgs) ToServiceRegistryOutputWithContext added in v0.2.0 

func (i ServiceRegistryArgs) ToServiceRegistryOutputWithContext(ctx context.Context) ServiceRegistryOutput

type ServiceRegistryArray added in v0.2.0 

type ServiceRegistryArray []ServiceRegistryInput

func (ServiceRegistryArray) ElementType added in v0.2.0 

func (ServiceRegistryArray) ElementType() reflect.Type

func (ServiceRegistryArray) ToServiceRegistryArrayOutput added in v0.2.0 

func (i ServiceRegistryArray) ToServiceRegistryArrayOutput() ServiceRegistryArrayOutput

func (ServiceRegistryArray) ToServiceRegistryArrayOutputWithContext added in v0.2.0 

func (i ServiceRegistryArray) ToServiceRegistryArrayOutputWithContext(ctx context.Context) ServiceRegistryArrayOutput

type ServiceRegistryArrayInput added in v0.2.0 

type ServiceRegistryArrayInput interface {
	pulumi.Input

	ToServiceRegistryArrayOutput() ServiceRegistryArrayOutput
	ToServiceRegistryArrayOutputWithContext(context.Context) ServiceRegistryArrayOutput
}

ServiceRegistryArrayInput is an input type that accepts ServiceRegistryArray and ServiceRegistryArrayOutput values. You can construct a concrete instance of `ServiceRegistryArrayInput` via: 

ServiceRegistryArray{ ServiceRegistryArgs{...} }

type ServiceRegistryArrayOutput added in v0.2.0 

type ServiceRegistryArrayOutput struct{ *pulumi.OutputState }

func (ServiceRegistryArrayOutput) ElementType added in v0.2.0 

func (ServiceRegistryArrayOutput) ElementType() reflect.Type

func (ServiceRegistryArrayOutput) Index added in v0.2.0 

func (o ServiceRegistryArrayOutput) Index(i pulumi.IntInput) ServiceRegistryOutput

func (ServiceRegistryArrayOutput) ToServiceRegistryArrayOutput added in v0.2.0 

func (o ServiceRegistryArrayOutput) ToServiceRegistryArrayOutput() ServiceRegistryArrayOutput

func (ServiceRegistryArrayOutput) ToServiceRegistryArrayOutputWithContext added in v0.2.0 

func (o ServiceRegistryArrayOutput) ToServiceRegistryArrayOutputWithContext(ctx context.Context) ServiceRegistryArrayOutput

type ServiceRegistryInput added in v0.2.0 

type ServiceRegistryInput interface {
	pulumi.Input

	ToServiceRegistryOutput() ServiceRegistryOutput
	ToServiceRegistryOutputWithContext(context.Context) ServiceRegistryOutput
}

ServiceRegistryInput is an input type that accepts ServiceRegistryArgs and ServiceRegistryOutput values. You can construct a concrete instance of `ServiceRegistryInput` via: 

ServiceRegistryArgs{...}

type ServiceRegistryOutput added in v0.2.0 

type ServiceRegistryOutput struct{ *pulumi.OutputState }

The “ServiceRegistry“ property specifies details of the service registry. For more information, see [Service Discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceRegistryOutput) ContainerName added in v0.2.0 

func (o ServiceRegistryOutput) ContainerName() pulumi.StringPtrOutput

The container name value to be used for your service discovery service. It's already specified in the task definition. If the task definition that your service task specifies uses the “bridge“ or “host“ network mode, you must specify a “containerName“ and “containerPort“ combination from the task definition. If the task definition that your service task specifies uses the “awsvpc“ network mode and a type SRV DNS record is used, you must specify either a “containerName“ and “containerPort“ combination or a “port“ value. However, you can't specify both.

func (ServiceRegistryOutput) ContainerPort added in v0.2.0 

func (o ServiceRegistryOutput) ContainerPort() pulumi.IntPtrOutput

The port value to be used for your service discovery service. It's already specified in the task definition. If the task definition your service task specifies uses the “bridge“ or “host“ network mode, you must specify a “containerName“ and “containerPort“ combination from the task definition. If the task definition your service task specifies uses the “awsvpc“ network mode and a type SRV DNS record is used, you must specify either a “containerName“ and “containerPort“ combination or a “port“ value. However, you can't specify both.

func (ServiceRegistryOutput) ElementType added in v0.2.0 

func (ServiceRegistryOutput) ElementType() reflect.Type

func (ServiceRegistryOutput) Port added in v0.2.0 

func (o ServiceRegistryOutput) Port() pulumi.IntPtrOutput

The port value used if your service discovery service specified an SRV record. This field might be used if both the “awsvpc“ network mode and SRV records are used.

func (ServiceRegistryOutput) RegistryArn added in v0.2.0 

func (o ServiceRegistryOutput) RegistryArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the service registry. The currently supported service registry is CMAP. For more information, see [CreateService](https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html).

func (ServiceRegistryOutput) ToServiceRegistryOutput added in v0.2.0 

func (o ServiceRegistryOutput) ToServiceRegistryOutput() ServiceRegistryOutput

func (ServiceRegistryOutput) ToServiceRegistryOutputWithContext added in v0.2.0 

func (o ServiceRegistryOutput) ToServiceRegistryOutputWithContext(ctx context.Context) ServiceRegistryOutput

type ServiceSchedulingStrategy 

type ServiceSchedulingStrategy string

The scheduling strategy to use for the service. For more information, see [Services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html). 

There are two service scheduler strategies available:
 +   ``REPLICA``-The replica scheduling strategy places and maintains the desired number of tasks across your cluster. By default, the service scheduler spreads tasks across Availability Zones. You can use task placement strategies and constraints to customize task placement decisions. This scheduler strategy is required if the service uses the ``CODE_DEPLOY`` or ``EXTERNAL`` deployment controller types.
 +   ``DAEMON``-The daemon scheduling strategy deploys exactly one task on each active container instance that meets all of the task placement constraints that you specify in your cluster. The service scheduler also evaluates the task placement constraints for running tasks and will stop tasks that don't meet the placement constraints. When you're using this strategy, you don't need to specify a desired number of tasks, a task placement strategy, or use Service Auto Scaling policies.
       Tasks using the Fargate launch type or the ``CODE_DEPLOY`` or ``EXTERNAL`` deployment controller types don't support the ``DAEMON`` scheduling strategy.

func (ServiceSchedulingStrategy) ElementType 

func (ServiceSchedulingStrategy) ElementType() reflect.Type

func (ServiceSchedulingStrategy) ToServiceSchedulingStrategyOutput 

func (e ServiceSchedulingStrategy) ToServiceSchedulingStrategyOutput() ServiceSchedulingStrategyOutput

func (ServiceSchedulingStrategy) ToServiceSchedulingStrategyOutputWithContext 

func (e ServiceSchedulingStrategy) ToServiceSchedulingStrategyOutputWithContext(ctx context.Context) ServiceSchedulingStrategyOutput

func (ServiceSchedulingStrategy) ToServiceSchedulingStrategyPtrOutput 

func (e ServiceSchedulingStrategy) ToServiceSchedulingStrategyPtrOutput() ServiceSchedulingStrategyPtrOutput

func (ServiceSchedulingStrategy) ToServiceSchedulingStrategyPtrOutputWithContext 

func (e ServiceSchedulingStrategy) ToServiceSchedulingStrategyPtrOutputWithContext(ctx context.Context) ServiceSchedulingStrategyPtrOutput

func (ServiceSchedulingStrategy) ToStringOutput 

func (e ServiceSchedulingStrategy) ToStringOutput() pulumi.StringOutput

func (ServiceSchedulingStrategy) ToStringOutputWithContext 

func (e ServiceSchedulingStrategy) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceSchedulingStrategy) ToStringPtrOutput 

func (e ServiceSchedulingStrategy) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceSchedulingStrategy) ToStringPtrOutputWithContext 

func (e ServiceSchedulingStrategy) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceSchedulingStrategyInput 

type ServiceSchedulingStrategyInput interface {
	pulumi.Input

	ToServiceSchedulingStrategyOutput() ServiceSchedulingStrategyOutput
	ToServiceSchedulingStrategyOutputWithContext(context.Context) ServiceSchedulingStrategyOutput
}

ServiceSchedulingStrategyInput is an input type that accepts values of the ServiceSchedulingStrategy enum A concrete instance of `ServiceSchedulingStrategyInput` can be one of the following: 

ServiceSchedulingStrategyDaemon
ServiceSchedulingStrategyReplica

type ServiceSchedulingStrategyOutput 

type ServiceSchedulingStrategyOutput struct{ *pulumi.OutputState }

func (ServiceSchedulingStrategyOutput) ElementType 

func (ServiceSchedulingStrategyOutput) ElementType() reflect.Type

func (ServiceSchedulingStrategyOutput) ToServiceSchedulingStrategyOutput 

func (o ServiceSchedulingStrategyOutput) ToServiceSchedulingStrategyOutput() ServiceSchedulingStrategyOutput

func (ServiceSchedulingStrategyOutput) ToServiceSchedulingStrategyOutputWithContext 

func (o ServiceSchedulingStrategyOutput) ToServiceSchedulingStrategyOutputWithContext(ctx context.Context) ServiceSchedulingStrategyOutput

func (ServiceSchedulingStrategyOutput) ToServiceSchedulingStrategyPtrOutput 

func (o ServiceSchedulingStrategyOutput) ToServiceSchedulingStrategyPtrOutput() ServiceSchedulingStrategyPtrOutput

func (ServiceSchedulingStrategyOutput) ToServiceSchedulingStrategyPtrOutputWithContext 

func (o ServiceSchedulingStrategyOutput) ToServiceSchedulingStrategyPtrOutputWithContext(ctx context.Context) ServiceSchedulingStrategyPtrOutput

func (ServiceSchedulingStrategyOutput) ToStringOutput 

func (o ServiceSchedulingStrategyOutput) ToStringOutput() pulumi.StringOutput

func (ServiceSchedulingStrategyOutput) ToStringOutputWithContext 

func (o ServiceSchedulingStrategyOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (ServiceSchedulingStrategyOutput) ToStringPtrOutput 

func (o ServiceSchedulingStrategyOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceSchedulingStrategyOutput) ToStringPtrOutputWithContext 

func (o ServiceSchedulingStrategyOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceSchedulingStrategyPtrInput 

type ServiceSchedulingStrategyPtrInput interface {
	pulumi.Input

	ToServiceSchedulingStrategyPtrOutput() ServiceSchedulingStrategyPtrOutput
	ToServiceSchedulingStrategyPtrOutputWithContext(context.Context) ServiceSchedulingStrategyPtrOutput
}

func ServiceSchedulingStrategyPtr 

func ServiceSchedulingStrategyPtr(v string) ServiceSchedulingStrategyPtrInput

type ServiceSchedulingStrategyPtrOutput 

type ServiceSchedulingStrategyPtrOutput struct{ *pulumi.OutputState }

func (ServiceSchedulingStrategyPtrOutput) Elem 

func (o ServiceSchedulingStrategyPtrOutput) Elem() ServiceSchedulingStrategyOutput

func (ServiceSchedulingStrategyPtrOutput) ElementType 

func (ServiceSchedulingStrategyPtrOutput) ElementType() reflect.Type

func (ServiceSchedulingStrategyPtrOutput) ToServiceSchedulingStrategyPtrOutput 

func (o ServiceSchedulingStrategyPtrOutput) ToServiceSchedulingStrategyPtrOutput() ServiceSchedulingStrategyPtrOutput

func (ServiceSchedulingStrategyPtrOutput) ToServiceSchedulingStrategyPtrOutputWithContext 

func (o ServiceSchedulingStrategyPtrOutput) ToServiceSchedulingStrategyPtrOutputWithContext(ctx context.Context) ServiceSchedulingStrategyPtrOutput

func (ServiceSchedulingStrategyPtrOutput) ToStringPtrOutput 

func (o ServiceSchedulingStrategyPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (ServiceSchedulingStrategyPtrOutput) ToStringPtrOutputWithContext 

func (o ServiceSchedulingStrategyPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

type ServiceSecret added in v0.41.0 

type ServiceSecret struct {
	// The name of the secret.
	Name string `pulumi:"name"`
	// The secret to expose to the container. The supported values are either the full ARN of the ASMlong secret or the full ARN of the parameter in the SSM Parameter Store.
	//  For information about the require IAMlong permissions, see [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-secrets.html#secrets-iam) (for Secrets Manager) or [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-parameters.html) (for Systems Manager Parameter store) in the *Amazon Elastic Container Service Developer Guide*.
	//   If the SSM Parameter Store parameter exists in the same Region as the task you're launching, then you can use either the full ARN or name of the parameter. If the parameter exists in a different Region, then the full ARN must be specified.
	ValueFrom string `pulumi:"valueFrom"`
}

An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:

  • To inject sensitive data into your containers as environment variables, use the “secrets“ container definition parameter.

  • To reference sensitive information in the log configuration of a container, use the “secretOptions“ container definition parameter.

    For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

type ServiceSecretArgs added in v0.41.0 

type ServiceSecretArgs struct {
	// The name of the secret.
	Name pulumi.StringInput `pulumi:"name"`
	// The secret to expose to the container. The supported values are either the full ARN of the ASMlong secret or the full ARN of the parameter in the SSM Parameter Store.
	//  For information about the require IAMlong permissions, see [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-secrets.html#secrets-iam) (for Secrets Manager) or [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-parameters.html) (for Systems Manager Parameter store) in the *Amazon Elastic Container Service Developer Guide*.
	//   If the SSM Parameter Store parameter exists in the same Region as the task you're launching, then you can use either the full ARN or name of the parameter. If the parameter exists in a different Region, then the full ARN must be specified.
	ValueFrom pulumi.StringInput `pulumi:"valueFrom"`
}

An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:

  • To inject sensitive data into your containers as environment variables, use the “secrets“ container definition parameter.

  • To reference sensitive information in the log configuration of a container, use the “secretOptions“ container definition parameter.

    For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceSecretArgs) ElementType added in v0.41.0 

func (ServiceSecretArgs) ElementType() reflect.Type

func (ServiceSecretArgs) ToServiceSecretOutput added in v0.41.0 

func (i ServiceSecretArgs) ToServiceSecretOutput() ServiceSecretOutput

func (ServiceSecretArgs) ToServiceSecretOutputWithContext added in v0.41.0 

func (i ServiceSecretArgs) ToServiceSecretOutputWithContext(ctx context.Context) ServiceSecretOutput

type ServiceSecretArray added in v0.41.0 

type ServiceSecretArray []ServiceSecretInput

func (ServiceSecretArray) ElementType added in v0.41.0 

func (ServiceSecretArray) ElementType() reflect.Type

func (ServiceSecretArray) ToServiceSecretArrayOutput added in v0.41.0 

func (i ServiceSecretArray) ToServiceSecretArrayOutput() ServiceSecretArrayOutput

func (ServiceSecretArray) ToServiceSecretArrayOutputWithContext added in v0.41.0 

func (i ServiceSecretArray) ToServiceSecretArrayOutputWithContext(ctx context.Context) ServiceSecretArrayOutput

type ServiceSecretArrayInput added in v0.41.0 

type ServiceSecretArrayInput interface {
	pulumi.Input

	ToServiceSecretArrayOutput() ServiceSecretArrayOutput
	ToServiceSecretArrayOutputWithContext(context.Context) ServiceSecretArrayOutput
}

ServiceSecretArrayInput is an input type that accepts ServiceSecretArray and ServiceSecretArrayOutput values. You can construct a concrete instance of `ServiceSecretArrayInput` via: 

ServiceSecretArray{ ServiceSecretArgs{...} }

type ServiceSecretArrayOutput added in v0.41.0 

type ServiceSecretArrayOutput struct{ *pulumi.OutputState }

func (ServiceSecretArrayOutput) ElementType added in v0.41.0 

func (ServiceSecretArrayOutput) ElementType() reflect.Type

func (ServiceSecretArrayOutput) Index added in v0.41.0 

func (o ServiceSecretArrayOutput) Index(i pulumi.IntInput) ServiceSecretOutput

func (ServiceSecretArrayOutput) ToServiceSecretArrayOutput added in v0.41.0 

func (o ServiceSecretArrayOutput) ToServiceSecretArrayOutput() ServiceSecretArrayOutput

func (ServiceSecretArrayOutput) ToServiceSecretArrayOutputWithContext added in v0.41.0 

func (o ServiceSecretArrayOutput) ToServiceSecretArrayOutputWithContext(ctx context.Context) ServiceSecretArrayOutput

type ServiceSecretInput added in v0.41.0 

type ServiceSecretInput interface {
	pulumi.Input

	ToServiceSecretOutput() ServiceSecretOutput
	ToServiceSecretOutputWithContext(context.Context) ServiceSecretOutput
}

ServiceSecretInput is an input type that accepts ServiceSecretArgs and ServiceSecretOutput values. You can construct a concrete instance of `ServiceSecretInput` via: 

ServiceSecretArgs{...}

type ServiceSecretOutput added in v0.41.0 

type ServiceSecretOutput struct{ *pulumi.OutputState }

An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:

  • To inject sensitive data into your containers as environment variables, use the “secrets“ container definition parameter.

  • To reference sensitive information in the log configuration of a container, use the “secretOptions“ container definition parameter.

    For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (ServiceSecretOutput) ElementType added in v0.41.0 

func (ServiceSecretOutput) ElementType() reflect.Type

func (ServiceSecretOutput) Name added in v0.41.0 

func (o ServiceSecretOutput) Name() pulumi.StringOutput

The name of the secret.

func (ServiceSecretOutput) ToServiceSecretOutput added in v0.41.0 

func (o ServiceSecretOutput) ToServiceSecretOutput() ServiceSecretOutput

func (ServiceSecretOutput) ToServiceSecretOutputWithContext added in v0.41.0 

func (o ServiceSecretOutput) ToServiceSecretOutputWithContext(ctx context.Context) ServiceSecretOutput

func (ServiceSecretOutput) ValueFrom added in v0.41.0 

func (o ServiceSecretOutput) ValueFrom() pulumi.StringOutput

The secret to expose to the container. The supported values are either the full ARN of the ASMlong secret or the full ARN of the parameter in the SSM Parameter Store. 

For information about the require IAMlong permissions, see [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-secrets.html#secrets-iam) (for Secrets Manager) or [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-parameters.html) (for Systems Manager Parameter store) in the *Amazon Elastic Container Service Developer Guide*.
 If the SSM Parameter Store parameter exists in the same Region as the task you're launching, then you can use either the full ARN or name of the parameter. If the parameter exists in a different Region, then the full ARN must be specified.

type ServiceState 

type ServiceState struct {
}

func (ServiceState) ElementType 

func (ServiceState) ElementType() reflect.Type

type ServiceTag 

type ServiceTag struct {
	// One part of a key-value pair that make up a tag. A “key“ is a general label that acts like a category for more specific tag values.
	Key *string `pulumi:"key"`
	// The optional part of a key-value pair that make up a tag. A “value“ acts as a descriptor within a tag category (key).
	Value *string `pulumi:"value"`
}

The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value. You define them. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

type ServiceTagArgs 

type ServiceTagArgs struct {
	// One part of a key-value pair that make up a tag. A “key“ is a general label that acts like a category for more specific tag values.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// The optional part of a key-value pair that make up a tag. A “value“ acts as a descriptor within a tag category (key).
	Value pulumi.StringPtrInput `pulumi:"value"`
}

The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value. You define them. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

func (ServiceTagArgs) ElementType 

func (ServiceTagArgs) ElementType() reflect.Type

func (ServiceTagArgs) ToServiceTagOutput 

func (i ServiceTagArgs) ToServiceTagOutput() ServiceTagOutput

func (ServiceTagArgs) ToServiceTagOutputWithContext 

func (i ServiceTagArgs) ToServiceTagOutputWithContext(ctx context.Context) ServiceTagOutput

type ServiceTagArray 

type ServiceTagArray []ServiceTagInput

func (ServiceTagArray) ElementType 

func (ServiceTagArray) ElementType() reflect.Type

func (ServiceTagArray) ToServiceTagArrayOutput 

func (i ServiceTagArray) ToServiceTagArrayOutput() ServiceTagArrayOutput

func (ServiceTagArray) ToServiceTagArrayOutputWithContext 

func (i ServiceTagArray) ToServiceTagArrayOutputWithContext(ctx context.Context) ServiceTagArrayOutput

type ServiceTagArrayInput 

type ServiceTagArrayInput interface {
	pulumi.Input

	ToServiceTagArrayOutput() ServiceTagArrayOutput
	ToServiceTagArrayOutputWithContext(context.Context) ServiceTagArrayOutput
}

ServiceTagArrayInput is an input type that accepts ServiceTagArray and ServiceTagArrayOutput values. You can construct a concrete instance of `ServiceTagArrayInput` via: 

ServiceTagArray{ ServiceTagArgs{...} }

type ServiceTagArrayOutput 

type ServiceTagArrayOutput struct{ *pulumi.OutputState }

func (ServiceTagArrayOutput) ElementType 

func (ServiceTagArrayOutput) ElementType() reflect.Type

func (ServiceTagArrayOutput) Index 

func (o ServiceTagArrayOutput) Index(i pulumi.IntInput) ServiceTagOutput

func (ServiceTagArrayOutput) ToServiceTagArrayOutput 

func (o ServiceTagArrayOutput) ToServiceTagArrayOutput() ServiceTagArrayOutput

func (ServiceTagArrayOutput) ToServiceTagArrayOutputWithContext 

func (o ServiceTagArrayOutput) ToServiceTagArrayOutputWithContext(ctx context.Context) ServiceTagArrayOutput

type ServiceTagInput 

type ServiceTagInput interface {
	pulumi.Input

	ToServiceTagOutput() ServiceTagOutput
	ToServiceTagOutputWithContext(context.Context) ServiceTagOutput
}

ServiceTagInput is an input type that accepts ServiceTagArgs and ServiceTagOutput values. You can construct a concrete instance of `ServiceTagInput` via: 

ServiceTagArgs{...}

type ServiceTagOutput 

type ServiceTagOutput struct{ *pulumi.OutputState }

The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value. You define them. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

func (ServiceTagOutput) ElementType 

func (ServiceTagOutput) ElementType() reflect.Type

func (ServiceTagOutput) Key 

func (o ServiceTagOutput) Key() pulumi.StringPtrOutput

One part of a key-value pair that make up a tag. A “key“ is a general label that acts like a category for more specific tag values.

func (ServiceTagOutput) ToServiceTagOutput 

func (o ServiceTagOutput) ToServiceTagOutput() ServiceTagOutput

func (ServiceTagOutput) ToServiceTagOutputWithContext 

func (o ServiceTagOutput) ToServiceTagOutputWithContext(ctx context.Context) ServiceTagOutput

func (ServiceTagOutput) Value 

func (o ServiceTagOutput) Value() pulumi.StringPtrOutput

The optional part of a key-value pair that make up a tag. A “value“ acts as a descriptor within a tag category (key).

type ServiceTimeoutConfiguration added in v0.95.0 

type ServiceTimeoutConfiguration struct {
	// The amount of time in seconds a connection will stay active while idle. A value of “0“ can be set to disable “idleTimeout“.
	//  The “idleTimeout“ default for “HTTP“/“HTTP2“/“GRPC“ is 5 minutes.
	//  The “idleTimeout“ default for “TCP“ is 1 hour.
	IdleTimeoutSeconds *int `pulumi:"idleTimeoutSeconds"`
	// The amount of time waiting for the upstream to respond with a complete response per request. A value of “0“ can be set to disable “perRequestTimeout“. “perRequestTimeout“ can only be set if Service Connect “appProtocol“ isn't “TCP“. Only “idleTimeout“ is allowed for “TCP“ “appProtocol“.
	PerRequestTimeoutSeconds *int `pulumi:"perRequestTimeoutSeconds"`
}

An object that represents the timeout configurations for Service Connect. 

If ``idleTimeout`` is set to a time that is less than ``perRequestTimeout``, the connection will close when the ``idleTimeout`` is reached and not the ``perRequestTimeout``.

type ServiceTimeoutConfigurationArgs added in v0.95.0 

type ServiceTimeoutConfigurationArgs struct {
	// The amount of time in seconds a connection will stay active while idle. A value of “0“ can be set to disable “idleTimeout“.
	//  The “idleTimeout“ default for “HTTP“/“HTTP2“/“GRPC“ is 5 minutes.
	//  The “idleTimeout“ default for “TCP“ is 1 hour.
	IdleTimeoutSeconds pulumi.IntPtrInput `pulumi:"idleTimeoutSeconds"`
	// The amount of time waiting for the upstream to respond with a complete response per request. A value of “0“ can be set to disable “perRequestTimeout“. “perRequestTimeout“ can only be set if Service Connect “appProtocol“ isn't “TCP“. Only “idleTimeout“ is allowed for “TCP“ “appProtocol“.
	PerRequestTimeoutSeconds pulumi.IntPtrInput `pulumi:"perRequestTimeoutSeconds"`
}

An object that represents the timeout configurations for Service Connect. 

If ``idleTimeout`` is set to a time that is less than ``perRequestTimeout``, the connection will close when the ``idleTimeout`` is reached and not the ``perRequestTimeout``.

func (ServiceTimeoutConfigurationArgs) ElementType added in v0.95.0 

func (ServiceTimeoutConfigurationArgs) ElementType() reflect.Type

func (ServiceTimeoutConfigurationArgs) ToServiceTimeoutConfigurationOutput added in v0.95.0 

func (i ServiceTimeoutConfigurationArgs) ToServiceTimeoutConfigurationOutput() ServiceTimeoutConfigurationOutput

func (ServiceTimeoutConfigurationArgs) ToServiceTimeoutConfigurationOutputWithContext added in v0.95.0 

func (i ServiceTimeoutConfigurationArgs) ToServiceTimeoutConfigurationOutputWithContext(ctx context.Context) ServiceTimeoutConfigurationOutput

func (ServiceTimeoutConfigurationArgs) ToServiceTimeoutConfigurationPtrOutput added in v0.95.0 

func (i ServiceTimeoutConfigurationArgs) ToServiceTimeoutConfigurationPtrOutput() ServiceTimeoutConfigurationPtrOutput

func (ServiceTimeoutConfigurationArgs) ToServiceTimeoutConfigurationPtrOutputWithContext added in v0.95.0 

func (i ServiceTimeoutConfigurationArgs) ToServiceTimeoutConfigurationPtrOutputWithContext(ctx context.Context) ServiceTimeoutConfigurationPtrOutput

type ServiceTimeoutConfigurationInput added in v0.95.0 

type ServiceTimeoutConfigurationInput interface {
	pulumi.Input

	ToServiceTimeoutConfigurationOutput() ServiceTimeoutConfigurationOutput
	ToServiceTimeoutConfigurationOutputWithContext(context.Context) ServiceTimeoutConfigurationOutput
}

ServiceTimeoutConfigurationInput is an input type that accepts ServiceTimeoutConfigurationArgs and ServiceTimeoutConfigurationOutput values. You can construct a concrete instance of `ServiceTimeoutConfigurationInput` via: 

ServiceTimeoutConfigurationArgs{...}

type ServiceTimeoutConfigurationOutput added in v0.95.0 

type ServiceTimeoutConfigurationOutput struct{ *pulumi.OutputState }

An object that represents the timeout configurations for Service Connect. 

If ``idleTimeout`` is set to a time that is less than ``perRequestTimeout``, the connection will close when the ``idleTimeout`` is reached and not the ``perRequestTimeout``.

func (ServiceTimeoutConfigurationOutput) ElementType added in v0.95.0 

func (ServiceTimeoutConfigurationOutput) ElementType() reflect.Type

func (ServiceTimeoutConfigurationOutput) IdleTimeoutSeconds added in v0.95.0 

func (o ServiceTimeoutConfigurationOutput) IdleTimeoutSeconds() pulumi.IntPtrOutput

The amount of time in seconds a connection will stay active while idle. A value of “0“ can be set to disable “idleTimeout“. 

The ``idleTimeout`` default for ``HTTP``/``HTTP2``/``GRPC`` is 5 minutes.
The ``idleTimeout`` default for ``TCP`` is 1 hour.

func (ServiceTimeoutConfigurationOutput) PerRequestTimeoutSeconds added in v0.95.0 

func (o ServiceTimeoutConfigurationOutput) PerRequestTimeoutSeconds() pulumi.IntPtrOutput

The amount of time waiting for the upstream to respond with a complete response per request. A value of “0“ can be set to disable “perRequestTimeout“. “perRequestTimeout“ can only be set if Service Connect “appProtocol“ isn't “TCP“. Only “idleTimeout“ is allowed for “TCP“ “appProtocol“.

func (ServiceTimeoutConfigurationOutput) ToServiceTimeoutConfigurationOutput added in v0.95.0 

func (o ServiceTimeoutConfigurationOutput) ToServiceTimeoutConfigurationOutput() ServiceTimeoutConfigurationOutput

func (ServiceTimeoutConfigurationOutput) ToServiceTimeoutConfigurationOutputWithContext added in v0.95.0 

func (o ServiceTimeoutConfigurationOutput) ToServiceTimeoutConfigurationOutputWithContext(ctx context.Context) ServiceTimeoutConfigurationOutput

func (ServiceTimeoutConfigurationOutput) ToServiceTimeoutConfigurationPtrOutput added in v0.95.0 

func (o ServiceTimeoutConfigurationOutput) ToServiceTimeoutConfigurationPtrOutput() ServiceTimeoutConfigurationPtrOutput

func (ServiceTimeoutConfigurationOutput) ToServiceTimeoutConfigurationPtrOutputWithContext added in v0.95.0 

func (o ServiceTimeoutConfigurationOutput) ToServiceTimeoutConfigurationPtrOutputWithContext(ctx context.Context) ServiceTimeoutConfigurationPtrOutput

type ServiceTimeoutConfigurationPtrInput added in v0.95.0 

type ServiceTimeoutConfigurationPtrInput interface {
	pulumi.Input

	ToServiceTimeoutConfigurationPtrOutput() ServiceTimeoutConfigurationPtrOutput
	ToServiceTimeoutConfigurationPtrOutputWithContext(context.Context) ServiceTimeoutConfigurationPtrOutput
}

ServiceTimeoutConfigurationPtrInput is an input type that accepts ServiceTimeoutConfigurationArgs, ServiceTimeoutConfigurationPtr and ServiceTimeoutConfigurationPtrOutput values. You can construct a concrete instance of `ServiceTimeoutConfigurationPtrInput` via: 

        ServiceTimeoutConfigurationArgs{...}

or:

        nil

func ServiceTimeoutConfigurationPtr added in v0.95.0 

func ServiceTimeoutConfigurationPtr(v *ServiceTimeoutConfigurationArgs) ServiceTimeoutConfigurationPtrInput

type ServiceTimeoutConfigurationPtrOutput added in v0.95.0 

type ServiceTimeoutConfigurationPtrOutput struct{ *pulumi.OutputState }

func (ServiceTimeoutConfigurationPtrOutput) Elem added in v0.95.0 

func (o ServiceTimeoutConfigurationPtrOutput) Elem() ServiceTimeoutConfigurationOutput

func (ServiceTimeoutConfigurationPtrOutput) ElementType added in v0.95.0 

func (ServiceTimeoutConfigurationPtrOutput) ElementType() reflect.Type

func (ServiceTimeoutConfigurationPtrOutput) IdleTimeoutSeconds added in v0.95.0 

func (o ServiceTimeoutConfigurationPtrOutput) IdleTimeoutSeconds() pulumi.IntPtrOutput

The amount of time in seconds a connection will stay active while idle. A value of “0“ can be set to disable “idleTimeout“. 

The ``idleTimeout`` default for ``HTTP``/``HTTP2``/``GRPC`` is 5 minutes.
The ``idleTimeout`` default for ``TCP`` is 1 hour.

func (ServiceTimeoutConfigurationPtrOutput) PerRequestTimeoutSeconds added in v0.95.0 

func (o ServiceTimeoutConfigurationPtrOutput) PerRequestTimeoutSeconds() pulumi.IntPtrOutput

The amount of time waiting for the upstream to respond with a complete response per request. A value of “0“ can be set to disable “perRequestTimeout“. “perRequestTimeout“ can only be set if Service Connect “appProtocol“ isn't “TCP“. Only “idleTimeout“ is allowed for “TCP“ “appProtocol“.

func (ServiceTimeoutConfigurationPtrOutput) ToServiceTimeoutConfigurationPtrOutput added in v0.95.0 

func (o ServiceTimeoutConfigurationPtrOutput) ToServiceTimeoutConfigurationPtrOutput() ServiceTimeoutConfigurationPtrOutput

func (ServiceTimeoutConfigurationPtrOutput) ToServiceTimeoutConfigurationPtrOutputWithContext added in v0.95.0 

func (o ServiceTimeoutConfigurationPtrOutput) ToServiceTimeoutConfigurationPtrOutputWithContext(ctx context.Context) ServiceTimeoutConfigurationPtrOutput

type ServiceVolumeConfiguration added in v0.91.0 

type ServiceVolumeConfiguration struct {
	// The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf. These settings are used to create each Amazon EBS volume, with one volume created for each task in the service. The Amazon EBS volumes are visible in your account in the Amazon EC2 console once they are created.
	ManagedEbsVolume *ServiceManagedEbsVolumeConfiguration `pulumi:"managedEbsVolume"`
	// The name of the volume. This value must match the volume name from the “Volume“ object in the task definition.
	Name string `pulumi:"name"`
}

The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.

type ServiceVolumeConfigurationArgs added in v0.91.0 

type ServiceVolumeConfigurationArgs struct {
	// The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf. These settings are used to create each Amazon EBS volume, with one volume created for each task in the service. The Amazon EBS volumes are visible in your account in the Amazon EC2 console once they are created.
	ManagedEbsVolume ServiceManagedEbsVolumeConfigurationPtrInput `pulumi:"managedEbsVolume"`
	// The name of the volume. This value must match the volume name from the “Volume“ object in the task definition.
	Name pulumi.StringInput `pulumi:"name"`
}

The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.

func (ServiceVolumeConfigurationArgs) ElementType added in v0.91.0 

func (ServiceVolumeConfigurationArgs) ElementType() reflect.Type

func (ServiceVolumeConfigurationArgs) ToServiceVolumeConfigurationOutput added in v0.91.0 

func (i ServiceVolumeConfigurationArgs) ToServiceVolumeConfigurationOutput() ServiceVolumeConfigurationOutput

func (ServiceVolumeConfigurationArgs) ToServiceVolumeConfigurationOutputWithContext added in v0.91.0 

func (i ServiceVolumeConfigurationArgs) ToServiceVolumeConfigurationOutputWithContext(ctx context.Context) ServiceVolumeConfigurationOutput

type ServiceVolumeConfigurationArray added in v0.91.0 

type ServiceVolumeConfigurationArray []ServiceVolumeConfigurationInput

func (ServiceVolumeConfigurationArray) ElementType added in v0.91.0 

func (ServiceVolumeConfigurationArray) ElementType() reflect.Type

func (ServiceVolumeConfigurationArray) ToServiceVolumeConfigurationArrayOutput added in v0.91.0 

func (i ServiceVolumeConfigurationArray) ToServiceVolumeConfigurationArrayOutput() ServiceVolumeConfigurationArrayOutput

func (ServiceVolumeConfigurationArray) ToServiceVolumeConfigurationArrayOutputWithContext added in v0.91.0 

func (i ServiceVolumeConfigurationArray) ToServiceVolumeConfigurationArrayOutputWithContext(ctx context.Context) ServiceVolumeConfigurationArrayOutput

type ServiceVolumeConfigurationArrayInput added in v0.91.0 

type ServiceVolumeConfigurationArrayInput interface {
	pulumi.Input

	ToServiceVolumeConfigurationArrayOutput() ServiceVolumeConfigurationArrayOutput
	ToServiceVolumeConfigurationArrayOutputWithContext(context.Context) ServiceVolumeConfigurationArrayOutput
}

ServiceVolumeConfigurationArrayInput is an input type that accepts ServiceVolumeConfigurationArray and ServiceVolumeConfigurationArrayOutput values. You can construct a concrete instance of `ServiceVolumeConfigurationArrayInput` via: 

ServiceVolumeConfigurationArray{ ServiceVolumeConfigurationArgs{...} }

type ServiceVolumeConfigurationArrayOutput added in v0.91.0 

type ServiceVolumeConfigurationArrayOutput struct{ *pulumi.OutputState }

func (ServiceVolumeConfigurationArrayOutput) ElementType added in v0.91.0 

func (ServiceVolumeConfigurationArrayOutput) ElementType() reflect.Type

func (ServiceVolumeConfigurationArrayOutput) Index added in v0.91.0 

func (o ServiceVolumeConfigurationArrayOutput) Index(i pulumi.IntInput) ServiceVolumeConfigurationOutput

func (ServiceVolumeConfigurationArrayOutput) ToServiceVolumeConfigurationArrayOutput added in v0.91.0 

func (o ServiceVolumeConfigurationArrayOutput) ToServiceVolumeConfigurationArrayOutput() ServiceVolumeConfigurationArrayOutput

func (ServiceVolumeConfigurationArrayOutput) ToServiceVolumeConfigurationArrayOutputWithContext added in v0.91.0 

func (o ServiceVolumeConfigurationArrayOutput) ToServiceVolumeConfigurationArrayOutputWithContext(ctx context.Context) ServiceVolumeConfigurationArrayOutput

type ServiceVolumeConfigurationInput added in v0.91.0 

type ServiceVolumeConfigurationInput interface {
	pulumi.Input

	ToServiceVolumeConfigurationOutput() ServiceVolumeConfigurationOutput
	ToServiceVolumeConfigurationOutputWithContext(context.Context) ServiceVolumeConfigurationOutput
}

ServiceVolumeConfigurationInput is an input type that accepts ServiceVolumeConfigurationArgs and ServiceVolumeConfigurationOutput values. You can construct a concrete instance of `ServiceVolumeConfigurationInput` via: 

ServiceVolumeConfigurationArgs{...}

type ServiceVolumeConfigurationOutput added in v0.91.0 

type ServiceVolumeConfigurationOutput struct{ *pulumi.OutputState }

The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.

func (ServiceVolumeConfigurationOutput) ElementType added in v0.91.0 

func (ServiceVolumeConfigurationOutput) ElementType() reflect.Type

func (ServiceVolumeConfigurationOutput) ManagedEbsVolume added in v0.91.0 

func (o ServiceVolumeConfigurationOutput) ManagedEbsVolume() ServiceManagedEbsVolumeConfigurationPtrOutput

The configuration for the Amazon EBS volume that Amazon ECS creates and manages on your behalf. These settings are used to create each Amazon EBS volume, with one volume created for each task in the service. The Amazon EBS volumes are visible in your account in the Amazon EC2 console once they are created.

func (ServiceVolumeConfigurationOutput) Name added in v0.91.0 

func (o ServiceVolumeConfigurationOutput) Name() pulumi.StringOutput

The name of the volume. This value must match the volume name from the “Volume“ object in the task definition.

func (ServiceVolumeConfigurationOutput) ToServiceVolumeConfigurationOutput added in v0.91.0 

func (o ServiceVolumeConfigurationOutput) ToServiceVolumeConfigurationOutput() ServiceVolumeConfigurationOutput

func (ServiceVolumeConfigurationOutput) ToServiceVolumeConfigurationOutputWithContext added in v0.91.0 

func (o ServiceVolumeConfigurationOutput) ToServiceVolumeConfigurationOutputWithContext(ctx context.Context) ServiceVolumeConfigurationOutput

type TaskDefinition 

type TaskDefinition struct {
	pulumi.CustomResourceState

	// A list of container definitions in JSON format that describe the different containers that make up your task. For more information about container definition parameters and defaults, see [Amazon ECS Task Definitions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html) in the *Amazon Elastic Container Service Developer Guide*.
	ContainerDefinitions TaskDefinitionContainerDefinitionArrayOutput `pulumi:"containerDefinitions"`
	// The number of “cpu“ units used by the task. If you use the EC2 launch type, this field is optional. Any value can be used. If you use the Fargate launch type, this field is required. You must use one of the following values. The value that you choose determines your range of valid values for the “memory“ parameter.
	//  The CPU units cannot be less than 1 vCPU when you use Windows containers on Fargate.
	//   +  256 (.25 vCPU) - Available “memory“ values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)
	//   +  512 (.5 vCPU) - Available “memory“ values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)
	//   +  1024 (1 vCPU) - Available “memory“ values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
	//   +  2048 (2 vCPU) - Available “memory“ values: 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)
	//   +  4096 (4 vCPU) - Available “memory“ values: 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)
	//   +  8192 (8 vCPU) - Available “memory“ values: 16 GB and 60 GB in 4 GB increments
	//       This option requires Linux platform “1.4.0“ or later.
	//   +  16384 (16vCPU) - Available “memory“ values: 32GB and 120 GB in 8 GB increments
	//       This option requires Linux platform “1.4.0“ or later.
	Cpu pulumi.StringPtrOutput `pulumi:"cpu"`
	// The ephemeral storage settings to use for tasks run with the task definition.
	EphemeralStorage TaskDefinitionEphemeralStoragePtrOutput `pulumi:"ephemeralStorage"`
	// The Amazon Resource Name (ARN) of the task execution role that grants the Amazon ECS container agent permission to make AWS API calls on your behalf. The task execution IAM role is required depending on the requirements of your task. For more information, see [Amazon ECS task execution IAM role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) in the *Amazon Elastic Container Service Developer Guide*.
	ExecutionRoleArn pulumi.StringPtrOutput `pulumi:"executionRoleArn"`
	// The name of a family that this task definition is registered to. Up to 255 letters (uppercase and lowercase), numbers, hyphens, and underscores are allowed.
	//  A family groups multiple versions of a task definition. Amazon ECS gives the first task definition that you registered to a family a revision number of 1. Amazon ECS gives sequential revision numbers to each task definition that you add.
	//   To use revision numbers when you update a task definition, specify this property. If you don't specify a value, CFNlong generates a new task definition each time that you update it.
	Family pulumi.StringPtrOutput `pulumi:"family"`
	// The Elastic Inference accelerators to use for the containers in the task.
	InferenceAccelerators TaskDefinitionInferenceAcceleratorArrayOutput `pulumi:"inferenceAccelerators"`
	// The IPC resource namespace to use for the containers in the task. The valid values are “host“, “task“, or “none“. If “host“ is specified, then all containers within the tasks that specified the “host“ IPC mode on the same container instance share the same IPC resources with the host Amazon EC2 instance. If “task“ is specified, all containers within the specified task share the same IPC resources. If “none“ is specified, then IPC resources within the containers of a task are private and not shared with other containers in a task or on the container instance. If no value is specified, then the IPC resource namespace sharing depends on the Docker daemon setting on the container instance. For more information, see [IPC settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#ipc-settings---ipc) in the *Docker run reference*.
	//  If the “host“ IPC mode is used, be aware that there is a heightened risk of undesired IPC namespace expose. For more information, see [Docker security](https://docs.aws.amazon.com/https://docs.docker.com/engine/security/security/).
	//  If you are setting namespaced kernel parameters using “systemControls“ for the containers in the task, the following will apply to your IPC resource namespace. For more information, see [System Controls](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   +  For tasks that use the “host“ IPC mode, IPC namespace related “systemControls“ are not supported.
	//   +  For tasks that use the “task“ IPC mode, IPC namespace related “systemControls“ will apply to all containers within a task.
	//
	//   This parameter is not supported for Windows containers or tasks run on FARGATElong.
	IpcMode pulumi.StringPtrOutput `pulumi:"ipcMode"`
	// The amount (in MiB) of memory used by the task.
	//  If your tasks runs on Amazon EC2 instances, you must specify either a task-level memory value or a container-level memory value. This field is optional and any value can be used. If a task-level memory value is specified, the container-level memory value is optional. For more information regarding container-level memory and memory reservation, see [ContainerDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html).
	//  If your tasks runs on FARGATElong, this field is required. You must use one of the following values. The value you choose determines your range of valid values for the “cpu“ parameter.
	//   +  512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available “cpu“ values: 256 (.25 vCPU)
	//   +  1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available “cpu“ values: 512 (.5 vCPU)
	//   +  2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available “cpu“ values: 1024 (1 vCPU)
	//   +  Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available “cpu“ values: 2048 (2 vCPU)
	//   +  Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available “cpu“ values: 4096 (4 vCPU)
	//   +  Between 16 GB and 60 GB in 4 GB increments - Available “cpu“ values: 8192 (8 vCPU)
	//       This option requires Linux platform “1.4.0“ or later.
	//   +  Between 32GB and 120 GB in 8 GB increments - Available “cpu“ values: 16384 (16 vCPU)
	//       This option requires Linux platform “1.4.0“ or later.
	Memory pulumi.StringPtrOutput `pulumi:"memory"`
	// The Docker networking mode to use for the containers in the task. The valid values are “none“, “bridge“, “awsvpc“, and “host“. If no network mode is specified, the default is “bridge“.
	//  For Amazon ECS tasks on Fargate, the “awsvpc“ network mode is required. For Amazon ECS tasks on Amazon EC2 Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon EC2 Windows instances, “<default>“ or “awsvpc“ can be used. If the network mode is set to “none“, you cannot specify port mappings in your container definitions, and the tasks containers do not have external connectivity. The “host“ and “awsvpc“ network modes offer the highest networking performance for containers because they use the EC2 network stack instead of the virtualized network stack provided by the “bridge“ mode.
	//  With the “host“ and “awsvpc“ network modes, exposed container ports are mapped directly to the corresponding host port (for the “host“ network mode) or the attached elastic network interface port (for the “awsvpc“ network mode), so you cannot take advantage of dynamic host port mappings.
	//   When using the “host“ network mode, you should not run containers using the root user (UID 0). It is considered best practice to use a non-root user.
	//   If the network mode is “awsvpc“, the task is allocated an elastic network interface, and you must specify a NetworkConfiguration value when you create a service or run a task with the task definition. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  If the network mode is “host“, you cannot run multiple instantiations of the same task on a single container instance when port mappings are used.
	//  For more information, see [Network settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#network-settings) in the *Docker run reference*.
	NetworkMode pulumi.StringPtrOutput `pulumi:"networkMode"`
	// The process namespace to use for the containers in the task. The valid values are “host“ or “task“. On Fargate for Linux containers, the only valid value is “task“. For example, monitoring sidecars might need “pidMode“ to access information about other containers running in the same task.
	//  If “host“ is specified, all containers within the tasks that specified the “host“ PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance.
	//  If “task“ is specified, all containers within the specified task share the same process namespace.
	//  If no value is specified, the default is a private namespace for each container. For more information, see [PID settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#pid-settings---pid) in the *Docker run reference*.
	//  If the “host“ PID mode is used, there's a heightened risk of undesired process namespace exposure. For more information, see [Docker security](https://docs.aws.amazon.com/https://docs.docker.com/engine/security/security/).
	//   This parameter is not supported for Windows containers.
	//    This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version “1.4.0“ or later (Linux). This isn't supported for Windows containers on Fargate.
	PidMode pulumi.StringPtrOutput `pulumi:"pidMode"`
	// An array of placement constraint objects to use for tasks.
	//   This parameter isn't supported for tasks run on FARGATElong.
	PlacementConstraints TaskDefinitionPlacementConstraintArrayOutput `pulumi:"placementConstraints"`
	// The configuration details for the App Mesh proxy.
	//  Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the “ecs-init“ package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version “20190301“ or later, they contain the required versions of the container agent and “ecs-init“. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
	ProxyConfiguration TaskDefinitionProxyConfigurationPtrOutput `pulumi:"proxyConfiguration"`
	// The task launch types the task definition was validated against. The valid values are “EC2“, “FARGATE“, and “EXTERNAL“. For more information, see [Amazon ECS launch types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.
	RequiresCompatibilities pulumi.StringArrayOutput `pulumi:"requiresCompatibilities"`
	// The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
	//  When you specify a task definition in a service, this value must match the “runtimePlatform“ value of the service.
	RuntimePlatform TaskDefinitionRuntimePlatformPtrOutput `pulumi:"runtimePlatform"`
	// The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags              aws.TagArrayOutput  `pulumi:"tags"`
	TaskDefinitionArn pulumi.StringOutput `pulumi:"taskDefinitionArn"`
	// The short name or full Amazon Resource Name (ARN) of the IAMlong role that grants containers in the task permission to call AWS APIs on your behalf. For more information, see [Amazon ECS Task Role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  IAM roles for tasks on Windows require that the “-EnableTaskIAMRole“ option is set when you launch the Amazon ECS-optimized Windows AMI. Your containers must also run some configuration code to use the feature. For more information, see [Windows IAM roles for tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html) in the *Amazon Elastic Container Service Developer Guide*.
	TaskRoleArn pulumi.StringPtrOutput `pulumi:"taskRoleArn"`
	// The list of data volume definitions for the task. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   The “host“ and “sourcePath“ parameters aren't supported for tasks run on FARGATElong.
	Volumes TaskDefinitionVolumeArrayOutput `pulumi:"volumes"`
}

Registers a new task definition from the supplied “family“ and “containerDefinitions“. Optionally, you can add data volumes to your containers with the “volumes“ parameter. For more information about task definition parameters and defaults, see [Amazon ECS Task Definitions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html) in the *Amazon Elastic Container Service Developer Guide*. 

You can specify a role for your task with the ``taskRoleArn`` parameter. When you specify a role for a task, its containers can then use the latest versions of the CLI or SDKs to make API requests to the AWS services that are specified in the policy that's associated with the role. For more information, see [IAM Roles for Tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) in the *Amazon Elastic Container Service Developer Guide*.
You can specify a Docker networking mode for the containers in your task definition with the ``networkMode`` parameter. The available network modes correspond to those described in [Network settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#/network-settings) in the Docker run reference. If you specify the ``awsvpc`` network mode, the task is allocated an elastic network interface, and you must specify a NetworkConfiguration when you create a service or run a task with the task definition. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.
 In the following example or examples, the Authorization header contents (``AUTHPARAMS``) must be replaced with an AWS Signature Version 4 signature. For more information, see [Signature Version 4 Signing Process](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) in the *General Reference*.
You only need to learn how to sign HTTP requests if you intend to create them manually. When you use the [](https://docs.aws.amazon.com/cli/) or one of the [SDKs](https://docs.aws.amazon.com/tools/) to make requests to AWS, these tools automatically sign the requests for you, with the access key that you specify when you configure the tools. When you use these tools, you don't have to sign requests yourself.

## Example Usage ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecs.NewTaskDefinition(ctx, "taskdefinition", &ecs.TaskDefinitionArgs{
			RequiresCompatibilities: pulumi.StringArray{
				pulumi.String("EC2"),
			},
			ContainerDefinitions: ecs.TaskDefinitionContainerDefinitionArray{
				&ecs.TaskDefinitionContainerDefinitionArgs{
					Name: pulumi.String("my-app"),
					MountPoints: ecs.TaskDefinitionMountPointArray{
						&ecs.TaskDefinitionMountPointArgs{
							SourceVolume:  pulumi.String("my-vol"),
							ContainerPath: pulumi.String("/var/www/my-vol"),
						},
					},
					Image: pulumi.String("amazon/amazon-ecs-sample"),
					Cpu:   pulumi.Int(256),
					EntryPoint: pulumi.StringArray{
						pulumi.String("/usr/sbin/apache2"),
						pulumi.String("-D"),
						pulumi.String("FOREGROUND"),
					},
					Memory:    pulumi.Int(512),
					Essential: pulumi.Bool(true),
				},
				&ecs.TaskDefinitionContainerDefinitionArgs{
					Name:  pulumi.String("busybox"),
					Image: pulumi.String("busybox"),
					Cpu:   pulumi.Int(256),
					EntryPoint: pulumi.StringArray{
						pulumi.String("sh"),
						pulumi.String("-c"),
					},
					Memory: pulumi.Int(512),
					Command: pulumi.StringArray{
						pulumi.String("/bin/sh -c \"while true; do /bin/date > /var/www/my-vol/date; sleep 1; done\""),
					},
					Essential: pulumi.Bool(false),
					DependsOn: ecs.TaskDefinitionContainerDependencyArray{
						&ecs.TaskDefinitionContainerDependencyArgs{
							ContainerName: pulumi.String("my-app"),
							Condition:     pulumi.String("START"),
						},
					},
					VolumesFrom: ecs.TaskDefinitionVolumeFromArray{
						&ecs.TaskDefinitionVolumeFromArgs{
							SourceContainer: pulumi.String("my-app"),
						},
					},
				},
			},
			Volumes: ecs.TaskDefinitionVolumeArray{
				&ecs.TaskDefinitionVolumeArgs{
					Host: &ecs.TaskDefinitionHostVolumePropertiesArgs{
						SourcePath: pulumi.String("/var/lib/docker/vfs/dir/"),
					},
					Name: pulumi.String("my-vol"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := ecs.NewTaskDefinition(ctx, "taskdefinition", &ecs.TaskDefinitionArgs{
			RequiresCompatibilities: pulumi.StringArray{
				pulumi.String("EC2"),
			},
			ContainerDefinitions: ecs.TaskDefinitionContainerDefinitionArray{
				&ecs.TaskDefinitionContainerDefinitionArgs{
					Name: pulumi.String("my-app"),
					MountPoints: ecs.TaskDefinitionMountPointArray{
						&ecs.TaskDefinitionMountPointArgs{
							SourceVolume:  pulumi.String("my-vol"),
							ContainerPath: pulumi.String("/var/www/my-vol"),
						},
					},
					Image: pulumi.String("amazon/amazon-ecs-sample"),
					Cpu:   pulumi.Int(256),
					EntryPoint: pulumi.StringArray{
						pulumi.String("/usr/sbin/apache2"),
						pulumi.String("-D"),
						pulumi.String("FOREGROUND"),
					},
					Memory:    pulumi.Int(512),
					Essential: pulumi.Bool(true),
				},
				&ecs.TaskDefinitionContainerDefinitionArgs{
					Name:  pulumi.String("busybox"),
					Image: pulumi.String("busybox"),
					Cpu:   pulumi.Int(256),
					EntryPoint: pulumi.StringArray{
						pulumi.String("sh"),
						pulumi.String("-c"),
					},
					Memory: pulumi.Int(512),
					Command: pulumi.StringArray{
						pulumi.String("/bin/sh -c \"while true; do /bin/date > /var/www/my-vol/date; sleep 1; done\""),
					},
					Essential: pulumi.Bool(false),
					DependsOn: ecs.TaskDefinitionContainerDependencyArray{
						&ecs.TaskDefinitionContainerDependencyArgs{
							ContainerName: pulumi.String("my-app"),
							Condition:     pulumi.String("START"),
						},
					},
					VolumesFrom: ecs.TaskDefinitionVolumeFromArray{
						&ecs.TaskDefinitionVolumeFromArgs{
							SourceContainer: pulumi.String("my-app"),
						},
					},
				},
			},
			Volumes: ecs.TaskDefinitionVolumeArray{
				&ecs.TaskDefinitionVolumeArgs{
					Host: &ecs.TaskDefinitionHostVolumePropertiesArgs{
						SourcePath: pulumi.String("/var/lib/docker/vfs/dir/"),
					},
					Name: pulumi.String("my-vol"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ecsTaskDefinitionResource, err := ecs.NewTaskDefinition(ctx, "ecsTaskDefinitionResource", &ecs.TaskDefinitionArgs{
			ContainerDefinitions: ecs.TaskDefinitionContainerDefinitionArray{
				&ecs.TaskDefinitionContainerDefinitionArgs{
					Name:      pulumi.String("first-run-task"),
					Image:     pulumi.String("httpd:2.4"),
					Essential: pulumi.Bool(true),
					PortMappings: ecs.TaskDefinitionPortMappingArray{
						&ecs.TaskDefinitionPortMappingArgs{
							ContainerPort: pulumi.Int(80),
							Protocol:      pulumi.String("tcp"),
						},
					},
					Environment: ecs.TaskDefinitionKeyValuePairArray{
						&ecs.TaskDefinitionKeyValuePairArgs{
							Name:  pulumi.String("entryPoint"),
							Value: pulumi.String("sh, -c"),
						},
						&ecs.TaskDefinitionKeyValuePairArgs{
							Name:  pulumi.String("command"),
							Value: pulumi.String("/bin/sh -c \\\"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\\\""),
						},
					},
					EnvironmentFiles: ecs.TaskDefinitionEnvironmentFileArray{},
				},
			},
			Family: pulumi.String("first-run-task"),
			Cpu:    pulumi.String("1 vCPU"),
			Memory: pulumi.String("3 GB"),
		})
		if err != nil {
			return err
		}
		ctx.Export("ecsTaskDefinition", ecsTaskDefinitionResource.ID())
		return nil
	})
}

``` ### Example

```go package main

import ( 

"github.com/pulumi/pulumi-aws-native/sdk/go/aws/ecs"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		ecsTaskDefinitionResource, err := ecs.NewTaskDefinition(ctx, "ecsTaskDefinitionResource", &ecs.TaskDefinitionArgs{
			ContainerDefinitions: ecs.TaskDefinitionContainerDefinitionArray{
				&ecs.TaskDefinitionContainerDefinitionArgs{
					Name:      pulumi.String("first-run-task"),
					Image:     pulumi.String("httpd:2.4"),
					Essential: pulumi.Bool(true),
					PortMappings: ecs.TaskDefinitionPortMappingArray{
						&ecs.TaskDefinitionPortMappingArgs{
							ContainerPort: pulumi.Int(80),
							Protocol:      pulumi.String("tcp"),
						},
					},
					Environment: ecs.TaskDefinitionKeyValuePairArray{
						&ecs.TaskDefinitionKeyValuePairArgs{
							Name:  pulumi.String("entryPoint"),
							Value: pulumi.String("sh, -c"),
						},
						&ecs.TaskDefinitionKeyValuePairArgs{
							Name:  pulumi.String("command"),
							Value: pulumi.String("/bin/sh -c \\\"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\\\""),
						},
					},
					EnvironmentFiles: ecs.TaskDefinitionEnvironmentFileArray{},
				},
			},
			Family: pulumi.String("first-run-task"),
			Cpu:    pulumi.String("1 vCPU"),
			Memory: pulumi.String("3 GB"),
		})
		if err != nil {
			return err
		}
		ctx.Export("ecsTaskDefinition", ecsTaskDefinitionResource.ID())
		return nil
	})
}

```

func GetTaskDefinition 

func GetTaskDefinition(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TaskDefinitionState, opts ...pulumi.ResourceOption) (*TaskDefinition, error)

GetTaskDefinition gets an existing TaskDefinition 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 NewTaskDefinition 

func NewTaskDefinition(ctx *pulumi.Context,
	name string, args *TaskDefinitionArgs, opts ...pulumi.ResourceOption) (*TaskDefinition, error)

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

func (*TaskDefinition) ElementType 

func (*TaskDefinition) ElementType() reflect.Type

func (*TaskDefinition) ToTaskDefinitionOutput 

func (i *TaskDefinition) ToTaskDefinitionOutput() TaskDefinitionOutput

func (*TaskDefinition) ToTaskDefinitionOutputWithContext 

func (i *TaskDefinition) ToTaskDefinitionOutputWithContext(ctx context.Context) TaskDefinitionOutput

type TaskDefinitionArgs 

type TaskDefinitionArgs struct {
	// A list of container definitions in JSON format that describe the different containers that make up your task. For more information about container definition parameters and defaults, see [Amazon ECS Task Definitions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html) in the *Amazon Elastic Container Service Developer Guide*.
	ContainerDefinitions TaskDefinitionContainerDefinitionArrayInput
	// The number of “cpu“ units used by the task. If you use the EC2 launch type, this field is optional. Any value can be used. If you use the Fargate launch type, this field is required. You must use one of the following values. The value that you choose determines your range of valid values for the “memory“ parameter.
	//  The CPU units cannot be less than 1 vCPU when you use Windows containers on Fargate.
	//   +  256 (.25 vCPU) - Available “memory“ values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)
	//   +  512 (.5 vCPU) - Available “memory“ values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)
	//   +  1024 (1 vCPU) - Available “memory“ values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
	//   +  2048 (2 vCPU) - Available “memory“ values: 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)
	//   +  4096 (4 vCPU) - Available “memory“ values: 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)
	//   +  8192 (8 vCPU) - Available “memory“ values: 16 GB and 60 GB in 4 GB increments
	//       This option requires Linux platform “1.4.0“ or later.
	//   +  16384 (16vCPU) - Available “memory“ values: 32GB and 120 GB in 8 GB increments
	//       This option requires Linux platform “1.4.0“ or later.
	Cpu pulumi.StringPtrInput
	// The ephemeral storage settings to use for tasks run with the task definition.
	EphemeralStorage TaskDefinitionEphemeralStoragePtrInput
	// The Amazon Resource Name (ARN) of the task execution role that grants the Amazon ECS container agent permission to make AWS API calls on your behalf. The task execution IAM role is required depending on the requirements of your task. For more information, see [Amazon ECS task execution IAM role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) in the *Amazon Elastic Container Service Developer Guide*.
	ExecutionRoleArn pulumi.StringPtrInput
	// The name of a family that this task definition is registered to. Up to 255 letters (uppercase and lowercase), numbers, hyphens, and underscores are allowed.
	//  A family groups multiple versions of a task definition. Amazon ECS gives the first task definition that you registered to a family a revision number of 1. Amazon ECS gives sequential revision numbers to each task definition that you add.
	//   To use revision numbers when you update a task definition, specify this property. If you don't specify a value, CFNlong generates a new task definition each time that you update it.
	Family pulumi.StringPtrInput
	// The Elastic Inference accelerators to use for the containers in the task.
	InferenceAccelerators TaskDefinitionInferenceAcceleratorArrayInput
	// The IPC resource namespace to use for the containers in the task. The valid values are “host“, “task“, or “none“. If “host“ is specified, then all containers within the tasks that specified the “host“ IPC mode on the same container instance share the same IPC resources with the host Amazon EC2 instance. If “task“ is specified, all containers within the specified task share the same IPC resources. If “none“ is specified, then IPC resources within the containers of a task are private and not shared with other containers in a task or on the container instance. If no value is specified, then the IPC resource namespace sharing depends on the Docker daemon setting on the container instance. For more information, see [IPC settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#ipc-settings---ipc) in the *Docker run reference*.
	//  If the “host“ IPC mode is used, be aware that there is a heightened risk of undesired IPC namespace expose. For more information, see [Docker security](https://docs.aws.amazon.com/https://docs.docker.com/engine/security/security/).
	//  If you are setting namespaced kernel parameters using “systemControls“ for the containers in the task, the following will apply to your IPC resource namespace. For more information, see [System Controls](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   +  For tasks that use the “host“ IPC mode, IPC namespace related “systemControls“ are not supported.
	//   +  For tasks that use the “task“ IPC mode, IPC namespace related “systemControls“ will apply to all containers within a task.
	//
	//   This parameter is not supported for Windows containers or tasks run on FARGATElong.
	IpcMode pulumi.StringPtrInput
	// The amount (in MiB) of memory used by the task.
	//  If your tasks runs on Amazon EC2 instances, you must specify either a task-level memory value or a container-level memory value. This field is optional and any value can be used. If a task-level memory value is specified, the container-level memory value is optional. For more information regarding container-level memory and memory reservation, see [ContainerDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html).
	//  If your tasks runs on FARGATElong, this field is required. You must use one of the following values. The value you choose determines your range of valid values for the “cpu“ parameter.
	//   +  512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available “cpu“ values: 256 (.25 vCPU)
	//   +  1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available “cpu“ values: 512 (.5 vCPU)
	//   +  2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available “cpu“ values: 1024 (1 vCPU)
	//   +  Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available “cpu“ values: 2048 (2 vCPU)
	//   +  Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available “cpu“ values: 4096 (4 vCPU)
	//   +  Between 16 GB and 60 GB in 4 GB increments - Available “cpu“ values: 8192 (8 vCPU)
	//       This option requires Linux platform “1.4.0“ or later.
	//   +  Between 32GB and 120 GB in 8 GB increments - Available “cpu“ values: 16384 (16 vCPU)
	//       This option requires Linux platform “1.4.0“ or later.
	Memory pulumi.StringPtrInput
	// The Docker networking mode to use for the containers in the task. The valid values are “none“, “bridge“, “awsvpc“, and “host“. If no network mode is specified, the default is “bridge“.
	//  For Amazon ECS tasks on Fargate, the “awsvpc“ network mode is required. For Amazon ECS tasks on Amazon EC2 Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon EC2 Windows instances, “<default>“ or “awsvpc“ can be used. If the network mode is set to “none“, you cannot specify port mappings in your container definitions, and the tasks containers do not have external connectivity. The “host“ and “awsvpc“ network modes offer the highest networking performance for containers because they use the EC2 network stack instead of the virtualized network stack provided by the “bridge“ mode.
	//  With the “host“ and “awsvpc“ network modes, exposed container ports are mapped directly to the corresponding host port (for the “host“ network mode) or the attached elastic network interface port (for the “awsvpc“ network mode), so you cannot take advantage of dynamic host port mappings.
	//   When using the “host“ network mode, you should not run containers using the root user (UID 0). It is considered best practice to use a non-root user.
	//   If the network mode is “awsvpc“, the task is allocated an elastic network interface, and you must specify a NetworkConfiguration value when you create a service or run a task with the task definition. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  If the network mode is “host“, you cannot run multiple instantiations of the same task on a single container instance when port mappings are used.
	//  For more information, see [Network settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#network-settings) in the *Docker run reference*.
	NetworkMode pulumi.StringPtrInput
	// The process namespace to use for the containers in the task. The valid values are “host“ or “task“. On Fargate for Linux containers, the only valid value is “task“. For example, monitoring sidecars might need “pidMode“ to access information about other containers running in the same task.
	//  If “host“ is specified, all containers within the tasks that specified the “host“ PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance.
	//  If “task“ is specified, all containers within the specified task share the same process namespace.
	//  If no value is specified, the default is a private namespace for each container. For more information, see [PID settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#pid-settings---pid) in the *Docker run reference*.
	//  If the “host“ PID mode is used, there's a heightened risk of undesired process namespace exposure. For more information, see [Docker security](https://docs.aws.amazon.com/https://docs.docker.com/engine/security/security/).
	//   This parameter is not supported for Windows containers.
	//    This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version “1.4.0“ or later (Linux). This isn't supported for Windows containers on Fargate.
	PidMode pulumi.StringPtrInput
	// An array of placement constraint objects to use for tasks.
	//   This parameter isn't supported for tasks run on FARGATElong.
	PlacementConstraints TaskDefinitionPlacementConstraintArrayInput
	// The configuration details for the App Mesh proxy.
	//  Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the “ecs-init“ package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version “20190301“ or later, they contain the required versions of the container agent and “ecs-init“. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
	ProxyConfiguration TaskDefinitionProxyConfigurationPtrInput
	// The task launch types the task definition was validated against. The valid values are “EC2“, “FARGATE“, and “EXTERNAL“. For more information, see [Amazon ECS launch types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.
	RequiresCompatibilities pulumi.StringArrayInput
	// The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
	//  When you specify a task definition in a service, this value must match the “runtimePlatform“ value of the service.
	RuntimePlatform TaskDefinitionRuntimePlatformPtrInput
	// The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them.
	//  The following basic restrictions apply to tags:
	//   +  Maximum number of tags per resource - 50
	//   +  For each resource, each tag key must be unique, and each tag key can have only one value.
	//   +  Maximum key length - 128 Unicode characters in UTF-8
	//   +  Maximum value length - 256 Unicode characters in UTF-8
	//   +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
	//   +  Tag keys and values are case-sensitive.
	//   +  Do not use “aws:“, “AWS:“, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.
	Tags aws.TagArrayInput
	// The short name or full Amazon Resource Name (ARN) of the IAMlong role that grants containers in the task permission to call AWS APIs on your behalf. For more information, see [Amazon ECS Task Role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  IAM roles for tasks on Windows require that the “-EnableTaskIAMRole“ option is set when you launch the Amazon ECS-optimized Windows AMI. Your containers must also run some configuration code to use the feature. For more information, see [Windows IAM roles for tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html) in the *Amazon Elastic Container Service Developer Guide*.
	TaskRoleArn pulumi.StringPtrInput
	// The list of data volume definitions for the task. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   The “host“ and “sourcePath“ parameters aren't supported for tasks run on FARGATElong.
	Volumes TaskDefinitionVolumeArrayInput
}

The set of arguments for constructing a TaskDefinition resource.

func (TaskDefinitionArgs) ElementType 

func (TaskDefinitionArgs) ElementType() reflect.Type

type TaskDefinitionAuthorizationConfig 

type TaskDefinitionAuthorizationConfig struct {
	// The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the “EFSVolumeConfiguration“ must either be omitted or set to “/“ which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the “EFSVolumeConfiguration“. For more information, see [Working with Amazon EFS access points](https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html) in the *Amazon Elastic File System User Guide*.
	AccessPointId *string `pulumi:"accessPointId"`
	// Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the “EFSVolumeConfiguration“. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Using Amazon EFS access points](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints) in the *Amazon Elastic Container Service Developer Guide*.
	Iam *TaskDefinitionAuthorizationConfigIam `pulumi:"iam"`
}

The authorization configuration details for the Amazon EFS file system.

type TaskDefinitionAuthorizationConfigArgs 

type TaskDefinitionAuthorizationConfigArgs struct {
	// The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the “EFSVolumeConfiguration“ must either be omitted or set to “/“ which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the “EFSVolumeConfiguration“. For more information, see [Working with Amazon EFS access points](https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html) in the *Amazon Elastic File System User Guide*.
	AccessPointId pulumi.StringPtrInput `pulumi:"accessPointId"`
	// Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the “EFSVolumeConfiguration“. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Using Amazon EFS access points](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints) in the *Amazon Elastic Container Service Developer Guide*.
	Iam TaskDefinitionAuthorizationConfigIamPtrInput `pulumi:"iam"`
}

The authorization configuration details for the Amazon EFS file system.

func (TaskDefinitionAuthorizationConfigArgs) ElementType 

func (TaskDefinitionAuthorizationConfigArgs) ElementType() reflect.Type

func (TaskDefinitionAuthorizationConfigArgs) ToTaskDefinitionAuthorizationConfigOutput 

func (i TaskDefinitionAuthorizationConfigArgs) ToTaskDefinitionAuthorizationConfigOutput() TaskDefinitionAuthorizationConfigOutput

func (TaskDefinitionAuthorizationConfigArgs) ToTaskDefinitionAuthorizationConfigOutputWithContext 

func (i TaskDefinitionAuthorizationConfigArgs) ToTaskDefinitionAuthorizationConfigOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigOutput

func (TaskDefinitionAuthorizationConfigArgs) ToTaskDefinitionAuthorizationConfigPtrOutput 

func (i TaskDefinitionAuthorizationConfigArgs) ToTaskDefinitionAuthorizationConfigPtrOutput() TaskDefinitionAuthorizationConfigPtrOutput

func (TaskDefinitionAuthorizationConfigArgs) ToTaskDefinitionAuthorizationConfigPtrOutputWithContext 

func (i TaskDefinitionAuthorizationConfigArgs) ToTaskDefinitionAuthorizationConfigPtrOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigPtrOutput

type TaskDefinitionAuthorizationConfigIam added in v0.72.0 

type TaskDefinitionAuthorizationConfigIam string

Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the “EFSVolumeConfiguration“. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Using Amazon EFS access points](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionAuthorizationConfigIam) ElementType added in v0.72.0 

func (TaskDefinitionAuthorizationConfigIam) ElementType() reflect.Type

func (TaskDefinitionAuthorizationConfigIam) ToStringOutput added in v0.72.0 

func (e TaskDefinitionAuthorizationConfigIam) ToStringOutput() pulumi.StringOutput

func (TaskDefinitionAuthorizationConfigIam) ToStringOutputWithContext added in v0.72.0 

func (e TaskDefinitionAuthorizationConfigIam) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskDefinitionAuthorizationConfigIam) ToStringPtrOutput added in v0.72.0 

func (e TaskDefinitionAuthorizationConfigIam) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionAuthorizationConfigIam) ToStringPtrOutputWithContext added in v0.72.0 

func (e TaskDefinitionAuthorizationConfigIam) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionAuthorizationConfigIam) ToTaskDefinitionAuthorizationConfigIamOutput added in v0.72.0 

func (e TaskDefinitionAuthorizationConfigIam) ToTaskDefinitionAuthorizationConfigIamOutput() TaskDefinitionAuthorizationConfigIamOutput

func (TaskDefinitionAuthorizationConfigIam) ToTaskDefinitionAuthorizationConfigIamOutputWithContext added in v0.72.0 

func (e TaskDefinitionAuthorizationConfigIam) ToTaskDefinitionAuthorizationConfigIamOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigIamOutput

func (TaskDefinitionAuthorizationConfigIam) ToTaskDefinitionAuthorizationConfigIamPtrOutput added in v0.72.0 

func (e TaskDefinitionAuthorizationConfigIam) ToTaskDefinitionAuthorizationConfigIamPtrOutput() TaskDefinitionAuthorizationConfigIamPtrOutput

func (TaskDefinitionAuthorizationConfigIam) ToTaskDefinitionAuthorizationConfigIamPtrOutputWithContext added in v0.72.0 

func (e TaskDefinitionAuthorizationConfigIam) ToTaskDefinitionAuthorizationConfigIamPtrOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigIamPtrOutput

type TaskDefinitionAuthorizationConfigIamInput added in v0.72.0 

type TaskDefinitionAuthorizationConfigIamInput interface {
	pulumi.Input

	ToTaskDefinitionAuthorizationConfigIamOutput() TaskDefinitionAuthorizationConfigIamOutput
	ToTaskDefinitionAuthorizationConfigIamOutputWithContext(context.Context) TaskDefinitionAuthorizationConfigIamOutput
}

TaskDefinitionAuthorizationConfigIamInput is an input type that accepts values of the TaskDefinitionAuthorizationConfigIam enum A concrete instance of `TaskDefinitionAuthorizationConfigIamInput` can be one of the following: 

TaskDefinitionAuthorizationConfigIamEnabled
TaskDefinitionAuthorizationConfigIamDisabled

type TaskDefinitionAuthorizationConfigIamOutput added in v0.72.0 

type TaskDefinitionAuthorizationConfigIamOutput struct{ *pulumi.OutputState }

func (TaskDefinitionAuthorizationConfigIamOutput) ElementType added in v0.72.0 

func (TaskDefinitionAuthorizationConfigIamOutput) ElementType() reflect.Type

func (TaskDefinitionAuthorizationConfigIamOutput) ToStringOutput added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamOutput) ToStringOutput() pulumi.StringOutput

func (TaskDefinitionAuthorizationConfigIamOutput) ToStringOutputWithContext added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskDefinitionAuthorizationConfigIamOutput) ToStringPtrOutput added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionAuthorizationConfigIamOutput) ToStringPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionAuthorizationConfigIamOutput) ToTaskDefinitionAuthorizationConfigIamOutput added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamOutput) ToTaskDefinitionAuthorizationConfigIamOutput() TaskDefinitionAuthorizationConfigIamOutput

func (TaskDefinitionAuthorizationConfigIamOutput) ToTaskDefinitionAuthorizationConfigIamOutputWithContext added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamOutput) ToTaskDefinitionAuthorizationConfigIamOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigIamOutput

func (TaskDefinitionAuthorizationConfigIamOutput) ToTaskDefinitionAuthorizationConfigIamPtrOutput added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamOutput) ToTaskDefinitionAuthorizationConfigIamPtrOutput() TaskDefinitionAuthorizationConfigIamPtrOutput

func (TaskDefinitionAuthorizationConfigIamOutput) ToTaskDefinitionAuthorizationConfigIamPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamOutput) ToTaskDefinitionAuthorizationConfigIamPtrOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigIamPtrOutput

type TaskDefinitionAuthorizationConfigIamPtrInput added in v0.72.0 

type TaskDefinitionAuthorizationConfigIamPtrInput interface {
	pulumi.Input

	ToTaskDefinitionAuthorizationConfigIamPtrOutput() TaskDefinitionAuthorizationConfigIamPtrOutput
	ToTaskDefinitionAuthorizationConfigIamPtrOutputWithContext(context.Context) TaskDefinitionAuthorizationConfigIamPtrOutput
}

func TaskDefinitionAuthorizationConfigIamPtr added in v0.72.0 

func TaskDefinitionAuthorizationConfigIamPtr(v string) TaskDefinitionAuthorizationConfigIamPtrInput

type TaskDefinitionAuthorizationConfigIamPtrOutput added in v0.72.0 

type TaskDefinitionAuthorizationConfigIamPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionAuthorizationConfigIamPtrOutput) Elem added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamPtrOutput) Elem() TaskDefinitionAuthorizationConfigIamOutput

func (TaskDefinitionAuthorizationConfigIamPtrOutput) ElementType added in v0.72.0 

func (TaskDefinitionAuthorizationConfigIamPtrOutput) ElementType() reflect.Type

func (TaskDefinitionAuthorizationConfigIamPtrOutput) ToStringPtrOutput added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionAuthorizationConfigIamPtrOutput) ToStringPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionAuthorizationConfigIamPtrOutput) ToTaskDefinitionAuthorizationConfigIamPtrOutput added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamPtrOutput) ToTaskDefinitionAuthorizationConfigIamPtrOutput() TaskDefinitionAuthorizationConfigIamPtrOutput

func (TaskDefinitionAuthorizationConfigIamPtrOutput) ToTaskDefinitionAuthorizationConfigIamPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigIamPtrOutput) ToTaskDefinitionAuthorizationConfigIamPtrOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigIamPtrOutput

type TaskDefinitionAuthorizationConfigInput 

type TaskDefinitionAuthorizationConfigInput interface {
	pulumi.Input

	ToTaskDefinitionAuthorizationConfigOutput() TaskDefinitionAuthorizationConfigOutput
	ToTaskDefinitionAuthorizationConfigOutputWithContext(context.Context) TaskDefinitionAuthorizationConfigOutput
}

TaskDefinitionAuthorizationConfigInput is an input type that accepts TaskDefinitionAuthorizationConfigArgs and TaskDefinitionAuthorizationConfigOutput values. You can construct a concrete instance of `TaskDefinitionAuthorizationConfigInput` via: 

TaskDefinitionAuthorizationConfigArgs{...}

type TaskDefinitionAuthorizationConfigOutput 

type TaskDefinitionAuthorizationConfigOutput struct{ *pulumi.OutputState }

The authorization configuration details for the Amazon EFS file system.

func (TaskDefinitionAuthorizationConfigOutput) AccessPointId 

func (o TaskDefinitionAuthorizationConfigOutput) AccessPointId() pulumi.StringPtrOutput

The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the “EFSVolumeConfiguration“ must either be omitted or set to “/“ which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the “EFSVolumeConfiguration“. For more information, see [Working with Amazon EFS access points](https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html) in the *Amazon Elastic File System User Guide*.

func (TaskDefinitionAuthorizationConfigOutput) ElementType 

func (TaskDefinitionAuthorizationConfigOutput) ElementType() reflect.Type

func (TaskDefinitionAuthorizationConfigOutput) Iam added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigOutput) Iam() TaskDefinitionAuthorizationConfigIamPtrOutput

Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the “EFSVolumeConfiguration“. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Using Amazon EFS access points](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionAuthorizationConfigOutput) ToTaskDefinitionAuthorizationConfigOutput 

func (o TaskDefinitionAuthorizationConfigOutput) ToTaskDefinitionAuthorizationConfigOutput() TaskDefinitionAuthorizationConfigOutput

func (TaskDefinitionAuthorizationConfigOutput) ToTaskDefinitionAuthorizationConfigOutputWithContext 

func (o TaskDefinitionAuthorizationConfigOutput) ToTaskDefinitionAuthorizationConfigOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigOutput

func (TaskDefinitionAuthorizationConfigOutput) ToTaskDefinitionAuthorizationConfigPtrOutput 

func (o TaskDefinitionAuthorizationConfigOutput) ToTaskDefinitionAuthorizationConfigPtrOutput() TaskDefinitionAuthorizationConfigPtrOutput

func (TaskDefinitionAuthorizationConfigOutput) ToTaskDefinitionAuthorizationConfigPtrOutputWithContext 

func (o TaskDefinitionAuthorizationConfigOutput) ToTaskDefinitionAuthorizationConfigPtrOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigPtrOutput

type TaskDefinitionAuthorizationConfigPtrInput 

type TaskDefinitionAuthorizationConfigPtrInput interface {
	pulumi.Input

	ToTaskDefinitionAuthorizationConfigPtrOutput() TaskDefinitionAuthorizationConfigPtrOutput
	ToTaskDefinitionAuthorizationConfigPtrOutputWithContext(context.Context) TaskDefinitionAuthorizationConfigPtrOutput
}

TaskDefinitionAuthorizationConfigPtrInput is an input type that accepts TaskDefinitionAuthorizationConfigArgs, TaskDefinitionAuthorizationConfigPtr and TaskDefinitionAuthorizationConfigPtrOutput values. You can construct a concrete instance of `TaskDefinitionAuthorizationConfigPtrInput` via: 

        TaskDefinitionAuthorizationConfigArgs{...}

or:

        nil

func TaskDefinitionAuthorizationConfigPtr 

func TaskDefinitionAuthorizationConfigPtr(v *TaskDefinitionAuthorizationConfigArgs) TaskDefinitionAuthorizationConfigPtrInput

type TaskDefinitionAuthorizationConfigPtrOutput 

type TaskDefinitionAuthorizationConfigPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionAuthorizationConfigPtrOutput) AccessPointId 

func (o TaskDefinitionAuthorizationConfigPtrOutput) AccessPointId() pulumi.StringPtrOutput

The Amazon EFS access point ID to use. If an access point is specified, the root directory value specified in the “EFSVolumeConfiguration“ must either be omitted or set to “/“ which will enforce the path set on the EFS access point. If an access point is used, transit encryption must be on in the “EFSVolumeConfiguration“. For more information, see [Working with Amazon EFS access points](https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html) in the *Amazon Elastic File System User Guide*.

func (TaskDefinitionAuthorizationConfigPtrOutput) Elem 

func (o TaskDefinitionAuthorizationConfigPtrOutput) Elem() TaskDefinitionAuthorizationConfigOutput

func (TaskDefinitionAuthorizationConfigPtrOutput) ElementType 

func (TaskDefinitionAuthorizationConfigPtrOutput) ElementType() reflect.Type

func (TaskDefinitionAuthorizationConfigPtrOutput) Iam added in v0.72.0 

func (o TaskDefinitionAuthorizationConfigPtrOutput) Iam() TaskDefinitionAuthorizationConfigIamPtrOutput

Determines whether to use the Amazon ECS task role defined in a task definition when mounting the Amazon EFS file system. If it is turned on, transit encryption must be turned on in the “EFSVolumeConfiguration“. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Using Amazon EFS access points](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html#efs-volume-accesspoints) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionAuthorizationConfigPtrOutput) ToTaskDefinitionAuthorizationConfigPtrOutput 

func (o TaskDefinitionAuthorizationConfigPtrOutput) ToTaskDefinitionAuthorizationConfigPtrOutput() TaskDefinitionAuthorizationConfigPtrOutput

func (TaskDefinitionAuthorizationConfigPtrOutput) ToTaskDefinitionAuthorizationConfigPtrOutputWithContext 

func (o TaskDefinitionAuthorizationConfigPtrOutput) ToTaskDefinitionAuthorizationConfigPtrOutputWithContext(ctx context.Context) TaskDefinitionAuthorizationConfigPtrOutput

type TaskDefinitionContainerDefinition 

type TaskDefinitionContainerDefinition struct {
	// The command that's passed to the container. This parameter maps to “Cmd“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “COMMAND“ parameter to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For more information, see [https://docs.docker.com/engine/reference/builder/#cmd](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/builder/#cmd). If there are multiple arguments, each argument is a separated string in the array.
	Command []string `pulumi:"command"`
	// The number of “cpu“ units reserved for the container. This parameter maps to “CpuShares“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cpu-shares“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level “cpu“ value.
	//   You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
	//   Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
	//  On Linux container instances, the Docker daemon on the container instance uses the CPU value to calculate the relative CPU share ratios for running containers. For more information, see [CPU share constraint](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#cpu-share-constraint) in the Docker documentation. The minimum valid CPU share value that the Linux kernel allows is 2. However, the CPU parameter isn't required, and you can use CPU values below 2 in your container definitions. For CPU values below 2 (including null), the behavior varies based on your Amazon ECS container agent version:
	//   +   *Agent versions less than or equal to 1.1.0:* Null and zero CPU values are passed to Docker as 0, which Docker then converts to 1,024 CPU shares. CPU values of 1 are passed to Docker as 1, which the Linux kernel converts to two CPU shares.
	//   +   *Agent versions greater than or equal to 1.2.0:* Null, zero, and CPU values of 1 are passed to Docker as 2.
	//
	//  On Windows container instances, the CPU limit is enforced as an absolute limit, or a quota. Windows containers only have access to the specified amount of CPU that's described in the task definition. A null or zero CPU value is passed to Docker as “0“, which Windows interprets as 1% of one CPU.
	Cpu *int `pulumi:"cpu"`
	// A list of ARNs in SSM or Amazon S3 to a credential spec (“CredSpec“) file that configures the container for Active Directory authentication. We recommend that you use this parameter instead of the “dockerSecurityOptions“. The maximum number of ARNs is 1.
	//  There are two formats for each ARN.
	//   + credentialspecdomainless:MyARN You use credentialspecdomainless:MyARN to provide a CredSpec with an additional section for a secret in . You provide the login credentials to the domain in the secret. Each task that runs on any container instance can join different domains. You can use this format without joining the container instance to a domain. + credentialspec:MyARN You use credentialspec:MyARN to provide a CredSpec for a single domain. You must join the container instance to the domain before you start any tasks that use this task definition.
	//      In both formats, replace “MyARN“ with the ARN in SSM or Amazon S3.
	//      If you provide a “credentialspecdomainless:MyARN“, the “credspec“ must provide a ARN in ASMlong for a secret containing the username, password, and the domain to connect to. For better security, the instance isn't joined to the domain for domainless authentication. Other applications on the instance can't use the domainless credentials. You can use this parameter to run tasks on the same instance, even it the tasks need to join different domains. For more information, see [Using gMSAs for Windows Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html) and [Using gMSAs for Linux Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html).
	CredentialSpecs []string `pulumi:"credentialSpecs"`
	// The dependencies defined for container startup and shutdown. A container can contain multiple dependencies. When a dependency is defined for container startup, for container shutdown it is reversed.
	//  For tasks using the EC2 launch type, the container instances require at least version 1.26.0 of the container agent to turn on container dependencies. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the “ecs-init“ package. If your container instances are launched from version “20190301“ or later, then they contain the required versions of the container agent and “ecs-init“. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  For tasks using the Fargate launch type, the task or service requires the following platforms:
	//   +  Linux platform version “1.3.0“ or later.
	//   +  Windows platform version “1.0.0“ or later.
	//
	//  If the task definition is used in a blue/green deployment that uses [AWS::CodeDeploy::DeploymentGroup BlueGreenDeploymentConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codedeploy-deploymentgroup-bluegreendeploymentconfiguration.html), the “dependsOn“ parameter is not supported. For more information see [Issue #680](https://docs.aws.amazon.com/https://github.com/aws-cloudformation/cloudformation-coverage-roadmap/issues/680) on the on the GitHub website.
	DependsOn []TaskDefinitionContainerDependency `pulumi:"dependsOn"`
	// When this parameter is true, networking is off within the container. This parameter maps to “NetworkDisabled“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/).
	//   This parameter is not supported for Windows containers.
	DisableNetworking *bool `pulumi:"disableNetworking"`
	// A list of DNS search domains that are presented to the container. This parameter maps to “DnsSearch“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--dns-search“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers.
	DnsSearchDomains []string `pulumi:"dnsSearchDomains"`
	// A list of DNS servers that are presented to the container. This parameter maps to “Dns“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--dns“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers.
	DnsServers []string `pulumi:"dnsServers"`
	// A key/value map of labels to add to the container. This parameter maps to “Labels“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--label“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	DockerLabels map[string]string `pulumi:"dockerLabels"`
	// A list of strings to provide custom configuration for multiple security systems. For more information about valid values, see [Docker Run Security Configuration](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This field isn't valid for containers in tasks using the Fargate launch type.
	//  For Linux tasks on EC2, this parameter can be used to reference custom labels for SELinux and AppArmor multi-level security systems.
	//  For any tasks on EC2, this parameter can be used to reference a credential spec file that configures a container for Active Directory authentication. For more information, see [Using gMSAs for Windows Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html) and [Using gMSAs for Linux Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  This parameter maps to “SecurityOpt“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--security-opt“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   The Amazon ECS container agent running on a container instance must register with the “ECS_SELINUX_CAPABLE=true“ or “ECS_APPARMOR_CAPABLE=true“ environment variables before containers placed on that instance can use these security options. For more information, see [Amazon ECS Container Agent Configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   For more information about valid values, see [Docker Run Security Configuration](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  Valid values: "no-new-privileges" | "apparmor:PROFILE" | "label:value" | "credentialspec:CredentialSpecFilePath"
	DockerSecurityOptions []string `pulumi:"dockerSecurityOptions"`
	// Early versions of the Amazon ECS container agent don't properly handle “entryPoint“ parameters. If you have problems using “entryPoint“, update your container agent or enter your commands and arguments as “command“ array items instead.
	//   The entry point that's passed to the container. This parameter maps to “Entrypoint“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--entrypoint“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For more information, see [https://docs.docker.com/engine/reference/builder/#entrypoint](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/builder/#entrypoint).
	EntryPoint []string `pulumi:"entryPoint"`
	// The environment variables to pass to a container. This parameter maps to “Env“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--env“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   We don't recommend that you use plaintext environment variables for sensitive information, such as credential data.
	Environment []TaskDefinitionKeyValuePair `pulumi:"environment"`
	// A list of files containing the environment variables to pass to a container. This parameter maps to the “--env-file“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  You can specify up to ten environment files. The file must have a “.env“ file extension. Each line in an environment file contains an environment variable in “VARIABLE=VALUE“ format. Lines beginning with “#“ are treated as comments and are ignored. For more information about the environment variable file syntax, see [Declare default environment variables in file](https://docs.aws.amazon.com/https://docs.docker.com/compose/env-file/).
	//  If there are environment variables specified using the “environment“ parameter in a container definition, they take precedence over the variables contained within an environment file. If multiple environment files are specified that contain the same variable, they're processed from the top down. We recommend that you use unique variable names. For more information, see [Specifying Environment Variables](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html) in the *Amazon Elastic Container Service Developer Guide*.
	EnvironmentFiles []TaskDefinitionEnvironmentFile `pulumi:"environmentFiles"`
	// If the “essential“ parameter of a container is marked as “true“, and that container fails or stops for any reason, all other containers that are part of the task are stopped. If the “essential“ parameter of a container is marked as “false“, its failure doesn't affect the rest of the containers in a task. If this parameter is omitted, a container is assumed to be essential.
	//  All tasks must have at least one essential container. If you have an application that's composed of multiple containers, group containers that are used for a common purpose into components, and separate the different components into multiple task definitions. For more information, see [Application Architecture](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html) in the *Amazon Elastic Container Service Developer Guide*.
	Essential *bool `pulumi:"essential"`
	// A list of hostnames and IP address mappings to append to the “/etc/hosts“ file on the container. This parameter maps to “ExtraHosts“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--add-host“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter isn't supported for Windows containers or tasks that use the “awsvpc“ network mode.
	ExtraHosts []TaskDefinitionHostEntry `pulumi:"extraHosts"`
	// The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see [Custom Log Routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
	FirelensConfiguration *TaskDefinitionFirelensConfiguration `pulumi:"firelensConfiguration"`
	// The container health check command and associated configuration parameters for the container. This parameter maps to “HealthCheck“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “HEALTHCHECK“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	HealthCheck *TaskDefinitionHealthCheck `pulumi:"healthCheck"`
	// The hostname to use for your container. This parameter maps to “Hostname“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--hostname“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   The “hostname“ parameter is not supported if you're using the “awsvpc“ network mode.
	Hostname *string `pulumi:"hostname"`
	// The image used to start a container. This string is passed directly to the Docker daemon. By default, images in the Docker Hub registry are available. Other repositories are specified with either “repository-url/image:tag“ or “repository-url/image@digest“. Up to 255 letters (uppercase and lowercase), numbers, hyphens, underscores, colons, periods, forward slashes, and number signs are allowed. This parameter maps to “Image“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “IMAGE“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   +  When a new task starts, the Amazon ECS container agent pulls the latest version of the specified image and tag for the container to use. However, subsequent updates to a repository image aren't propagated to already running tasks.
	//   +  Images in Amazon ECR repositories can be specified by either using the full “registry/repository:tag“ or “registry/repository@digest“. For example, “012345678910.dkr.ecr.<region-name>.amazonaws.com/<repository-name>:latest“ or “012345678910.dkr.ecr.<region-name>.amazonaws.com/<repository-name>@sha256:94afd1f2e64d908bc90dbca0035a5b567EXAMPLE“.
	//   +  Images in official repositories on Docker Hub use a single name (for example, “ubuntu“ or “mongo“).
	//   +  Images in other repositories on Docker Hub are qualified with an organization name (for example, “amazon/amazon-ecs-agent“).
	//   +  Images in other online repositories are qualified further by a domain name (for example, “quay.io/assemblyline/ubuntu“).
	Image string `pulumi:"image"`
	// When this parameter is “true“, you can deploy containerized applications that require “stdin“ or a “tty“ to be allocated. This parameter maps to “OpenStdin“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--interactive“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	Interactive *bool `pulumi:"interactive"`
	// The “links“ parameter allows containers to communicate with each other without the need for port mappings. This parameter is only supported if the network mode of a task definition is “bridge“. The “name:internalName“ construct is analogous to “name:alias“ in Docker links. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. For more information about linking Docker containers, go to [Legacy container links](https://docs.aws.amazon.com/https://docs.docker.com/network/links/) in the Docker documentation. This parameter maps to “Links“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--link“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers.
	//    Containers that are collocated on a single container instance may be able to communicate with each other without requiring links or host port mappings. Network isolation is achieved on the container instance using security groups and VPC settings.
	Links []string `pulumi:"links"`
	// Linux-specific modifications that are applied to the container, such as Linux kernel capabilities. For more information see [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).
	//   This parameter is not supported for Windows containers.
	LinuxParameters *TaskDefinitionLinuxParameters `pulumi:"linuxParameters"`
	// The log configuration specification for the container.
	//  This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). By default, containers use the same logging driver that the Docker daemon uses. However, the container may use a different logging driver than the Docker daemon by specifying a log driver with this parameter in the container definition. To use a different logging driver for a container, the log system must be configured properly on the container instance (or on a different log server for remote logging options). For more information on the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
	//   Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon (shown in the [LogConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html) data type). Additional log drivers may be available in future releases of the Amazon ECS container agent.
	//   This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	//   The Amazon ECS container agent running on a container instance must register the logging drivers available on that instance with the “ECS_AVAILABLE_LOGGING_DRIVERS“ environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS Container Agent Configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
	LogConfiguration *TaskDefinitionLogConfiguration `pulumi:"logConfiguration"`
	// The amount (in MiB) of memory to present to the container. If your container attempts to exceed the memory specified here, the container is killed. The total amount of memory reserved for all containers within a task must be lower than the task “memory“ value, if one is specified. This parameter maps to “Memory“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--memory“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  If using the Fargate launch type, this parameter is optional.
	//  If using the EC2 launch type, you must specify either a task-level memory value or a container-level memory value. If you specify both a container-level “memory“ and “memoryReservation“ value, “memory“ must be greater than “memoryReservation“. If you specify “memoryReservation“, then that value is subtracted from the available memory resources for the container instance where the container is placed. Otherwise, the value of “memory“ is used.
	//  The Docker 20.10.0 or later daemon reserves a minimum of 6 MiB of memory for a container, so you should not specify fewer than 6 MiB of memory for your containers.
	//  The Docker 19.03.13-ce or earlier daemon reserves a minimum of 4 MiB of memory for a container, so you should not specify fewer than 4 MiB of memory for your containers.
	Memory *int `pulumi:"memory"`
	// The soft limit (in MiB) of memory to reserve for the container. When system memory is under heavy contention, Docker attempts to keep the container memory to this soft limit. However, your container can consume more memory when it needs to, up to either the hard limit specified with the “memory“ parameter (if applicable), or all of the available memory on the container instance, whichever comes first. This parameter maps to “MemoryReservation“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--memory-reservation“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  If a task-level memory value is not specified, you must specify a non-zero integer for one or both of “memory“ or “memoryReservation“ in a container definition. If you specify both, “memory“ must be greater than “memoryReservation“. If you specify “memoryReservation“, then that value is subtracted from the available memory resources for the container instance where the container is placed. Otherwise, the value of “memory“ is used.
	//  For example, if your container normally uses 128 MiB of memory, but occasionally bursts to 256 MiB of memory for short periods of time, you can set a “memoryReservation“ of 128 MiB, and a “memory“ hard limit of 300 MiB. This configuration would allow the container to only reserve 128 MiB of memory from the remaining resources on the container instance, but also allow the container to consume more memory resources when needed.
	//  The Docker 20.10.0 or later daemon reserves a minimum of 6 MiB of memory for a container. So, don't specify less than 6 MiB of memory for your containers.
	//  The Docker 19.03.13-ce or earlier daemon reserves a minimum of 4 MiB of memory for a container. So, don't specify less than 4 MiB of memory for your containers.
	MemoryReservation *int `pulumi:"memoryReservation"`
	// The mount points for data volumes in your container.
	//  This parameter maps to “Volumes“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--volume“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  Windows containers can mount whole directories on the same drive as “$env:ProgramData“. Windows containers can't mount directories on a different drive, and mount point can't be across drives.
	MountPoints []TaskDefinitionMountPoint `pulumi:"mountPoints"`
	// The name of a container. If you're linking multiple containers together in a task definition, the “name“ of one container can be entered in the “links“ of another container to connect the containers. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. This parameter maps to “name“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--name“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	Name string `pulumi:"name"`
	// The list of port mappings for the container. Port mappings allow containers to access ports on the host container instance to send or receive traffic.
	//  For task definitions that use the “awsvpc“ network mode, you should only specify the “containerPort“. The “hostPort“ can be left blank or it must be the same value as the “containerPort“.
	//  Port mappings on Windows use the “NetNAT“ gateway address rather than “localhost“. There is no loopback for port mappings on Windows, so you cannot access a container's mapped port from the host itself.
	//  This parameter maps to “PortBindings“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--publish“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). If the network mode of a task definition is set to “none“, then you can't specify port mappings. If the network mode of a task definition is set to “host“, then host ports must either be undefined or they must match the container port in the port mapping.
	//   After a task reaches the “RUNNING“ status, manual and automatic host and container port assignments are visible in the *Network Bindings* section of a container description for a selected task in the Amazon ECS console. The assignments are also visible in the “networkBindings“ section [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) responses.
	PortMappings []TaskDefinitionPortMapping `pulumi:"portMappings"`
	// When this parameter is true, the container is given elevated privileges on the host container instance (similar to the “root“ user). This parameter maps to “Privileged“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--privileged“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers or tasks run on FARGATElong.
	Privileged *bool `pulumi:"privileged"`
	// When this parameter is “true“, a TTY is allocated. This parameter maps to “Tty“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--tty“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	PseudoTerminal *bool `pulumi:"pseudoTerminal"`
	// When this parameter is true, the container is given read-only access to its root file system. This parameter maps to “ReadonlyRootfs“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--read-only“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers.
	ReadonlyRootFilesystem *bool `pulumi:"readonlyRootFilesystem"`
	// The private repository authentication credentials to use.
	RepositoryCredentials *TaskDefinitionRepositoryCredentials `pulumi:"repositoryCredentials"`
	// The type and amount of a resource to assign to a container. The only supported resource is a GPU.
	ResourceRequirements []TaskDefinitionResourceRequirement `pulumi:"resourceRequirements"`
	// The secrets to pass to the container. For more information, see [Specifying Sensitive Data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.
	Secrets []TaskDefinitionSecret `pulumi:"secrets"`
	// Time duration (in seconds) to wait before giving up on resolving dependencies for a container. For example, you specify two containers in a task definition with containerA having a dependency on containerB reaching a “COMPLETE“, “SUCCESS“, or “HEALTHY“ status. If a “startTimeout“ value is specified for containerB and it doesn't reach the desired status within that time then containerA gives up and not start. This results in the task transitioning to a “STOPPED“ state.
	//   When the “ECS_CONTAINER_START_TIMEOUT“ container agent configuration variable is used, it's enforced independently from this start timeout value.
	//   For tasks using the Fargate launch type, the task or service requires the following platforms:
	//   +  Linux platform version “1.3.0“ or later.
	//   +  Windows platform version “1.0.0“ or later.
	//
	//  For tasks using the EC2 launch type, your container instances require at least version “1.26.0“ of the container agent to use a container start timeout value. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version “1.26.0-1“ of the “ecs-init“ package. If your container instances are launched from version “20190301“ or later, then they contain the required versions of the container agent and “ecs-init“. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  The valid values are 2-120 seconds.
	StartTimeout *int `pulumi:"startTimeout"`
	// Time duration (in seconds) to wait before the container is forcefully killed if it doesn't exit normally on its own.
	//  For tasks using the Fargate launch type, the task or service requires the following platforms:
	//   +  Linux platform version “1.3.0“ or later.
	//   +  Windows platform version “1.0.0“ or later.
	//
	//  The max stop timeout value is 120 seconds and if the parameter is not specified, the default value of 30 seconds is used.
	//  For tasks that use the EC2 launch type, if the “stopTimeout“ parameter isn't specified, the value set for the Amazon ECS container agent configuration variable “ECS_CONTAINER_STOP_TIMEOUT“ is used. If neither the “stopTimeout“ parameter or the “ECS_CONTAINER_STOP_TIMEOUT“ agent configuration variable are set, then the default values of 30 seconds for Linux containers and 30 seconds on Windows containers are used. Your container instances require at least version 1.26.0 of the container agent to use a container stop timeout value. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the “ecs-init“ package. If your container instances are launched from version “20190301“ or later, then they contain the required versions of the container agent and “ecs-init“. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  The valid values are 2-120 seconds.
	StopTimeout *int `pulumi:"stopTimeout"`
	// A list of namespaced kernel parameters to set in the container. This parameter maps to “Sysctls“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--sysctl“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For example, you can configure “net.ipv4.tcp_keepalive_time“ setting to maintain longer lived connections.
	SystemControls []TaskDefinitionSystemControl `pulumi:"systemControls"`
	// A list of “ulimits“ to set in the container. This parameter maps to “Ulimits“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--ulimit“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). Valid naming values are displayed in the [Ulimit](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Ulimit.html) data type. This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	//   This parameter is not supported for Windows containers.
	Ulimits []TaskDefinitionUlimit `pulumi:"ulimits"`
	// The user to use inside the container. This parameter maps to “User“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--user“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   When running tasks using the “host“ network mode, don't run containers using the root user (UID 0). We recommend using a non-root user for better security.
	//   You can specify the “user“ using the following formats. If specifying a UID or GID, you must specify it as a positive integer.
	//   +   “user“
	//   +   “user:group“
	//   +   “uid“
	//   +   “uid:gid“
	//   +   “user:gid“
	//   +   “uid:group“
	//
	//   This parameter is not supported for Windows containers.
	User *string `pulumi:"user"`
	// Data volumes to mount from another container. This parameter maps to “VolumesFrom“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--volumes-from“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	VolumesFrom []TaskDefinitionVolumeFrom `pulumi:"volumesFrom"`
	// The working directory to run commands inside the container in. This parameter maps to “WorkingDir“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--workdir“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	WorkingDirectory *string `pulumi:"workingDirectory"`
}

The “ContainerDefinition“ property specifies a container definition. Container definitions are used in task definitions to describe the different containers that are launched as part of a task.

type TaskDefinitionContainerDefinitionArgs 

type TaskDefinitionContainerDefinitionArgs struct {
	// The command that's passed to the container. This parameter maps to “Cmd“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “COMMAND“ parameter to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For more information, see [https://docs.docker.com/engine/reference/builder/#cmd](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/builder/#cmd). If there are multiple arguments, each argument is a separated string in the array.
	Command pulumi.StringArrayInput `pulumi:"command"`
	// The number of “cpu“ units reserved for the container. This parameter maps to “CpuShares“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cpu-shares“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level “cpu“ value.
	//   You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
	//   Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
	//  On Linux container instances, the Docker daemon on the container instance uses the CPU value to calculate the relative CPU share ratios for running containers. For more information, see [CPU share constraint](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#cpu-share-constraint) in the Docker documentation. The minimum valid CPU share value that the Linux kernel allows is 2. However, the CPU parameter isn't required, and you can use CPU values below 2 in your container definitions. For CPU values below 2 (including null), the behavior varies based on your Amazon ECS container agent version:
	//   +   *Agent versions less than or equal to 1.1.0:* Null and zero CPU values are passed to Docker as 0, which Docker then converts to 1,024 CPU shares. CPU values of 1 are passed to Docker as 1, which the Linux kernel converts to two CPU shares.
	//   +   *Agent versions greater than or equal to 1.2.0:* Null, zero, and CPU values of 1 are passed to Docker as 2.
	//
	//  On Windows container instances, the CPU limit is enforced as an absolute limit, or a quota. Windows containers only have access to the specified amount of CPU that's described in the task definition. A null or zero CPU value is passed to Docker as “0“, which Windows interprets as 1% of one CPU.
	Cpu pulumi.IntPtrInput `pulumi:"cpu"`
	// A list of ARNs in SSM or Amazon S3 to a credential spec (“CredSpec“) file that configures the container for Active Directory authentication. We recommend that you use this parameter instead of the “dockerSecurityOptions“. The maximum number of ARNs is 1.
	//  There are two formats for each ARN.
	//   + credentialspecdomainless:MyARN You use credentialspecdomainless:MyARN to provide a CredSpec with an additional section for a secret in . You provide the login credentials to the domain in the secret. Each task that runs on any container instance can join different domains. You can use this format without joining the container instance to a domain. + credentialspec:MyARN You use credentialspec:MyARN to provide a CredSpec for a single domain. You must join the container instance to the domain before you start any tasks that use this task definition.
	//      In both formats, replace “MyARN“ with the ARN in SSM or Amazon S3.
	//      If you provide a “credentialspecdomainless:MyARN“, the “credspec“ must provide a ARN in ASMlong for a secret containing the username, password, and the domain to connect to. For better security, the instance isn't joined to the domain for domainless authentication. Other applications on the instance can't use the domainless credentials. You can use this parameter to run tasks on the same instance, even it the tasks need to join different domains. For more information, see [Using gMSAs for Windows Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html) and [Using gMSAs for Linux Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html).
	CredentialSpecs pulumi.StringArrayInput `pulumi:"credentialSpecs"`
	// The dependencies defined for container startup and shutdown. A container can contain multiple dependencies. When a dependency is defined for container startup, for container shutdown it is reversed.
	//  For tasks using the EC2 launch type, the container instances require at least version 1.26.0 of the container agent to turn on container dependencies. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the “ecs-init“ package. If your container instances are launched from version “20190301“ or later, then they contain the required versions of the container agent and “ecs-init“. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  For tasks using the Fargate launch type, the task or service requires the following platforms:
	//   +  Linux platform version “1.3.0“ or later.
	//   +  Windows platform version “1.0.0“ or later.
	//
	//  If the task definition is used in a blue/green deployment that uses [AWS::CodeDeploy::DeploymentGroup BlueGreenDeploymentConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codedeploy-deploymentgroup-bluegreendeploymentconfiguration.html), the “dependsOn“ parameter is not supported. For more information see [Issue #680](https://docs.aws.amazon.com/https://github.com/aws-cloudformation/cloudformation-coverage-roadmap/issues/680) on the on the GitHub website.
	DependsOn TaskDefinitionContainerDependencyArrayInput `pulumi:"dependsOn"`
	// When this parameter is true, networking is off within the container. This parameter maps to “NetworkDisabled“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/).
	//   This parameter is not supported for Windows containers.
	DisableNetworking pulumi.BoolPtrInput `pulumi:"disableNetworking"`
	// A list of DNS search domains that are presented to the container. This parameter maps to “DnsSearch“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--dns-search“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers.
	DnsSearchDomains pulumi.StringArrayInput `pulumi:"dnsSearchDomains"`
	// A list of DNS servers that are presented to the container. This parameter maps to “Dns“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--dns“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers.
	DnsServers pulumi.StringArrayInput `pulumi:"dnsServers"`
	// A key/value map of labels to add to the container. This parameter maps to “Labels“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--label“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	DockerLabels pulumi.StringMapInput `pulumi:"dockerLabels"`
	// A list of strings to provide custom configuration for multiple security systems. For more information about valid values, see [Docker Run Security Configuration](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This field isn't valid for containers in tasks using the Fargate launch type.
	//  For Linux tasks on EC2, this parameter can be used to reference custom labels for SELinux and AppArmor multi-level security systems.
	//  For any tasks on EC2, this parameter can be used to reference a credential spec file that configures a container for Active Directory authentication. For more information, see [Using gMSAs for Windows Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html) and [Using gMSAs for Linux Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  This parameter maps to “SecurityOpt“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--security-opt“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   The Amazon ECS container agent running on a container instance must register with the “ECS_SELINUX_CAPABLE=true“ or “ECS_APPARMOR_CAPABLE=true“ environment variables before containers placed on that instance can use these security options. For more information, see [Amazon ECS Container Agent Configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   For more information about valid values, see [Docker Run Security Configuration](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  Valid values: "no-new-privileges" | "apparmor:PROFILE" | "label:value" | "credentialspec:CredentialSpecFilePath"
	DockerSecurityOptions pulumi.StringArrayInput `pulumi:"dockerSecurityOptions"`
	// Early versions of the Amazon ECS container agent don't properly handle “entryPoint“ parameters. If you have problems using “entryPoint“, update your container agent or enter your commands and arguments as “command“ array items instead.
	//   The entry point that's passed to the container. This parameter maps to “Entrypoint“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--entrypoint“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For more information, see [https://docs.docker.com/engine/reference/builder/#entrypoint](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/builder/#entrypoint).
	EntryPoint pulumi.StringArrayInput `pulumi:"entryPoint"`
	// The environment variables to pass to a container. This parameter maps to “Env“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--env“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   We don't recommend that you use plaintext environment variables for sensitive information, such as credential data.
	Environment TaskDefinitionKeyValuePairArrayInput `pulumi:"environment"`
	// A list of files containing the environment variables to pass to a container. This parameter maps to the “--env-file“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  You can specify up to ten environment files. The file must have a “.env“ file extension. Each line in an environment file contains an environment variable in “VARIABLE=VALUE“ format. Lines beginning with “#“ are treated as comments and are ignored. For more information about the environment variable file syntax, see [Declare default environment variables in file](https://docs.aws.amazon.com/https://docs.docker.com/compose/env-file/).
	//  If there are environment variables specified using the “environment“ parameter in a container definition, they take precedence over the variables contained within an environment file. If multiple environment files are specified that contain the same variable, they're processed from the top down. We recommend that you use unique variable names. For more information, see [Specifying Environment Variables](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html) in the *Amazon Elastic Container Service Developer Guide*.
	EnvironmentFiles TaskDefinitionEnvironmentFileArrayInput `pulumi:"environmentFiles"`
	// If the “essential“ parameter of a container is marked as “true“, and that container fails or stops for any reason, all other containers that are part of the task are stopped. If the “essential“ parameter of a container is marked as “false“, its failure doesn't affect the rest of the containers in a task. If this parameter is omitted, a container is assumed to be essential.
	//  All tasks must have at least one essential container. If you have an application that's composed of multiple containers, group containers that are used for a common purpose into components, and separate the different components into multiple task definitions. For more information, see [Application Architecture](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html) in the *Amazon Elastic Container Service Developer Guide*.
	Essential pulumi.BoolPtrInput `pulumi:"essential"`
	// A list of hostnames and IP address mappings to append to the “/etc/hosts“ file on the container. This parameter maps to “ExtraHosts“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--add-host“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter isn't supported for Windows containers or tasks that use the “awsvpc“ network mode.
	ExtraHosts TaskDefinitionHostEntryArrayInput `pulumi:"extraHosts"`
	// The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see [Custom Log Routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
	FirelensConfiguration TaskDefinitionFirelensConfigurationPtrInput `pulumi:"firelensConfiguration"`
	// The container health check command and associated configuration parameters for the container. This parameter maps to “HealthCheck“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “HEALTHCHECK“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	HealthCheck TaskDefinitionHealthCheckPtrInput `pulumi:"healthCheck"`
	// The hostname to use for your container. This parameter maps to “Hostname“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--hostname“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   The “hostname“ parameter is not supported if you're using the “awsvpc“ network mode.
	Hostname pulumi.StringPtrInput `pulumi:"hostname"`
	// The image used to start a container. This string is passed directly to the Docker daemon. By default, images in the Docker Hub registry are available. Other repositories are specified with either “repository-url/image:tag“ or “repository-url/image@digest“. Up to 255 letters (uppercase and lowercase), numbers, hyphens, underscores, colons, periods, forward slashes, and number signs are allowed. This parameter maps to “Image“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “IMAGE“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   +  When a new task starts, the Amazon ECS container agent pulls the latest version of the specified image and tag for the container to use. However, subsequent updates to a repository image aren't propagated to already running tasks.
	//   +  Images in Amazon ECR repositories can be specified by either using the full “registry/repository:tag“ or “registry/repository@digest“. For example, “012345678910.dkr.ecr.<region-name>.amazonaws.com/<repository-name>:latest“ or “012345678910.dkr.ecr.<region-name>.amazonaws.com/<repository-name>@sha256:94afd1f2e64d908bc90dbca0035a5b567EXAMPLE“.
	//   +  Images in official repositories on Docker Hub use a single name (for example, “ubuntu“ or “mongo“).
	//   +  Images in other repositories on Docker Hub are qualified with an organization name (for example, “amazon/amazon-ecs-agent“).
	//   +  Images in other online repositories are qualified further by a domain name (for example, “quay.io/assemblyline/ubuntu“).
	Image pulumi.StringInput `pulumi:"image"`
	// When this parameter is “true“, you can deploy containerized applications that require “stdin“ or a “tty“ to be allocated. This parameter maps to “OpenStdin“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--interactive“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	Interactive pulumi.BoolPtrInput `pulumi:"interactive"`
	// The “links“ parameter allows containers to communicate with each other without the need for port mappings. This parameter is only supported if the network mode of a task definition is “bridge“. The “name:internalName“ construct is analogous to “name:alias“ in Docker links. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. For more information about linking Docker containers, go to [Legacy container links](https://docs.aws.amazon.com/https://docs.docker.com/network/links/) in the Docker documentation. This parameter maps to “Links“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--link“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers.
	//    Containers that are collocated on a single container instance may be able to communicate with each other without requiring links or host port mappings. Network isolation is achieved on the container instance using security groups and VPC settings.
	Links pulumi.StringArrayInput `pulumi:"links"`
	// Linux-specific modifications that are applied to the container, such as Linux kernel capabilities. For more information see [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).
	//   This parameter is not supported for Windows containers.
	LinuxParameters TaskDefinitionLinuxParametersPtrInput `pulumi:"linuxParameters"`
	// The log configuration specification for the container.
	//  This parameter maps to “LogConfig“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--log-driver“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). By default, containers use the same logging driver that the Docker daemon uses. However, the container may use a different logging driver than the Docker daemon by specifying a log driver with this parameter in the container definition. To use a different logging driver for a container, the log system must be configured properly on the container instance (or on a different log server for remote logging options). For more information on the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
	//   Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon (shown in the [LogConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html) data type). Additional log drivers may be available in future releases of the Amazon ECS container agent.
	//   This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	//   The Amazon ECS container agent running on a container instance must register the logging drivers available on that instance with the “ECS_AVAILABLE_LOGGING_DRIVERS“ environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS Container Agent Configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
	LogConfiguration TaskDefinitionLogConfigurationPtrInput `pulumi:"logConfiguration"`
	// The amount (in MiB) of memory to present to the container. If your container attempts to exceed the memory specified here, the container is killed. The total amount of memory reserved for all containers within a task must be lower than the task “memory“ value, if one is specified. This parameter maps to “Memory“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--memory“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  If using the Fargate launch type, this parameter is optional.
	//  If using the EC2 launch type, you must specify either a task-level memory value or a container-level memory value. If you specify both a container-level “memory“ and “memoryReservation“ value, “memory“ must be greater than “memoryReservation“. If you specify “memoryReservation“, then that value is subtracted from the available memory resources for the container instance where the container is placed. Otherwise, the value of “memory“ is used.
	//  The Docker 20.10.0 or later daemon reserves a minimum of 6 MiB of memory for a container, so you should not specify fewer than 6 MiB of memory for your containers.
	//  The Docker 19.03.13-ce or earlier daemon reserves a minimum of 4 MiB of memory for a container, so you should not specify fewer than 4 MiB of memory for your containers.
	Memory pulumi.IntPtrInput `pulumi:"memory"`
	// The soft limit (in MiB) of memory to reserve for the container. When system memory is under heavy contention, Docker attempts to keep the container memory to this soft limit. However, your container can consume more memory when it needs to, up to either the hard limit specified with the “memory“ parameter (if applicable), or all of the available memory on the container instance, whichever comes first. This parameter maps to “MemoryReservation“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--memory-reservation“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  If a task-level memory value is not specified, you must specify a non-zero integer for one or both of “memory“ or “memoryReservation“ in a container definition. If you specify both, “memory“ must be greater than “memoryReservation“. If you specify “memoryReservation“, then that value is subtracted from the available memory resources for the container instance where the container is placed. Otherwise, the value of “memory“ is used.
	//  For example, if your container normally uses 128 MiB of memory, but occasionally bursts to 256 MiB of memory for short periods of time, you can set a “memoryReservation“ of 128 MiB, and a “memory“ hard limit of 300 MiB. This configuration would allow the container to only reserve 128 MiB of memory from the remaining resources on the container instance, but also allow the container to consume more memory resources when needed.
	//  The Docker 20.10.0 or later daemon reserves a minimum of 6 MiB of memory for a container. So, don't specify less than 6 MiB of memory for your containers.
	//  The Docker 19.03.13-ce or earlier daemon reserves a minimum of 4 MiB of memory for a container. So, don't specify less than 4 MiB of memory for your containers.
	MemoryReservation pulumi.IntPtrInput `pulumi:"memoryReservation"`
	// The mount points for data volumes in your container.
	//  This parameter maps to “Volumes“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--volume“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  Windows containers can mount whole directories on the same drive as “$env:ProgramData“. Windows containers can't mount directories on a different drive, and mount point can't be across drives.
	MountPoints TaskDefinitionMountPointArrayInput `pulumi:"mountPoints"`
	// The name of a container. If you're linking multiple containers together in a task definition, the “name“ of one container can be entered in the “links“ of another container to connect the containers. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. This parameter maps to “name“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--name“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	Name pulumi.StringInput `pulumi:"name"`
	// The list of port mappings for the container. Port mappings allow containers to access ports on the host container instance to send or receive traffic.
	//  For task definitions that use the “awsvpc“ network mode, you should only specify the “containerPort“. The “hostPort“ can be left blank or it must be the same value as the “containerPort“.
	//  Port mappings on Windows use the “NetNAT“ gateway address rather than “localhost“. There is no loopback for port mappings on Windows, so you cannot access a container's mapped port from the host itself.
	//  This parameter maps to “PortBindings“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--publish“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). If the network mode of a task definition is set to “none“, then you can't specify port mappings. If the network mode of a task definition is set to “host“, then host ports must either be undefined or they must match the container port in the port mapping.
	//   After a task reaches the “RUNNING“ status, manual and automatic host and container port assignments are visible in the *Network Bindings* section of a container description for a selected task in the Amazon ECS console. The assignments are also visible in the “networkBindings“ section [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) responses.
	PortMappings TaskDefinitionPortMappingArrayInput `pulumi:"portMappings"`
	// When this parameter is true, the container is given elevated privileges on the host container instance (similar to the “root“ user). This parameter maps to “Privileged“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--privileged“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers or tasks run on FARGATElong.
	Privileged pulumi.BoolPtrInput `pulumi:"privileged"`
	// When this parameter is “true“, a TTY is allocated. This parameter maps to “Tty“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--tty“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	PseudoTerminal pulumi.BoolPtrInput `pulumi:"pseudoTerminal"`
	// When this parameter is true, the container is given read-only access to its root file system. This parameter maps to “ReadonlyRootfs“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--read-only“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   This parameter is not supported for Windows containers.
	ReadonlyRootFilesystem pulumi.BoolPtrInput `pulumi:"readonlyRootFilesystem"`
	// The private repository authentication credentials to use.
	RepositoryCredentials TaskDefinitionRepositoryCredentialsPtrInput `pulumi:"repositoryCredentials"`
	// The type and amount of a resource to assign to a container. The only supported resource is a GPU.
	ResourceRequirements TaskDefinitionResourceRequirementArrayInput `pulumi:"resourceRequirements"`
	// The secrets to pass to the container. For more information, see [Specifying Sensitive Data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.
	Secrets TaskDefinitionSecretArrayInput `pulumi:"secrets"`
	// Time duration (in seconds) to wait before giving up on resolving dependencies for a container. For example, you specify two containers in a task definition with containerA having a dependency on containerB reaching a “COMPLETE“, “SUCCESS“, or “HEALTHY“ status. If a “startTimeout“ value is specified for containerB and it doesn't reach the desired status within that time then containerA gives up and not start. This results in the task transitioning to a “STOPPED“ state.
	//   When the “ECS_CONTAINER_START_TIMEOUT“ container agent configuration variable is used, it's enforced independently from this start timeout value.
	//   For tasks using the Fargate launch type, the task or service requires the following platforms:
	//   +  Linux platform version “1.3.0“ or later.
	//   +  Windows platform version “1.0.0“ or later.
	//
	//  For tasks using the EC2 launch type, your container instances require at least version “1.26.0“ of the container agent to use a container start timeout value. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version “1.26.0-1“ of the “ecs-init“ package. If your container instances are launched from version “20190301“ or later, then they contain the required versions of the container agent and “ecs-init“. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  The valid values are 2-120 seconds.
	StartTimeout pulumi.IntPtrInput `pulumi:"startTimeout"`
	// Time duration (in seconds) to wait before the container is forcefully killed if it doesn't exit normally on its own.
	//  For tasks using the Fargate launch type, the task or service requires the following platforms:
	//   +  Linux platform version “1.3.0“ or later.
	//   +  Windows platform version “1.0.0“ or later.
	//
	//  The max stop timeout value is 120 seconds and if the parameter is not specified, the default value of 30 seconds is used.
	//  For tasks that use the EC2 launch type, if the “stopTimeout“ parameter isn't specified, the value set for the Amazon ECS container agent configuration variable “ECS_CONTAINER_STOP_TIMEOUT“ is used. If neither the “stopTimeout“ parameter or the “ECS_CONTAINER_STOP_TIMEOUT“ agent configuration variable are set, then the default values of 30 seconds for Linux containers and 30 seconds on Windows containers are used. Your container instances require at least version 1.26.0 of the container agent to use a container stop timeout value. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the “ecs-init“ package. If your container instances are launched from version “20190301“ or later, then they contain the required versions of the container agent and “ecs-init“. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  The valid values are 2-120 seconds.
	StopTimeout pulumi.IntPtrInput `pulumi:"stopTimeout"`
	// A list of namespaced kernel parameters to set in the container. This parameter maps to “Sysctls“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--sysctl“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For example, you can configure “net.ipv4.tcp_keepalive_time“ setting to maintain longer lived connections.
	SystemControls TaskDefinitionSystemControlArrayInput `pulumi:"systemControls"`
	// A list of “ulimits“ to set in the container. This parameter maps to “Ulimits“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--ulimit“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). Valid naming values are displayed in the [Ulimit](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Ulimit.html) data type. This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	//   This parameter is not supported for Windows containers.
	Ulimits TaskDefinitionUlimitArrayInput `pulumi:"ulimits"`
	// The user to use inside the container. This parameter maps to “User“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--user“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   When running tasks using the “host“ network mode, don't run containers using the root user (UID 0). We recommend using a non-root user for better security.
	//   You can specify the “user“ using the following formats. If specifying a UID or GID, you must specify it as a positive integer.
	//   +   “user“
	//   +   “user:group“
	//   +   “uid“
	//   +   “uid:gid“
	//   +   “user:gid“
	//   +   “uid:group“
	//
	//   This parameter is not supported for Windows containers.
	User pulumi.StringPtrInput `pulumi:"user"`
	// Data volumes to mount from another container. This parameter maps to “VolumesFrom“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--volumes-from“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	VolumesFrom TaskDefinitionVolumeFromArrayInput `pulumi:"volumesFrom"`
	// The working directory to run commands inside the container in. This parameter maps to “WorkingDir“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--workdir“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	WorkingDirectory pulumi.StringPtrInput `pulumi:"workingDirectory"`
}

The “ContainerDefinition“ property specifies a container definition. Container definitions are used in task definitions to describe the different containers that are launched as part of a task.

func (TaskDefinitionContainerDefinitionArgs) ElementType 

func (TaskDefinitionContainerDefinitionArgs) ElementType() reflect.Type

func (TaskDefinitionContainerDefinitionArgs) ToTaskDefinitionContainerDefinitionOutput 

func (i TaskDefinitionContainerDefinitionArgs) ToTaskDefinitionContainerDefinitionOutput() TaskDefinitionContainerDefinitionOutput

func (TaskDefinitionContainerDefinitionArgs) ToTaskDefinitionContainerDefinitionOutputWithContext 

func (i TaskDefinitionContainerDefinitionArgs) ToTaskDefinitionContainerDefinitionOutputWithContext(ctx context.Context) TaskDefinitionContainerDefinitionOutput

type TaskDefinitionContainerDefinitionArray 

type TaskDefinitionContainerDefinitionArray []TaskDefinitionContainerDefinitionInput

func (TaskDefinitionContainerDefinitionArray) ElementType 

func (TaskDefinitionContainerDefinitionArray) ElementType() reflect.Type

func (TaskDefinitionContainerDefinitionArray) ToTaskDefinitionContainerDefinitionArrayOutput 

func (i TaskDefinitionContainerDefinitionArray) ToTaskDefinitionContainerDefinitionArrayOutput() TaskDefinitionContainerDefinitionArrayOutput

func (TaskDefinitionContainerDefinitionArray) ToTaskDefinitionContainerDefinitionArrayOutputWithContext 

func (i TaskDefinitionContainerDefinitionArray) ToTaskDefinitionContainerDefinitionArrayOutputWithContext(ctx context.Context) TaskDefinitionContainerDefinitionArrayOutput

type TaskDefinitionContainerDefinitionArrayInput 

type TaskDefinitionContainerDefinitionArrayInput interface {
	pulumi.Input

	ToTaskDefinitionContainerDefinitionArrayOutput() TaskDefinitionContainerDefinitionArrayOutput
	ToTaskDefinitionContainerDefinitionArrayOutputWithContext(context.Context) TaskDefinitionContainerDefinitionArrayOutput
}

TaskDefinitionContainerDefinitionArrayInput is an input type that accepts TaskDefinitionContainerDefinitionArray and TaskDefinitionContainerDefinitionArrayOutput values. You can construct a concrete instance of `TaskDefinitionContainerDefinitionArrayInput` via: 

TaskDefinitionContainerDefinitionArray{ TaskDefinitionContainerDefinitionArgs{...} }

type TaskDefinitionContainerDefinitionArrayOutput 

type TaskDefinitionContainerDefinitionArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionContainerDefinitionArrayOutput) ElementType 

func (TaskDefinitionContainerDefinitionArrayOutput) ElementType() reflect.Type

func (TaskDefinitionContainerDefinitionArrayOutput) Index 

func (o TaskDefinitionContainerDefinitionArrayOutput) Index(i pulumi.IntInput) TaskDefinitionContainerDefinitionOutput

func (TaskDefinitionContainerDefinitionArrayOutput) ToTaskDefinitionContainerDefinitionArrayOutput 

func (o TaskDefinitionContainerDefinitionArrayOutput) ToTaskDefinitionContainerDefinitionArrayOutput() TaskDefinitionContainerDefinitionArrayOutput

func (TaskDefinitionContainerDefinitionArrayOutput) ToTaskDefinitionContainerDefinitionArrayOutputWithContext 

func (o TaskDefinitionContainerDefinitionArrayOutput) ToTaskDefinitionContainerDefinitionArrayOutputWithContext(ctx context.Context) TaskDefinitionContainerDefinitionArrayOutput

type TaskDefinitionContainerDefinitionInput 

type TaskDefinitionContainerDefinitionInput interface {
	pulumi.Input

	ToTaskDefinitionContainerDefinitionOutput() TaskDefinitionContainerDefinitionOutput
	ToTaskDefinitionContainerDefinitionOutputWithContext(context.Context) TaskDefinitionContainerDefinitionOutput
}

TaskDefinitionContainerDefinitionInput is an input type that accepts TaskDefinitionContainerDefinitionArgs and TaskDefinitionContainerDefinitionOutput values. You can construct a concrete instance of `TaskDefinitionContainerDefinitionInput` via: 

TaskDefinitionContainerDefinitionArgs{...}

type TaskDefinitionContainerDefinitionOutput 

type TaskDefinitionContainerDefinitionOutput struct{ *pulumi.OutputState }

The “ContainerDefinition“ property specifies a container definition. Container definitions are used in task definitions to describe the different containers that are launched as part of a task.

func (TaskDefinitionContainerDefinitionOutput) Command 

func (o TaskDefinitionContainerDefinitionOutput) Command() pulumi.StringArrayOutput

The command that's passed to the container. This parameter maps to “Cmd“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “COMMAND“ parameter to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For more information, see [https://docs.docker.com/engine/reference/builder/#cmd](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/builder/#cmd). If there are multiple arguments, each argument is a separated string in the array.

func (TaskDefinitionContainerDefinitionOutput) Cpu 

func (o TaskDefinitionContainerDefinitionOutput) Cpu() pulumi.IntPtrOutput

The number of “cpu“ units reserved for the container. This parameter maps to “CpuShares“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cpu-shares“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

This field is optional for tasks using the Fargate launch type, and the only requirement is that the total amount of CPU reserved for all containers within a task be lower than the task-level ``cpu`` value.
 You can determine the number of CPU units that are available per EC2 instance type by multiplying the vCPUs listed for that instance type on the [Amazon EC2 Instances](https://docs.aws.amazon.com/ec2/instance-types/) detail page by 1,024.
 Linux containers share unallocated CPU units with other containers on the container instance with the same ratio as their allocated amount. For example, if you run a single-container task on a single-core instance type with 512 CPU units specified for that container, and that's the only task running on the container instance, that container could use the full 1,024 CPU unit share at any given time. However, if you launched another copy of the same task on that container instance, each task is guaranteed a minimum of 512 CPU units when needed. Moreover, each container could float to higher CPU usage if the other container was not using it. If both tasks were 100% active all of the time, they would be limited to 512 CPU units.
On Linux container instances, the Docker daemon on the container instance uses the CPU value to calculate the relative CPU share ratios for running containers. For more information, see [CPU share constraint](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#cpu-share-constraint) in the Docker documentation. The minimum valid CPU share value that the Linux kernel allows is 2. However, the CPU parameter isn't required, and you can use CPU values below 2 in your container definitions. For CPU values below 2 (including null), the behavior varies based on your Amazon ECS container agent version:
 +   *Agent versions less than or equal to 1.1.0:* Null and zero CPU values are passed to Docker as 0, which Docker then converts to 1,024 CPU shares. CPU values of 1 are passed to Docker as 1, which the Linux kernel converts to two CPU shares.
 +   *Agent versions greater than or equal to 1.2.0:* Null, zero, and CPU values of 1 are passed to Docker as 2.

On Windows container instances, the CPU limit is enforced as an absolute limit, or a quota. Windows containers only have access to the specified amount of CPU that's described in the task definition. A null or zero CPU value is passed to Docker as ``0``, which Windows interprets as 1% of one CPU.

func (TaskDefinitionContainerDefinitionOutput) CredentialSpecs added in v0.96.0 

func (o TaskDefinitionContainerDefinitionOutput) CredentialSpecs() pulumi.StringArrayOutput

A list of ARNs in SSM or Amazon S3 to a credential spec (“CredSpec“) file that configures the container for Active Directory authentication. We recommend that you use this parameter instead of the “dockerSecurityOptions“. The maximum number of ARNs is 1. 

There are two formats for each ARN.
 + credentialspecdomainless:MyARN You use credentialspecdomainless:MyARN to provide a CredSpec with an additional section for a secret in . You provide the login credentials to the domain in the secret. Each task that runs on any container instance can join different domains. You can use this format without joining the container instance to a domain. + credentialspec:MyARN You use credentialspec:MyARN to provide a CredSpec for a single domain. You must join the container instance to the domain before you start any tasks that use this task definition.
    In both formats, replace ``MyARN`` with the ARN in SSM or Amazon S3.
    If you provide a ``credentialspecdomainless:MyARN``, the ``credspec`` must provide a ARN in ASMlong for a secret containing the username, password, and the domain to connect to. For better security, the instance isn't joined to the domain for domainless authentication. Other applications on the instance can't use the domainless credentials. You can use this parameter to run tasks on the same instance, even it the tasks need to join different domains. For more information, see [Using gMSAs for Windows Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html) and [Using gMSAs for Linux Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html).

func (TaskDefinitionContainerDefinitionOutput) DependsOn 

func (o TaskDefinitionContainerDefinitionOutput) DependsOn() TaskDefinitionContainerDependencyArrayOutput

The dependencies defined for container startup and shutdown. A container can contain multiple dependencies. When a dependency is defined for container startup, for container shutdown it is reversed. 

For tasks using the EC2 launch type, the container instances require at least version 1.26.0 of the container agent to turn on container dependencies. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the ``ecs-init`` package. If your container instances are launched from version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
For tasks using the Fargate launch type, the task or service requires the following platforms:
 +  Linux platform version ``1.3.0`` or later.
 +  Windows platform version ``1.0.0`` or later.

If the task definition is used in a blue/green deployment that uses [AWS::CodeDeploy::DeploymentGroup BlueGreenDeploymentConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codedeploy-deploymentgroup-bluegreendeploymentconfiguration.html), the ``dependsOn`` parameter is not supported. For more information see [Issue #680](https://docs.aws.amazon.com/https://github.com/aws-cloudformation/cloudformation-coverage-roadmap/issues/680) on the on the GitHub website.

func (TaskDefinitionContainerDefinitionOutput) DisableNetworking 

func (o TaskDefinitionContainerDefinitionOutput) DisableNetworking() pulumi.BoolPtrOutput

When this parameter is true, networking is off within the container. This parameter maps to “NetworkDisabled“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/). 

This parameter is not supported for Windows containers.

func (TaskDefinitionContainerDefinitionOutput) DnsSearchDomains 

func (o TaskDefinitionContainerDefinitionOutput) DnsSearchDomains() pulumi.StringArrayOutput

A list of DNS search domains that are presented to the container. This parameter maps to “DnsSearch“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--dns-search“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

This parameter is not supported for Windows containers.

func (TaskDefinitionContainerDefinitionOutput) DnsServers 

func (o TaskDefinitionContainerDefinitionOutput) DnsServers() pulumi.StringArrayOutput

A list of DNS servers that are presented to the container. This parameter maps to “Dns“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--dns“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

This parameter is not supported for Windows containers.

func (TaskDefinitionContainerDefinitionOutput) DockerLabels 

func (o TaskDefinitionContainerDefinitionOutput) DockerLabels() pulumi.StringMapOutput

A key/value map of labels to add to the container. This parameter maps to “Labels“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--label“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“

func (TaskDefinitionContainerDefinitionOutput) DockerSecurityOptions 

func (o TaskDefinitionContainerDefinitionOutput) DockerSecurityOptions() pulumi.StringArrayOutput

A list of strings to provide custom configuration for multiple security systems. For more information about valid values, see [Docker Run Security Configuration](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This field isn't valid for containers in tasks using the Fargate launch type. 

For Linux tasks on EC2, this parameter can be used to reference custom labels for SELinux and AppArmor multi-level security systems.
For any tasks on EC2, this parameter can be used to reference a credential spec file that configures a container for Active Directory authentication. For more information, see [Using gMSAs for Windows Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html) and [Using gMSAs for Linux Containers](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html) in the *Amazon Elastic Container Service Developer Guide*.
This parameter maps to ``SecurityOpt`` in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the ``--security-opt`` option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
 The Amazon ECS container agent running on a container instance must register with the ``ECS_SELINUX_CAPABLE=true`` or ``ECS_APPARMOR_CAPABLE=true`` environment variables before containers placed on that instance can use these security options. For more information, see [Amazon ECS Container Agent Configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.
 For more information about valid values, see [Docker Run Security Configuration](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
Valid values: "no-new-privileges" | "apparmor:PROFILE" | "label:value" | "credentialspec:CredentialSpecFilePath"

func (TaskDefinitionContainerDefinitionOutput) ElementType 

func (TaskDefinitionContainerDefinitionOutput) ElementType() reflect.Type

func (TaskDefinitionContainerDefinitionOutput) EntryPoint 

func (o TaskDefinitionContainerDefinitionOutput) EntryPoint() pulumi.StringArrayOutput

Early versions of the Amazon ECS container agent don't properly handle “entryPoint“ parameters. If you have problems using “entryPoint“, update your container agent or enter your commands and arguments as “command“ array items instead. 

The entry point that's passed to the container. This parameter maps to ``Entrypoint`` in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the ``--entrypoint`` option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For more information, see [https://docs.docker.com/engine/reference/builder/#entrypoint](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/builder/#entrypoint).

func (TaskDefinitionContainerDefinitionOutput) Environment 

func (o TaskDefinitionContainerDefinitionOutput) Environment() TaskDefinitionKeyValuePairArrayOutput

The environment variables to pass to a container. This parameter maps to “Env“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--env“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

We don't recommend that you use plaintext environment variables for sensitive information, such as credential data.

func (TaskDefinitionContainerDefinitionOutput) EnvironmentFiles 

func (o TaskDefinitionContainerDefinitionOutput) EnvironmentFiles() TaskDefinitionEnvironmentFileArrayOutput

A list of files containing the environment variables to pass to a container. This parameter maps to the “--env-file“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

You can specify up to ten environment files. The file must have a ``.env`` file extension. Each line in an environment file contains an environment variable in ``VARIABLE=VALUE`` format. Lines beginning with ``#`` are treated as comments and are ignored. For more information about the environment variable file syntax, see [Declare default environment variables in file](https://docs.aws.amazon.com/https://docs.docker.com/compose/env-file/).
If there are environment variables specified using the ``environment`` parameter in a container definition, they take precedence over the variables contained within an environment file. If multiple environment files are specified that contain the same variable, they're processed from the top down. We recommend that you use unique variable names. For more information, see [Specifying Environment Variables](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionContainerDefinitionOutput) Essential 

func (o TaskDefinitionContainerDefinitionOutput) Essential() pulumi.BoolPtrOutput

If the “essential“ parameter of a container is marked as “true“, and that container fails or stops for any reason, all other containers that are part of the task are stopped. If the “essential“ parameter of a container is marked as “false“, its failure doesn't affect the rest of the containers in a task. If this parameter is omitted, a container is assumed to be essential. 

All tasks must have at least one essential container. If you have an application that's composed of multiple containers, group containers that are used for a common purpose into components, and separate the different components into multiple task definitions. For more information, see [Application Architecture](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionContainerDefinitionOutput) ExtraHosts 

func (o TaskDefinitionContainerDefinitionOutput) ExtraHosts() TaskDefinitionHostEntryArrayOutput

A list of hostnames and IP address mappings to append to the “/etc/hosts“ file on the container. This parameter maps to “ExtraHosts“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--add-host“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

This parameter isn't supported for Windows containers or tasks that use the ``awsvpc`` network mode.

func (TaskDefinitionContainerDefinitionOutput) FirelensConfiguration 

func (o TaskDefinitionContainerDefinitionOutput) FirelensConfiguration() TaskDefinitionFirelensConfigurationPtrOutput

The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see [Custom Log Routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionContainerDefinitionOutput) HealthCheck 

func (o TaskDefinitionContainerDefinitionOutput) HealthCheck() TaskDefinitionHealthCheckPtrOutput

The container health check command and associated configuration parameters for the container. This parameter maps to “HealthCheck“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “HEALTHCHECK“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).

func (TaskDefinitionContainerDefinitionOutput) Hostname 

func (o TaskDefinitionContainerDefinitionOutput) Hostname() pulumi.StringPtrOutput

The hostname to use for your container. This parameter maps to “Hostname“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--hostname“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

The ``hostname`` parameter is not supported if you're using the ``awsvpc`` network mode.

func (TaskDefinitionContainerDefinitionOutput) Image 

func (o TaskDefinitionContainerDefinitionOutput) Image() pulumi.StringOutput

The image used to start a container. This string is passed directly to the Docker daemon. By default, images in the Docker Hub registry are available. Other repositories are specified with either “repository-url/image:tag“ or “repository-url/image@digest“. Up to 255 letters (uppercase and lowercase), numbers, hyphens, underscores, colons, periods, forward slashes, and number signs are allowed. This parameter maps to “Image“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “IMAGE“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).

  • When a new task starts, the Amazon ECS container agent pulls the latest version of the specified image and tag for the container to use. However, subsequent updates to a repository image aren't propagated to already running tasks.
  • Images in Amazon ECR repositories can be specified by either using the full “registry/repository:tag“ or “registry/repository@digest“. For example, “012345678910.dkr.ecr.<region-name>.amazonaws.com/<repository-name>:latest“ or “012345678910.dkr.ecr.<region-name>.amazonaws.com/<repository-name>@sha256:94afd1f2e64d908bc90dbca0035a5b567EXAMPLE“.
  • Images in official repositories on Docker Hub use a single name (for example, “ubuntu“ or “mongo“).
  • Images in other repositories on Docker Hub are qualified with an organization name (for example, “amazon/amazon-ecs-agent“).
  • Images in other online repositories are qualified further by a domain name (for example, “quay.io/assemblyline/ubuntu“).

func (TaskDefinitionContainerDefinitionOutput) Interactive 

func (o TaskDefinitionContainerDefinitionOutput) Interactive() pulumi.BoolPtrOutput

When this parameter is “true“, you can deploy containerized applications that require “stdin“ or a “tty“ to be allocated. This parameter maps to “OpenStdin“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--interactive“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

func (o TaskDefinitionContainerDefinitionOutput) Links() pulumi.StringArrayOutput

The “links“ parameter allows containers to communicate with each other without the need for port mappings. This parameter is only supported if the network mode of a task definition is “bridge“. The “name:internalName“ construct is analogous to “name:alias“ in Docker links. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. For more information about linking Docker containers, go to [Legacy container links](https://docs.aws.amazon.com/https://docs.docker.com/network/links/) in the Docker documentation. This parameter maps to “Links“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--link“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

This parameter is not supported for Windows containers.
 Containers that are collocated on a single container instance may be able to communicate with each other without requiring links or host port mappings. Network isolation is achieved on the container instance using security groups and VPC settings.

func (TaskDefinitionContainerDefinitionOutput) LinuxParameters 

func (o TaskDefinitionContainerDefinitionOutput) LinuxParameters() TaskDefinitionLinuxParametersPtrOutput

Linux-specific modifications that are applied to the container, such as Linux kernel capabilities. For more information see [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html). 

This parameter is not supported for Windows containers.

func (TaskDefinitionContainerDefinitionOutput) LogConfiguration 

func (o TaskDefinitionContainerDefinitionOutput) LogConfiguration() TaskDefinitionLogConfigurationPtrOutput

The log configuration specification for the container. 

This parameter maps to ``LogConfig`` in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the ``--log-driver`` option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). By default, containers use the same logging driver that the Docker daemon uses. However, the container may use a different logging driver than the Docker daemon by specifying a log driver with this parameter in the container definition. To use a different logging driver for a container, the log system must be configured properly on the container instance (or on a different log server for remote logging options). For more information on the options for different supported log drivers, see [Configure logging drivers](https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/) in the Docker documentation.
 Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon (shown in the [LogConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html) data type). Additional log drivers may be available in future releases of the Amazon ECS container agent.
 This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: ``sudo docker version --format '{{.Server.APIVersion}}'``
 The Amazon ECS container agent running on a container instance must register the logging drivers available on that instance with the ``ECS_AVAILABLE_LOGGING_DRIVERS`` environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS Container Agent Configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionContainerDefinitionOutput) Memory 

func (o TaskDefinitionContainerDefinitionOutput) Memory() pulumi.IntPtrOutput

The amount (in MiB) of memory to present to the container. If your container attempts to exceed the memory specified here, the container is killed. The total amount of memory reserved for all containers within a task must be lower than the task “memory“ value, if one is specified. This parameter maps to “Memory“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--memory“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

If using the Fargate launch type, this parameter is optional.
If using the EC2 launch type, you must specify either a task-level memory value or a container-level memory value. If you specify both a container-level ``memory`` and ``memoryReservation`` value, ``memory`` must be greater than ``memoryReservation``. If you specify ``memoryReservation``, then that value is subtracted from the available memory resources for the container instance where the container is placed. Otherwise, the value of ``memory`` is used.
The Docker 20.10.0 or later daemon reserves a minimum of 6 MiB of memory for a container, so you should not specify fewer than 6 MiB of memory for your containers.
The Docker 19.03.13-ce or earlier daemon reserves a minimum of 4 MiB of memory for a container, so you should not specify fewer than 4 MiB of memory for your containers.

func (TaskDefinitionContainerDefinitionOutput) MemoryReservation 

func (o TaskDefinitionContainerDefinitionOutput) MemoryReservation() pulumi.IntPtrOutput

The soft limit (in MiB) of memory to reserve for the container. When system memory is under heavy contention, Docker attempts to keep the container memory to this soft limit. However, your container can consume more memory when it needs to, up to either the hard limit specified with the “memory“ parameter (if applicable), or all of the available memory on the container instance, whichever comes first. This parameter maps to “MemoryReservation“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--memory-reservation“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

If a task-level memory value is not specified, you must specify a non-zero integer for one or both of ``memory`` or ``memoryReservation`` in a container definition. If you specify both, ``memory`` must be greater than ``memoryReservation``. If you specify ``memoryReservation``, then that value is subtracted from the available memory resources for the container instance where the container is placed. Otherwise, the value of ``memory`` is used.
For example, if your container normally uses 128 MiB of memory, but occasionally bursts to 256 MiB of memory for short periods of time, you can set a ``memoryReservation`` of 128 MiB, and a ``memory`` hard limit of 300 MiB. This configuration would allow the container to only reserve 128 MiB of memory from the remaining resources on the container instance, but also allow the container to consume more memory resources when needed.
The Docker 20.10.0 or later daemon reserves a minimum of 6 MiB of memory for a container. So, don't specify less than 6 MiB of memory for your containers.
The Docker 19.03.13-ce or earlier daemon reserves a minimum of 4 MiB of memory for a container. So, don't specify less than 4 MiB of memory for your containers.

func (TaskDefinitionContainerDefinitionOutput) MountPoints 

func (o TaskDefinitionContainerDefinitionOutput) MountPoints() TaskDefinitionMountPointArrayOutput

The mount points for data volumes in your container. 

This parameter maps to ``Volumes`` in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the ``--volume`` option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
Windows containers can mount whole directories on the same drive as ``$env:ProgramData``. Windows containers can't mount directories on a different drive, and mount point can't be across drives.

func (TaskDefinitionContainerDefinitionOutput) Name 

func (o TaskDefinitionContainerDefinitionOutput) Name() pulumi.StringOutput

The name of a container. If you're linking multiple containers together in a task definition, the “name“ of one container can be entered in the “links“ of another container to connect the containers. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. This parameter maps to “name“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--name“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).

func (TaskDefinitionContainerDefinitionOutput) PortMappings 

func (o TaskDefinitionContainerDefinitionOutput) PortMappings() TaskDefinitionPortMappingArrayOutput

The list of port mappings for the container. Port mappings allow containers to access ports on the host container instance to send or receive traffic. 

For task definitions that use the ``awsvpc`` network mode, you should only specify the ``containerPort``. The ``hostPort`` can be left blank or it must be the same value as the ``containerPort``.
Port mappings on Windows use the ``NetNAT`` gateway address rather than ``localhost``. There is no loopback for port mappings on Windows, so you cannot access a container's mapped port from the host itself.
This parameter maps to ``PortBindings`` in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the ``--publish`` option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). If the network mode of a task definition is set to ``none``, then you can't specify port mappings. If the network mode of a task definition is set to ``host``, then host ports must either be undefined or they must match the container port in the port mapping.
 After a task reaches the ``RUNNING`` status, manual and automatic host and container port assignments are visible in the *Network Bindings* section of a container description for a selected task in the Amazon ECS console. The assignments are also visible in the ``networkBindings`` section [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) responses.

func (TaskDefinitionContainerDefinitionOutput) Privileged 

func (o TaskDefinitionContainerDefinitionOutput) Privileged() pulumi.BoolPtrOutput

When this parameter is true, the container is given elevated privileges on the host container instance (similar to the “root“ user). This parameter maps to “Privileged“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--privileged“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

This parameter is not supported for Windows containers or tasks run on FARGATElong.

func (TaskDefinitionContainerDefinitionOutput) PseudoTerminal 

func (o TaskDefinitionContainerDefinitionOutput) PseudoTerminal() pulumi.BoolPtrOutput

When this parameter is “true“, a TTY is allocated. This parameter maps to “Tty“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--tty“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).

func (TaskDefinitionContainerDefinitionOutput) ReadonlyRootFilesystem 

func (o TaskDefinitionContainerDefinitionOutput) ReadonlyRootFilesystem() pulumi.BoolPtrOutput

When this parameter is true, the container is given read-only access to its root file system. This parameter maps to “ReadonlyRootfs“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--read-only“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

This parameter is not supported for Windows containers.

func (TaskDefinitionContainerDefinitionOutput) RepositoryCredentials 

func (o TaskDefinitionContainerDefinitionOutput) RepositoryCredentials() TaskDefinitionRepositoryCredentialsPtrOutput

The private repository authentication credentials to use.

func (TaskDefinitionContainerDefinitionOutput) ResourceRequirements 

func (o TaskDefinitionContainerDefinitionOutput) ResourceRequirements() TaskDefinitionResourceRequirementArrayOutput

The type and amount of a resource to assign to a container. The only supported resource is a GPU.

func (TaskDefinitionContainerDefinitionOutput) Secrets 

func (o TaskDefinitionContainerDefinitionOutput) Secrets() TaskDefinitionSecretArrayOutput

The secrets to pass to the container. For more information, see [Specifying Sensitive Data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionContainerDefinitionOutput) StartTimeout 

func (o TaskDefinitionContainerDefinitionOutput) StartTimeout() pulumi.IntPtrOutput

Time duration (in seconds) to wait before giving up on resolving dependencies for a container. For example, you specify two containers in a task definition with containerA having a dependency on containerB reaching a “COMPLETE“, “SUCCESS“, or “HEALTHY“ status. If a “startTimeout“ value is specified for containerB and it doesn't reach the desired status within that time then containerA gives up and not start. This results in the task transitioning to a “STOPPED“ state. 

 When the ``ECS_CONTAINER_START_TIMEOUT`` container agent configuration variable is used, it's enforced independently from this start timeout value.
 For tasks using the Fargate launch type, the task or service requires the following platforms:
 +  Linux platform version ``1.3.0`` or later.
 +  Windows platform version ``1.0.0`` or later.

For tasks using the EC2 launch type, your container instances require at least version ``1.26.0`` of the container agent to use a container start timeout value. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version ``1.26.0-1`` of the ``ecs-init`` package. If your container instances are launched from version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
The valid values are 2-120 seconds.

func (TaskDefinitionContainerDefinitionOutput) StopTimeout 

func (o TaskDefinitionContainerDefinitionOutput) StopTimeout() pulumi.IntPtrOutput

Time duration (in seconds) to wait before the container is forcefully killed if it doesn't exit normally on its own. 

For tasks using the Fargate launch type, the task or service requires the following platforms:
 +  Linux platform version ``1.3.0`` or later.
 +  Windows platform version ``1.0.0`` or later.

The max stop timeout value is 120 seconds and if the parameter is not specified, the default value of 30 seconds is used.
For tasks that use the EC2 launch type, if the ``stopTimeout`` parameter isn't specified, the value set for the Amazon ECS container agent configuration variable ``ECS_CONTAINER_STOP_TIMEOUT`` is used. If neither the ``stopTimeout`` parameter or the ``ECS_CONTAINER_STOP_TIMEOUT`` agent configuration variable are set, then the default values of 30 seconds for Linux containers and 30 seconds on Windows containers are used. Your container instances require at least version 1.26.0 of the container agent to use a container stop timeout value. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the ``ecs-init`` package. If your container instances are launched from version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
The valid values are 2-120 seconds.

func (TaskDefinitionContainerDefinitionOutput) SystemControls 

func (o TaskDefinitionContainerDefinitionOutput) SystemControls() TaskDefinitionSystemControlArrayOutput

A list of namespaced kernel parameters to set in the container. This parameter maps to “Sysctls“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--sysctl“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For example, you can configure “net.ipv4.tcp_keepalive_time“ setting to maintain longer lived connections.

func (TaskDefinitionContainerDefinitionOutput) ToTaskDefinitionContainerDefinitionOutput 

func (o TaskDefinitionContainerDefinitionOutput) ToTaskDefinitionContainerDefinitionOutput() TaskDefinitionContainerDefinitionOutput

func (TaskDefinitionContainerDefinitionOutput) ToTaskDefinitionContainerDefinitionOutputWithContext 

func (o TaskDefinitionContainerDefinitionOutput) ToTaskDefinitionContainerDefinitionOutputWithContext(ctx context.Context) TaskDefinitionContainerDefinitionOutput

func (TaskDefinitionContainerDefinitionOutput) Ulimits 

func (o TaskDefinitionContainerDefinitionOutput) Ulimits() TaskDefinitionUlimitArrayOutput

A list of “ulimits“ to set in the container. This parameter maps to “Ulimits“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--ulimit“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). Valid naming values are displayed in the [Ulimit](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Ulimit.html) data type. This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“ 

This parameter is not supported for Windows containers.

func (TaskDefinitionContainerDefinitionOutput) User 

func (o TaskDefinitionContainerDefinitionOutput) User() pulumi.StringPtrOutput

The user to use inside the container. This parameter maps to “User“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--user“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

When running tasks using the ``host`` network mode, don't run containers using the root user (UID 0). We recommend using a non-root user for better security.
You can specify the ``user`` using the following formats. If specifying a UID or GID, you must specify it as a positive integer.
+   ``user``
+   ``user:group``
+   ``uid``
+   ``uid:gid``
+   ``user:gid``
+   ``uid:group``

This parameter is not supported for Windows containers.

func (TaskDefinitionContainerDefinitionOutput) VolumesFrom 

func (o TaskDefinitionContainerDefinitionOutput) VolumesFrom() TaskDefinitionVolumeFromArrayOutput

Data volumes to mount from another container. This parameter maps to “VolumesFrom“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--volumes-from“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).

func (TaskDefinitionContainerDefinitionOutput) WorkingDirectory 

func (o TaskDefinitionContainerDefinitionOutput) WorkingDirectory() pulumi.StringPtrOutput

The working directory to run commands inside the container in. This parameter maps to “WorkingDir“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--workdir“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).

type TaskDefinitionContainerDependency 

type TaskDefinitionContainerDependency struct {
	// The dependency condition of the container. The following are the available conditions and their behavior:
	//   +   “START“ - This condition emulates the behavior of links and volumes today. It validates that a dependent container is started before permitting other containers to start.
	//   +   “COMPLETE“ - This condition validates that a dependent container runs to completion (exits) before permitting other containers to start. This can be useful for nonessential containers that run a script and then exit. This condition can't be set on an essential container.
	//   +   “SUCCESS“ - This condition is the same as “COMPLETE“, but it also requires that the container exits with a “zero“ status. This condition can't be set on an essential container.
	//   +   “HEALTHY“ - This condition validates that the dependent container passes its Docker health check before permitting other containers to start. This requires that the dependent container has health checks configured. This condition is confirmed only at task startup.
	Condition *string `pulumi:"condition"`
	// The name of a container.
	ContainerName *string `pulumi:"containerName"`
}

The “ContainerDependency“ property specifies the dependencies defined for container startup and shutdown. A container can contain multiple dependencies. When a dependency is defined for container startup, for container shutdown it is reversed. 

Your Amazon ECS container instances require at least version 1.26.0 of the container agent to enable container dependencies. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you are using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the ``ecs-init`` package. If your container instances are launched from version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
 For tasks using the Fargate launch type, this parameter requires that the task or service uses platform version 1.3.0 or later.

type TaskDefinitionContainerDependencyArgs 

type TaskDefinitionContainerDependencyArgs struct {
	// The dependency condition of the container. The following are the available conditions and their behavior:
	//   +   “START“ - This condition emulates the behavior of links and volumes today. It validates that a dependent container is started before permitting other containers to start.
	//   +   “COMPLETE“ - This condition validates that a dependent container runs to completion (exits) before permitting other containers to start. This can be useful for nonessential containers that run a script and then exit. This condition can't be set on an essential container.
	//   +   “SUCCESS“ - This condition is the same as “COMPLETE“, but it also requires that the container exits with a “zero“ status. This condition can't be set on an essential container.
	//   +   “HEALTHY“ - This condition validates that the dependent container passes its Docker health check before permitting other containers to start. This requires that the dependent container has health checks configured. This condition is confirmed only at task startup.
	Condition pulumi.StringPtrInput `pulumi:"condition"`
	// The name of a container.
	ContainerName pulumi.StringPtrInput `pulumi:"containerName"`
}

The “ContainerDependency“ property specifies the dependencies defined for container startup and shutdown. A container can contain multiple dependencies. When a dependency is defined for container startup, for container shutdown it is reversed. 

Your Amazon ECS container instances require at least version 1.26.0 of the container agent to enable container dependencies. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you are using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the ``ecs-init`` package. If your container instances are launched from version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
 For tasks using the Fargate launch type, this parameter requires that the task or service uses platform version 1.3.0 or later.

func (TaskDefinitionContainerDependencyArgs) ElementType 

func (TaskDefinitionContainerDependencyArgs) ElementType() reflect.Type

func (TaskDefinitionContainerDependencyArgs) ToTaskDefinitionContainerDependencyOutput 

func (i TaskDefinitionContainerDependencyArgs) ToTaskDefinitionContainerDependencyOutput() TaskDefinitionContainerDependencyOutput

func (TaskDefinitionContainerDependencyArgs) ToTaskDefinitionContainerDependencyOutputWithContext 

func (i TaskDefinitionContainerDependencyArgs) ToTaskDefinitionContainerDependencyOutputWithContext(ctx context.Context) TaskDefinitionContainerDependencyOutput

type TaskDefinitionContainerDependencyArray 

type TaskDefinitionContainerDependencyArray []TaskDefinitionContainerDependencyInput

func (TaskDefinitionContainerDependencyArray) ElementType 

func (TaskDefinitionContainerDependencyArray) ElementType() reflect.Type

func (TaskDefinitionContainerDependencyArray) ToTaskDefinitionContainerDependencyArrayOutput 

func (i TaskDefinitionContainerDependencyArray) ToTaskDefinitionContainerDependencyArrayOutput() TaskDefinitionContainerDependencyArrayOutput

func (TaskDefinitionContainerDependencyArray) ToTaskDefinitionContainerDependencyArrayOutputWithContext 

func (i TaskDefinitionContainerDependencyArray) ToTaskDefinitionContainerDependencyArrayOutputWithContext(ctx context.Context) TaskDefinitionContainerDependencyArrayOutput

type TaskDefinitionContainerDependencyArrayInput 

type TaskDefinitionContainerDependencyArrayInput interface {
	pulumi.Input

	ToTaskDefinitionContainerDependencyArrayOutput() TaskDefinitionContainerDependencyArrayOutput
	ToTaskDefinitionContainerDependencyArrayOutputWithContext(context.Context) TaskDefinitionContainerDependencyArrayOutput
}

TaskDefinitionContainerDependencyArrayInput is an input type that accepts TaskDefinitionContainerDependencyArray and TaskDefinitionContainerDependencyArrayOutput values. You can construct a concrete instance of `TaskDefinitionContainerDependencyArrayInput` via: 

TaskDefinitionContainerDependencyArray{ TaskDefinitionContainerDependencyArgs{...} }

type TaskDefinitionContainerDependencyArrayOutput 

type TaskDefinitionContainerDependencyArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionContainerDependencyArrayOutput) ElementType 

func (TaskDefinitionContainerDependencyArrayOutput) ElementType() reflect.Type

func (TaskDefinitionContainerDependencyArrayOutput) Index 

func (o TaskDefinitionContainerDependencyArrayOutput) Index(i pulumi.IntInput) TaskDefinitionContainerDependencyOutput

func (TaskDefinitionContainerDependencyArrayOutput) ToTaskDefinitionContainerDependencyArrayOutput 

func (o TaskDefinitionContainerDependencyArrayOutput) ToTaskDefinitionContainerDependencyArrayOutput() TaskDefinitionContainerDependencyArrayOutput

func (TaskDefinitionContainerDependencyArrayOutput) ToTaskDefinitionContainerDependencyArrayOutputWithContext 

func (o TaskDefinitionContainerDependencyArrayOutput) ToTaskDefinitionContainerDependencyArrayOutputWithContext(ctx context.Context) TaskDefinitionContainerDependencyArrayOutput

type TaskDefinitionContainerDependencyInput 

type TaskDefinitionContainerDependencyInput interface {
	pulumi.Input

	ToTaskDefinitionContainerDependencyOutput() TaskDefinitionContainerDependencyOutput
	ToTaskDefinitionContainerDependencyOutputWithContext(context.Context) TaskDefinitionContainerDependencyOutput
}

TaskDefinitionContainerDependencyInput is an input type that accepts TaskDefinitionContainerDependencyArgs and TaskDefinitionContainerDependencyOutput values. You can construct a concrete instance of `TaskDefinitionContainerDependencyInput` via: 

TaskDefinitionContainerDependencyArgs{...}

type TaskDefinitionContainerDependencyOutput 

type TaskDefinitionContainerDependencyOutput struct{ *pulumi.OutputState }

The “ContainerDependency“ property specifies the dependencies defined for container startup and shutdown. A container can contain multiple dependencies. When a dependency is defined for container startup, for container shutdown it is reversed. 

Your Amazon ECS container instances require at least version 1.26.0 of the container agent to enable container dependencies. However, we recommend using the latest container agent version. For information about checking your agent version and updating to the latest version, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you are using an Amazon ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the ``ecs-init`` package. If your container instances are launched from version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.
 For tasks using the Fargate launch type, this parameter requires that the task or service uses platform version 1.3.0 or later.

func (TaskDefinitionContainerDependencyOutput) Condition 

func (o TaskDefinitionContainerDependencyOutput) Condition() pulumi.StringPtrOutput

The dependency condition of the container. The following are the available conditions and their behavior:

  • “START“ - This condition emulates the behavior of links and volumes today. It validates that a dependent container is started before permitting other containers to start.
  • “COMPLETE“ - This condition validates that a dependent container runs to completion (exits) before permitting other containers to start. This can be useful for nonessential containers that run a script and then exit. This condition can't be set on an essential container.
  • “SUCCESS“ - This condition is the same as “COMPLETE“, but it also requires that the container exits with a “zero“ status. This condition can't be set on an essential container.
  • “HEALTHY“ - This condition validates that the dependent container passes its Docker health check before permitting other containers to start. This requires that the dependent container has health checks configured. This condition is confirmed only at task startup.

func (TaskDefinitionContainerDependencyOutput) ContainerName 

func (o TaskDefinitionContainerDependencyOutput) ContainerName() pulumi.StringPtrOutput

The name of a container.

func (TaskDefinitionContainerDependencyOutput) ElementType 

func (TaskDefinitionContainerDependencyOutput) ElementType() reflect.Type

func (TaskDefinitionContainerDependencyOutput) ToTaskDefinitionContainerDependencyOutput 

func (o TaskDefinitionContainerDependencyOutput) ToTaskDefinitionContainerDependencyOutput() TaskDefinitionContainerDependencyOutput

func (TaskDefinitionContainerDependencyOutput) ToTaskDefinitionContainerDependencyOutputWithContext 

func (o TaskDefinitionContainerDependencyOutput) ToTaskDefinitionContainerDependencyOutputWithContext(ctx context.Context) TaskDefinitionContainerDependencyOutput

type TaskDefinitionDevice 

type TaskDefinitionDevice struct {
	// The path inside the container at which to expose the host device.
	ContainerPath *string `pulumi:"containerPath"`
	// The path for the device on the host container instance.
	HostPath *string `pulumi:"hostPath"`
	// The explicit permissions to provide to the container for the device. By default, the container has permissions for “read“, “write“, and “mknod“ for the device.
	Permissions []string `pulumi:"permissions"`
}

The “Device“ property specifies an object representing a container instance host device.

type TaskDefinitionDeviceArgs 

type TaskDefinitionDeviceArgs struct {
	// The path inside the container at which to expose the host device.
	ContainerPath pulumi.StringPtrInput `pulumi:"containerPath"`
	// The path for the device on the host container instance.
	HostPath pulumi.StringPtrInput `pulumi:"hostPath"`
	// The explicit permissions to provide to the container for the device. By default, the container has permissions for “read“, “write“, and “mknod“ for the device.
	Permissions pulumi.StringArrayInput `pulumi:"permissions"`
}

The “Device“ property specifies an object representing a container instance host device.

func (TaskDefinitionDeviceArgs) ElementType 

func (TaskDefinitionDeviceArgs) ElementType() reflect.Type

func (TaskDefinitionDeviceArgs) ToTaskDefinitionDeviceOutput 

func (i TaskDefinitionDeviceArgs) ToTaskDefinitionDeviceOutput() TaskDefinitionDeviceOutput

func (TaskDefinitionDeviceArgs) ToTaskDefinitionDeviceOutputWithContext 

func (i TaskDefinitionDeviceArgs) ToTaskDefinitionDeviceOutputWithContext(ctx context.Context) TaskDefinitionDeviceOutput

type TaskDefinitionDeviceArray 

type TaskDefinitionDeviceArray []TaskDefinitionDeviceInput

func (TaskDefinitionDeviceArray) ElementType 

func (TaskDefinitionDeviceArray) ElementType() reflect.Type

func (TaskDefinitionDeviceArray) ToTaskDefinitionDeviceArrayOutput 

func (i TaskDefinitionDeviceArray) ToTaskDefinitionDeviceArrayOutput() TaskDefinitionDeviceArrayOutput

func (TaskDefinitionDeviceArray) ToTaskDefinitionDeviceArrayOutputWithContext 

func (i TaskDefinitionDeviceArray) ToTaskDefinitionDeviceArrayOutputWithContext(ctx context.Context) TaskDefinitionDeviceArrayOutput

type TaskDefinitionDeviceArrayInput 

type TaskDefinitionDeviceArrayInput interface {
	pulumi.Input

	ToTaskDefinitionDeviceArrayOutput() TaskDefinitionDeviceArrayOutput
	ToTaskDefinitionDeviceArrayOutputWithContext(context.Context) TaskDefinitionDeviceArrayOutput
}

TaskDefinitionDeviceArrayInput is an input type that accepts TaskDefinitionDeviceArray and TaskDefinitionDeviceArrayOutput values. You can construct a concrete instance of `TaskDefinitionDeviceArrayInput` via: 

TaskDefinitionDeviceArray{ TaskDefinitionDeviceArgs{...} }

type TaskDefinitionDeviceArrayOutput 

type TaskDefinitionDeviceArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionDeviceArrayOutput) ElementType 

func (TaskDefinitionDeviceArrayOutput) ElementType() reflect.Type

func (TaskDefinitionDeviceArrayOutput) Index 

func (o TaskDefinitionDeviceArrayOutput) Index(i pulumi.IntInput) TaskDefinitionDeviceOutput

func (TaskDefinitionDeviceArrayOutput) ToTaskDefinitionDeviceArrayOutput 

func (o TaskDefinitionDeviceArrayOutput) ToTaskDefinitionDeviceArrayOutput() TaskDefinitionDeviceArrayOutput

func (TaskDefinitionDeviceArrayOutput) ToTaskDefinitionDeviceArrayOutputWithContext 

func (o TaskDefinitionDeviceArrayOutput) ToTaskDefinitionDeviceArrayOutputWithContext(ctx context.Context) TaskDefinitionDeviceArrayOutput

type TaskDefinitionDeviceInput 

type TaskDefinitionDeviceInput interface {
	pulumi.Input

	ToTaskDefinitionDeviceOutput() TaskDefinitionDeviceOutput
	ToTaskDefinitionDeviceOutputWithContext(context.Context) TaskDefinitionDeviceOutput
}

TaskDefinitionDeviceInput is an input type that accepts TaskDefinitionDeviceArgs and TaskDefinitionDeviceOutput values. You can construct a concrete instance of `TaskDefinitionDeviceInput` via: 

TaskDefinitionDeviceArgs{...}

type TaskDefinitionDeviceOutput 

type TaskDefinitionDeviceOutput struct{ *pulumi.OutputState }

The “Device“ property specifies an object representing a container instance host device.

func (TaskDefinitionDeviceOutput) ContainerPath 

func (o TaskDefinitionDeviceOutput) ContainerPath() pulumi.StringPtrOutput

The path inside the container at which to expose the host device.

func (TaskDefinitionDeviceOutput) ElementType 

func (TaskDefinitionDeviceOutput) ElementType() reflect.Type

func (TaskDefinitionDeviceOutput) HostPath 

func (o TaskDefinitionDeviceOutput) HostPath() pulumi.StringPtrOutput

The path for the device on the host container instance.

func (TaskDefinitionDeviceOutput) Permissions 

func (o TaskDefinitionDeviceOutput) Permissions() pulumi.StringArrayOutput

The explicit permissions to provide to the container for the device. By default, the container has permissions for “read“, “write“, and “mknod“ for the device.

func (TaskDefinitionDeviceOutput) ToTaskDefinitionDeviceOutput 

func (o TaskDefinitionDeviceOutput) ToTaskDefinitionDeviceOutput() TaskDefinitionDeviceOutput

func (TaskDefinitionDeviceOutput) ToTaskDefinitionDeviceOutputWithContext 

func (o TaskDefinitionDeviceOutput) ToTaskDefinitionDeviceOutputWithContext(ctx context.Context) TaskDefinitionDeviceOutput

type TaskDefinitionDockerVolumeConfiguration 

type TaskDefinitionDockerVolumeConfiguration struct {
	// If this value is “true“, the Docker volume is created if it doesn't already exist.
	//   This field is only used if the “scope“ is “shared“.
	Autoprovision *bool `pulumi:"autoprovision"`
	// The Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement. If the driver was installed using the Docker plugin CLI, use “docker plugin ls“ to retrieve the driver name from your container instance. If the driver was installed using another method, use Docker plugin discovery to retrieve the driver name. For more information, see [Docker plugin discovery](https://docs.aws.amazon.com/https://docs.docker.com/engine/extend/plugin_api/#plugin-discovery). This parameter maps to “Driver“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxdriver“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).
	Driver *string `pulumi:"driver"`
	// A map of Docker driver-specific options passed through. This parameter maps to “DriverOpts“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxopt“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).
	DriverOpts map[string]string `pulumi:"driverOpts"`
	// Custom metadata to add to your Docker volume. This parameter maps to “Labels“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxlabel“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).
	Labels map[string]string `pulumi:"labels"`
	// The scope for the Docker volume that determines its lifecycle. Docker volumes that are scoped to a “task“ are automatically provisioned when the task starts and destroyed when the task stops. Docker volumes that are scoped as “shared“ persist after the task stops.
	Scope *string `pulumi:"scope"`
}

The “DockerVolumeConfiguration“ property specifies a Docker volume configuration and is used when you use Docker volumes. Docker volumes are only supported when you are using the EC2 launch type. Windows containers only support the use of the “local“ driver. To use bind mounts, specify a “host“ instead.

type TaskDefinitionDockerVolumeConfigurationArgs 

type TaskDefinitionDockerVolumeConfigurationArgs struct {
	// If this value is “true“, the Docker volume is created if it doesn't already exist.
	//   This field is only used if the “scope“ is “shared“.
	Autoprovision pulumi.BoolPtrInput `pulumi:"autoprovision"`
	// The Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement. If the driver was installed using the Docker plugin CLI, use “docker plugin ls“ to retrieve the driver name from your container instance. If the driver was installed using another method, use Docker plugin discovery to retrieve the driver name. For more information, see [Docker plugin discovery](https://docs.aws.amazon.com/https://docs.docker.com/engine/extend/plugin_api/#plugin-discovery). This parameter maps to “Driver“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxdriver“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).
	Driver pulumi.StringPtrInput `pulumi:"driver"`
	// A map of Docker driver-specific options passed through. This parameter maps to “DriverOpts“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxopt“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).
	DriverOpts pulumi.StringMapInput `pulumi:"driverOpts"`
	// Custom metadata to add to your Docker volume. This parameter maps to “Labels“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxlabel“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).
	Labels pulumi.StringMapInput `pulumi:"labels"`
	// The scope for the Docker volume that determines its lifecycle. Docker volumes that are scoped to a “task“ are automatically provisioned when the task starts and destroyed when the task stops. Docker volumes that are scoped as “shared“ persist after the task stops.
	Scope pulumi.StringPtrInput `pulumi:"scope"`
}

The “DockerVolumeConfiguration“ property specifies a Docker volume configuration and is used when you use Docker volumes. Docker volumes are only supported when you are using the EC2 launch type. Windows containers only support the use of the “local“ driver. To use bind mounts, specify a “host“ instead.

func (TaskDefinitionDockerVolumeConfigurationArgs) ElementType 

func (TaskDefinitionDockerVolumeConfigurationArgs) ElementType() reflect.Type

func (TaskDefinitionDockerVolumeConfigurationArgs) ToTaskDefinitionDockerVolumeConfigurationOutput 

func (i TaskDefinitionDockerVolumeConfigurationArgs) ToTaskDefinitionDockerVolumeConfigurationOutput() TaskDefinitionDockerVolumeConfigurationOutput

func (TaskDefinitionDockerVolumeConfigurationArgs) ToTaskDefinitionDockerVolumeConfigurationOutputWithContext 

func (i TaskDefinitionDockerVolumeConfigurationArgs) ToTaskDefinitionDockerVolumeConfigurationOutputWithContext(ctx context.Context) TaskDefinitionDockerVolumeConfigurationOutput

func (TaskDefinitionDockerVolumeConfigurationArgs) ToTaskDefinitionDockerVolumeConfigurationPtrOutput 

func (i TaskDefinitionDockerVolumeConfigurationArgs) ToTaskDefinitionDockerVolumeConfigurationPtrOutput() TaskDefinitionDockerVolumeConfigurationPtrOutput

func (TaskDefinitionDockerVolumeConfigurationArgs) ToTaskDefinitionDockerVolumeConfigurationPtrOutputWithContext 

func (i TaskDefinitionDockerVolumeConfigurationArgs) ToTaskDefinitionDockerVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionDockerVolumeConfigurationPtrOutput

type TaskDefinitionDockerVolumeConfigurationInput 

type TaskDefinitionDockerVolumeConfigurationInput interface {
	pulumi.Input

	ToTaskDefinitionDockerVolumeConfigurationOutput() TaskDefinitionDockerVolumeConfigurationOutput
	ToTaskDefinitionDockerVolumeConfigurationOutputWithContext(context.Context) TaskDefinitionDockerVolumeConfigurationOutput
}

TaskDefinitionDockerVolumeConfigurationInput is an input type that accepts TaskDefinitionDockerVolumeConfigurationArgs and TaskDefinitionDockerVolumeConfigurationOutput values. You can construct a concrete instance of `TaskDefinitionDockerVolumeConfigurationInput` via: 

TaskDefinitionDockerVolumeConfigurationArgs{...}

type TaskDefinitionDockerVolumeConfigurationOutput 

type TaskDefinitionDockerVolumeConfigurationOutput struct{ *pulumi.OutputState }

The “DockerVolumeConfiguration“ property specifies a Docker volume configuration and is used when you use Docker volumes. Docker volumes are only supported when you are using the EC2 launch type. Windows containers only support the use of the “local“ driver. To use bind mounts, specify a “host“ instead.

func (TaskDefinitionDockerVolumeConfigurationOutput) Autoprovision 

func (o TaskDefinitionDockerVolumeConfigurationOutput) Autoprovision() pulumi.BoolPtrOutput

If this value is “true“, the Docker volume is created if it doesn't already exist. 

This field is only used if the ``scope`` is ``shared``.

func (TaskDefinitionDockerVolumeConfigurationOutput) Driver 

func (o TaskDefinitionDockerVolumeConfigurationOutput) Driver() pulumi.StringPtrOutput

The Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement. If the driver was installed using the Docker plugin CLI, use “docker plugin ls“ to retrieve the driver name from your container instance. If the driver was installed using another method, use Docker plugin discovery to retrieve the driver name. For more information, see [Docker plugin discovery](https://docs.aws.amazon.com/https://docs.docker.com/engine/extend/plugin_api/#plugin-discovery). This parameter maps to “Driver“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxdriver“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).

func (TaskDefinitionDockerVolumeConfigurationOutput) DriverOpts 

func (o TaskDefinitionDockerVolumeConfigurationOutput) DriverOpts() pulumi.StringMapOutput

A map of Docker driver-specific options passed through. This parameter maps to “DriverOpts“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxopt“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).

func (TaskDefinitionDockerVolumeConfigurationOutput) ElementType 

func (TaskDefinitionDockerVolumeConfigurationOutput) ElementType() reflect.Type

func (TaskDefinitionDockerVolumeConfigurationOutput) Labels 

func (o TaskDefinitionDockerVolumeConfigurationOutput) Labels() pulumi.StringMapOutput

Custom metadata to add to your Docker volume. This parameter maps to “Labels“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxlabel“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).

func (TaskDefinitionDockerVolumeConfigurationOutput) Scope 

func (o TaskDefinitionDockerVolumeConfigurationOutput) Scope() pulumi.StringPtrOutput

The scope for the Docker volume that determines its lifecycle. Docker volumes that are scoped to a “task“ are automatically provisioned when the task starts and destroyed when the task stops. Docker volumes that are scoped as “shared“ persist after the task stops.

func (TaskDefinitionDockerVolumeConfigurationOutput) ToTaskDefinitionDockerVolumeConfigurationOutput 

func (o TaskDefinitionDockerVolumeConfigurationOutput) ToTaskDefinitionDockerVolumeConfigurationOutput() TaskDefinitionDockerVolumeConfigurationOutput

func (TaskDefinitionDockerVolumeConfigurationOutput) ToTaskDefinitionDockerVolumeConfigurationOutputWithContext 

func (o TaskDefinitionDockerVolumeConfigurationOutput) ToTaskDefinitionDockerVolumeConfigurationOutputWithContext(ctx context.Context) TaskDefinitionDockerVolumeConfigurationOutput

func (TaskDefinitionDockerVolumeConfigurationOutput) ToTaskDefinitionDockerVolumeConfigurationPtrOutput 

func (o TaskDefinitionDockerVolumeConfigurationOutput) ToTaskDefinitionDockerVolumeConfigurationPtrOutput() TaskDefinitionDockerVolumeConfigurationPtrOutput

func (TaskDefinitionDockerVolumeConfigurationOutput) ToTaskDefinitionDockerVolumeConfigurationPtrOutputWithContext 

func (o TaskDefinitionDockerVolumeConfigurationOutput) ToTaskDefinitionDockerVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionDockerVolumeConfigurationPtrOutput

type TaskDefinitionDockerVolumeConfigurationPtrInput 

type TaskDefinitionDockerVolumeConfigurationPtrInput interface {
	pulumi.Input

	ToTaskDefinitionDockerVolumeConfigurationPtrOutput() TaskDefinitionDockerVolumeConfigurationPtrOutput
	ToTaskDefinitionDockerVolumeConfigurationPtrOutputWithContext(context.Context) TaskDefinitionDockerVolumeConfigurationPtrOutput
}

TaskDefinitionDockerVolumeConfigurationPtrInput is an input type that accepts TaskDefinitionDockerVolumeConfigurationArgs, TaskDefinitionDockerVolumeConfigurationPtr and TaskDefinitionDockerVolumeConfigurationPtrOutput values. You can construct a concrete instance of `TaskDefinitionDockerVolumeConfigurationPtrInput` via: 

        TaskDefinitionDockerVolumeConfigurationArgs{...}

or:

        nil

func TaskDefinitionDockerVolumeConfigurationPtr 

func TaskDefinitionDockerVolumeConfigurationPtr(v *TaskDefinitionDockerVolumeConfigurationArgs) TaskDefinitionDockerVolumeConfigurationPtrInput

type TaskDefinitionDockerVolumeConfigurationPtrOutput 

type TaskDefinitionDockerVolumeConfigurationPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) Autoprovision 

func (o TaskDefinitionDockerVolumeConfigurationPtrOutput) Autoprovision() pulumi.BoolPtrOutput

If this value is “true“, the Docker volume is created if it doesn't already exist. 

This field is only used if the ``scope`` is ``shared``.

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) Driver 

func (o TaskDefinitionDockerVolumeConfigurationPtrOutput) Driver() pulumi.StringPtrOutput

The Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement. If the driver was installed using the Docker plugin CLI, use “docker plugin ls“ to retrieve the driver name from your container instance. If the driver was installed using another method, use Docker plugin discovery to retrieve the driver name. For more information, see [Docker plugin discovery](https://docs.aws.amazon.com/https://docs.docker.com/engine/extend/plugin_api/#plugin-discovery). This parameter maps to “Driver“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxdriver“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) DriverOpts 

func (o TaskDefinitionDockerVolumeConfigurationPtrOutput) DriverOpts() pulumi.StringMapOutput

A map of Docker driver-specific options passed through. This parameter maps to “DriverOpts“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxopt“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) Elem 

func (o TaskDefinitionDockerVolumeConfigurationPtrOutput) Elem() TaskDefinitionDockerVolumeConfigurationOutput

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) ElementType 

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) ElementType() reflect.Type

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) Labels 

func (o TaskDefinitionDockerVolumeConfigurationPtrOutput) Labels() pulumi.StringMapOutput

Custom metadata to add to your Docker volume. This parameter maps to “Labels“ in the [Create a volume](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/VolumeCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “xxlabel“ option to [docker volume create](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/commandline/volume_create/).

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) Scope 

func (o TaskDefinitionDockerVolumeConfigurationPtrOutput) Scope() pulumi.StringPtrOutput

The scope for the Docker volume that determines its lifecycle. Docker volumes that are scoped to a “task“ are automatically provisioned when the task starts and destroyed when the task stops. Docker volumes that are scoped as “shared“ persist after the task stops.

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) ToTaskDefinitionDockerVolumeConfigurationPtrOutput 

func (o TaskDefinitionDockerVolumeConfigurationPtrOutput) ToTaskDefinitionDockerVolumeConfigurationPtrOutput() TaskDefinitionDockerVolumeConfigurationPtrOutput

func (TaskDefinitionDockerVolumeConfigurationPtrOutput) ToTaskDefinitionDockerVolumeConfigurationPtrOutputWithContext 

func (o TaskDefinitionDockerVolumeConfigurationPtrOutput) ToTaskDefinitionDockerVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionDockerVolumeConfigurationPtrOutput

type TaskDefinitionEfsVolumeConfiguration added in v0.72.0 

type TaskDefinitionEfsVolumeConfiguration struct {
	// The authorization configuration details for the Amazon EFS file system.
	AuthorizationConfig *TaskDefinitionAuthorizationConfig `pulumi:"authorizationConfig"`
	// The Amazon EFS file system ID to use.
	FilesystemId string `pulumi:"filesystemId"`
	// The directory within the Amazon EFS file system to mount as the root directory inside the host. If this parameter is omitted, the root of the Amazon EFS volume will be used. Specifying “/“ will have the same effect as omitting this parameter.
	//   If an EFS access point is specified in the “authorizationConfig“, the root directory parameter must either be omitted or set to “/“ which will enforce the path set on the EFS access point.
	RootDirectory *string `pulumi:"rootDirectory"`
	// Determines whether to use encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be turned on if Amazon EFS IAM authorization is used. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Encrypting data in transit](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) in the *Amazon Elastic File System User Guide*.
	TransitEncryption *TaskDefinitionEfsVolumeConfigurationTransitEncryption `pulumi:"transitEncryption"`
	// The port to use when sending encrypted data between the Amazon ECS host and the Amazon EFS server. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses. For more information, see [EFS mount helper](https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html) in the *Amazon Elastic File System User Guide*.
	TransitEncryptionPort *int `pulumi:"transitEncryptionPort"`
}

This parameter is specified when you're using an Amazon Elastic File System file system for task storage. For more information, see [Amazon EFS volumes](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html) in the *Amazon Elastic Container Service Developer Guide*.

type TaskDefinitionEfsVolumeConfigurationArgs added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationArgs struct {
	// The authorization configuration details for the Amazon EFS file system.
	AuthorizationConfig TaskDefinitionAuthorizationConfigPtrInput `pulumi:"authorizationConfig"`
	// The Amazon EFS file system ID to use.
	FilesystemId pulumi.StringInput `pulumi:"filesystemId"`
	// The directory within the Amazon EFS file system to mount as the root directory inside the host. If this parameter is omitted, the root of the Amazon EFS volume will be used. Specifying “/“ will have the same effect as omitting this parameter.
	//   If an EFS access point is specified in the “authorizationConfig“, the root directory parameter must either be omitted or set to “/“ which will enforce the path set on the EFS access point.
	RootDirectory pulumi.StringPtrInput `pulumi:"rootDirectory"`
	// Determines whether to use encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be turned on if Amazon EFS IAM authorization is used. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Encrypting data in transit](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) in the *Amazon Elastic File System User Guide*.
	TransitEncryption TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrInput `pulumi:"transitEncryption"`
	// The port to use when sending encrypted data between the Amazon ECS host and the Amazon EFS server. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses. For more information, see [EFS mount helper](https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html) in the *Amazon Elastic File System User Guide*.
	TransitEncryptionPort pulumi.IntPtrInput `pulumi:"transitEncryptionPort"`
}

This parameter is specified when you're using an Amazon Elastic File System file system for task storage. For more information, see [Amazon EFS volumes](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionEfsVolumeConfigurationArgs) ElementType added in v0.72.0 

func (TaskDefinitionEfsVolumeConfigurationArgs) ElementType() reflect.Type

func (TaskDefinitionEfsVolumeConfigurationArgs) ToTaskDefinitionEfsVolumeConfigurationOutput added in v0.72.0 

func (i TaskDefinitionEfsVolumeConfigurationArgs) ToTaskDefinitionEfsVolumeConfigurationOutput() TaskDefinitionEfsVolumeConfigurationOutput

func (TaskDefinitionEfsVolumeConfigurationArgs) ToTaskDefinitionEfsVolumeConfigurationOutputWithContext added in v0.72.0 

func (i TaskDefinitionEfsVolumeConfigurationArgs) ToTaskDefinitionEfsVolumeConfigurationOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationOutput

func (TaskDefinitionEfsVolumeConfigurationArgs) ToTaskDefinitionEfsVolumeConfigurationPtrOutput added in v0.72.0 

func (i TaskDefinitionEfsVolumeConfigurationArgs) ToTaskDefinitionEfsVolumeConfigurationPtrOutput() TaskDefinitionEfsVolumeConfigurationPtrOutput

func (TaskDefinitionEfsVolumeConfigurationArgs) ToTaskDefinitionEfsVolumeConfigurationPtrOutputWithContext added in v0.72.0 

func (i TaskDefinitionEfsVolumeConfigurationArgs) ToTaskDefinitionEfsVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationPtrOutput

type TaskDefinitionEfsVolumeConfigurationInput added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationInput interface {
	pulumi.Input

	ToTaskDefinitionEfsVolumeConfigurationOutput() TaskDefinitionEfsVolumeConfigurationOutput
	ToTaskDefinitionEfsVolumeConfigurationOutputWithContext(context.Context) TaskDefinitionEfsVolumeConfigurationOutput
}

TaskDefinitionEfsVolumeConfigurationInput is an input type that accepts TaskDefinitionEfsVolumeConfigurationArgs and TaskDefinitionEfsVolumeConfigurationOutput values. You can construct a concrete instance of `TaskDefinitionEfsVolumeConfigurationInput` via: 

TaskDefinitionEfsVolumeConfigurationArgs{...}

type TaskDefinitionEfsVolumeConfigurationOutput added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationOutput struct{ *pulumi.OutputState }

This parameter is specified when you're using an Amazon Elastic File System file system for task storage. For more information, see [Amazon EFS volumes](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/efs-volumes.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionEfsVolumeConfigurationOutput) AuthorizationConfig added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) AuthorizationConfig() TaskDefinitionAuthorizationConfigPtrOutput

The authorization configuration details for the Amazon EFS file system.

func (TaskDefinitionEfsVolumeConfigurationOutput) ElementType added in v0.72.0 

func (TaskDefinitionEfsVolumeConfigurationOutput) ElementType() reflect.Type

func (TaskDefinitionEfsVolumeConfigurationOutput) FilesystemId added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) FilesystemId() pulumi.StringOutput

The Amazon EFS file system ID to use.

func (TaskDefinitionEfsVolumeConfigurationOutput) RootDirectory added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) RootDirectory() pulumi.StringPtrOutput

The directory within the Amazon EFS file system to mount as the root directory inside the host. If this parameter is omitted, the root of the Amazon EFS volume will be used. Specifying “/“ will have the same effect as omitting this parameter. 

If an EFS access point is specified in the ``authorizationConfig``, the root directory parameter must either be omitted or set to ``/`` which will enforce the path set on the EFS access point.

func (TaskDefinitionEfsVolumeConfigurationOutput) ToTaskDefinitionEfsVolumeConfigurationOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) ToTaskDefinitionEfsVolumeConfigurationOutput() TaskDefinitionEfsVolumeConfigurationOutput

func (TaskDefinitionEfsVolumeConfigurationOutput) ToTaskDefinitionEfsVolumeConfigurationOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) ToTaskDefinitionEfsVolumeConfigurationOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationOutput

func (TaskDefinitionEfsVolumeConfigurationOutput) ToTaskDefinitionEfsVolumeConfigurationPtrOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) ToTaskDefinitionEfsVolumeConfigurationPtrOutput() TaskDefinitionEfsVolumeConfigurationPtrOutput

func (TaskDefinitionEfsVolumeConfigurationOutput) ToTaskDefinitionEfsVolumeConfigurationPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) ToTaskDefinitionEfsVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationPtrOutput

func (TaskDefinitionEfsVolumeConfigurationOutput) TransitEncryption added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) TransitEncryption() TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput

Determines whether to use encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be turned on if Amazon EFS IAM authorization is used. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Encrypting data in transit](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) in the *Amazon Elastic File System User Guide*.

func (TaskDefinitionEfsVolumeConfigurationOutput) TransitEncryptionPort added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationOutput) TransitEncryptionPort() pulumi.IntPtrOutput

The port to use when sending encrypted data between the Amazon ECS host and the Amazon EFS server. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses. For more information, see [EFS mount helper](https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html) in the *Amazon Elastic File System User Guide*.

type TaskDefinitionEfsVolumeConfigurationPtrInput added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationPtrInput interface {
	pulumi.Input

	ToTaskDefinitionEfsVolumeConfigurationPtrOutput() TaskDefinitionEfsVolumeConfigurationPtrOutput
	ToTaskDefinitionEfsVolumeConfigurationPtrOutputWithContext(context.Context) TaskDefinitionEfsVolumeConfigurationPtrOutput
}

TaskDefinitionEfsVolumeConfigurationPtrInput is an input type that accepts TaskDefinitionEfsVolumeConfigurationArgs, TaskDefinitionEfsVolumeConfigurationPtr and TaskDefinitionEfsVolumeConfigurationPtrOutput values. You can construct a concrete instance of `TaskDefinitionEfsVolumeConfigurationPtrInput` via: 

        TaskDefinitionEfsVolumeConfigurationArgs{...}

or:

        nil

func TaskDefinitionEfsVolumeConfigurationPtr added in v0.72.0 

func TaskDefinitionEfsVolumeConfigurationPtr(v *TaskDefinitionEfsVolumeConfigurationArgs) TaskDefinitionEfsVolumeConfigurationPtrInput

type TaskDefinitionEfsVolumeConfigurationPtrOutput added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) AuthorizationConfig added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationPtrOutput) AuthorizationConfig() TaskDefinitionAuthorizationConfigPtrOutput

The authorization configuration details for the Amazon EFS file system.

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) Elem added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationPtrOutput) Elem() TaskDefinitionEfsVolumeConfigurationOutput

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) ElementType added in v0.72.0 

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) ElementType() reflect.Type

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) FilesystemId added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationPtrOutput) FilesystemId() pulumi.StringPtrOutput

The Amazon EFS file system ID to use.

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) RootDirectory added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationPtrOutput) RootDirectory() pulumi.StringPtrOutput

The directory within the Amazon EFS file system to mount as the root directory inside the host. If this parameter is omitted, the root of the Amazon EFS volume will be used. Specifying “/“ will have the same effect as omitting this parameter. 

If an EFS access point is specified in the ``authorizationConfig``, the root directory parameter must either be omitted or set to ``/`` which will enforce the path set on the EFS access point.

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) ToTaskDefinitionEfsVolumeConfigurationPtrOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationPtrOutput) ToTaskDefinitionEfsVolumeConfigurationPtrOutput() TaskDefinitionEfsVolumeConfigurationPtrOutput

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) ToTaskDefinitionEfsVolumeConfigurationPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationPtrOutput) ToTaskDefinitionEfsVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationPtrOutput

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) TransitEncryption added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationPtrOutput) TransitEncryption() TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput

Determines whether to use encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be turned on if Amazon EFS IAM authorization is used. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Encrypting data in transit](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) in the *Amazon Elastic File System User Guide*.

func (TaskDefinitionEfsVolumeConfigurationPtrOutput) TransitEncryptionPort added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationPtrOutput) TransitEncryptionPort() pulumi.IntPtrOutput

The port to use when sending encrypted data between the Amazon ECS host and the Amazon EFS server. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses. For more information, see [EFS mount helper](https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html) in the *Amazon Elastic File System User Guide*.

type TaskDefinitionEfsVolumeConfigurationTransitEncryption added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationTransitEncryption string

Determines whether to use encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be turned on if Amazon EFS IAM authorization is used. If this parameter is omitted, the default value of “DISABLED“ is used. For more information, see [Encrypting data in transit](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) in the *Amazon Elastic File System User Guide*.

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ElementType added in v0.72.0 

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ElementType() reflect.Type

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToStringOutput added in v0.72.0 

func (e TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToStringOutput() pulumi.StringOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToStringOutputWithContext added in v0.72.0 

func (e TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToStringPtrOutput added in v0.72.0 

func (e TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToStringPtrOutputWithContext added in v0.72.0 

func (e TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput added in v0.72.0 

func (e TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput() TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutputWithContext added in v0.72.0 

func (e TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput added in v0.72.0 

func (e TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput() TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutputWithContext added in v0.72.0 

func (e TaskDefinitionEfsVolumeConfigurationTransitEncryption) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput

type TaskDefinitionEfsVolumeConfigurationTransitEncryptionInput added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationTransitEncryptionInput interface {
	pulumi.Input

	ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput() TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput
	ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutputWithContext(context.Context) TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput
}

TaskDefinitionEfsVolumeConfigurationTransitEncryptionInput is an input type that accepts values of the TaskDefinitionEfsVolumeConfigurationTransitEncryption enum A concrete instance of `TaskDefinitionEfsVolumeConfigurationTransitEncryptionInput` can be one of the following: 

TaskDefinitionEfsVolumeConfigurationTransitEncryptionEnabled
TaskDefinitionEfsVolumeConfigurationTransitEncryptionDisabled

type TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput struct{ *pulumi.OutputState }

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ElementType added in v0.72.0 

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ElementType() reflect.Type

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToStringOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToStringOutput() pulumi.StringOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToStringOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToStringPtrOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToStringPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput() TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput() TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput

type TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrInput added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrInput interface {
	pulumi.Input

	ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput() TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput
	ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutputWithContext(context.Context) TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput
}

func TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtr added in v0.72.0 

func TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtr(v string) TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrInput

type TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput added in v0.72.0 

type TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) Elem added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) Elem() TaskDefinitionEfsVolumeConfigurationTransitEncryptionOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ElementType added in v0.72.0 

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ElementType() reflect.Type

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ToStringPtrOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ToStringPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput() TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput

func (TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutputWithContext added in v0.72.0 

func (o TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput) ToTaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutputWithContext(ctx context.Context) TaskDefinitionEfsVolumeConfigurationTransitEncryptionPtrOutput

type TaskDefinitionEnvironmentFile 

type TaskDefinitionEnvironmentFile struct {
	// The file type to use. Environment files are objects in Amazon S3. The only supported value is “s3“.
	Type *string `pulumi:"type"`
	// The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.
	Value *string `pulumi:"value"`
}

A list of files containing the environment variables to pass to a container. You can specify up to ten environment files. The file must have a “.env“ file extension. Each line in an environment file should contain an environment variable in “VARIABLE=VALUE“ format. Lines beginning with “#“ are treated as comments and are ignored. 

If there are environment variables specified using the ``environment`` parameter in a container definition, they take precedence over the variables contained within an environment file. If multiple environment files are specified that contain the same variable, they're processed from the top down. We recommend that you use unique variable names. For more information, see [Use a file to pass environment variables to a container](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/use-environment-file.html) in the *Amazon Elastic Container Service Developer Guide*.
Environment variable files are objects in Amazon S3 and all Amazon S3 security considerations apply.
You must use the following platforms for the Fargate launch type:
 +  Linux platform version ``1.4.0`` or later.
 +  Windows platform version ``1.0.0`` or later.

Consider the following when using the Fargate launch type:
 +  The file is handled like a native Docker env-file.
 +  There is no support for shell escape handling.
 +  The container entry point interperts the ``VARIABLE`` values.

type TaskDefinitionEnvironmentFileArgs 

type TaskDefinitionEnvironmentFileArgs struct {
	// The file type to use. Environment files are objects in Amazon S3. The only supported value is “s3“.
	Type pulumi.StringPtrInput `pulumi:"type"`
	// The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

A list of files containing the environment variables to pass to a container. You can specify up to ten environment files. The file must have a “.env“ file extension. Each line in an environment file should contain an environment variable in “VARIABLE=VALUE“ format. Lines beginning with “#“ are treated as comments and are ignored. 

If there are environment variables specified using the ``environment`` parameter in a container definition, they take precedence over the variables contained within an environment file. If multiple environment files are specified that contain the same variable, they're processed from the top down. We recommend that you use unique variable names. For more information, see [Use a file to pass environment variables to a container](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/use-environment-file.html) in the *Amazon Elastic Container Service Developer Guide*.
Environment variable files are objects in Amazon S3 and all Amazon S3 security considerations apply.
You must use the following platforms for the Fargate launch type:
 +  Linux platform version ``1.4.0`` or later.
 +  Windows platform version ``1.0.0`` or later.

Consider the following when using the Fargate launch type:
 +  The file is handled like a native Docker env-file.
 +  There is no support for shell escape handling.
 +  The container entry point interperts the ``VARIABLE`` values.

func (TaskDefinitionEnvironmentFileArgs) ElementType 

func (TaskDefinitionEnvironmentFileArgs) ElementType() reflect.Type

func (TaskDefinitionEnvironmentFileArgs) ToTaskDefinitionEnvironmentFileOutput 

func (i TaskDefinitionEnvironmentFileArgs) ToTaskDefinitionEnvironmentFileOutput() TaskDefinitionEnvironmentFileOutput

func (TaskDefinitionEnvironmentFileArgs) ToTaskDefinitionEnvironmentFileOutputWithContext 

func (i TaskDefinitionEnvironmentFileArgs) ToTaskDefinitionEnvironmentFileOutputWithContext(ctx context.Context) TaskDefinitionEnvironmentFileOutput

type TaskDefinitionEnvironmentFileArray 

type TaskDefinitionEnvironmentFileArray []TaskDefinitionEnvironmentFileInput

func (TaskDefinitionEnvironmentFileArray) ElementType 

func (TaskDefinitionEnvironmentFileArray) ElementType() reflect.Type

func (TaskDefinitionEnvironmentFileArray) ToTaskDefinitionEnvironmentFileArrayOutput 

func (i TaskDefinitionEnvironmentFileArray) ToTaskDefinitionEnvironmentFileArrayOutput() TaskDefinitionEnvironmentFileArrayOutput

func (TaskDefinitionEnvironmentFileArray) ToTaskDefinitionEnvironmentFileArrayOutputWithContext 

func (i TaskDefinitionEnvironmentFileArray) ToTaskDefinitionEnvironmentFileArrayOutputWithContext(ctx context.Context) TaskDefinitionEnvironmentFileArrayOutput

type TaskDefinitionEnvironmentFileArrayInput 

type TaskDefinitionEnvironmentFileArrayInput interface {
	pulumi.Input

	ToTaskDefinitionEnvironmentFileArrayOutput() TaskDefinitionEnvironmentFileArrayOutput
	ToTaskDefinitionEnvironmentFileArrayOutputWithContext(context.Context) TaskDefinitionEnvironmentFileArrayOutput
}

TaskDefinitionEnvironmentFileArrayInput is an input type that accepts TaskDefinitionEnvironmentFileArray and TaskDefinitionEnvironmentFileArrayOutput values. You can construct a concrete instance of `TaskDefinitionEnvironmentFileArrayInput` via: 

TaskDefinitionEnvironmentFileArray{ TaskDefinitionEnvironmentFileArgs{...} }

type TaskDefinitionEnvironmentFileArrayOutput 

type TaskDefinitionEnvironmentFileArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionEnvironmentFileArrayOutput) ElementType 

func (TaskDefinitionEnvironmentFileArrayOutput) ElementType() reflect.Type

func (TaskDefinitionEnvironmentFileArrayOutput) Index 

func (o TaskDefinitionEnvironmentFileArrayOutput) Index(i pulumi.IntInput) TaskDefinitionEnvironmentFileOutput

func (TaskDefinitionEnvironmentFileArrayOutput) ToTaskDefinitionEnvironmentFileArrayOutput 

func (o TaskDefinitionEnvironmentFileArrayOutput) ToTaskDefinitionEnvironmentFileArrayOutput() TaskDefinitionEnvironmentFileArrayOutput

func (TaskDefinitionEnvironmentFileArrayOutput) ToTaskDefinitionEnvironmentFileArrayOutputWithContext 

func (o TaskDefinitionEnvironmentFileArrayOutput) ToTaskDefinitionEnvironmentFileArrayOutputWithContext(ctx context.Context) TaskDefinitionEnvironmentFileArrayOutput

type TaskDefinitionEnvironmentFileInput 

type TaskDefinitionEnvironmentFileInput interface {
	pulumi.Input

	ToTaskDefinitionEnvironmentFileOutput() TaskDefinitionEnvironmentFileOutput
	ToTaskDefinitionEnvironmentFileOutputWithContext(context.Context) TaskDefinitionEnvironmentFileOutput
}

TaskDefinitionEnvironmentFileInput is an input type that accepts TaskDefinitionEnvironmentFileArgs and TaskDefinitionEnvironmentFileOutput values. You can construct a concrete instance of `TaskDefinitionEnvironmentFileInput` via: 

TaskDefinitionEnvironmentFileArgs{...}

type TaskDefinitionEnvironmentFileOutput 

type TaskDefinitionEnvironmentFileOutput struct{ *pulumi.OutputState }

A list of files containing the environment variables to pass to a container. You can specify up to ten environment files. The file must have a “.env“ file extension. Each line in an environment file should contain an environment variable in “VARIABLE=VALUE“ format. Lines beginning with “#“ are treated as comments and are ignored. 

If there are environment variables specified using the ``environment`` parameter in a container definition, they take precedence over the variables contained within an environment file. If multiple environment files are specified that contain the same variable, they're processed from the top down. We recommend that you use unique variable names. For more information, see [Use a file to pass environment variables to a container](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/use-environment-file.html) in the *Amazon Elastic Container Service Developer Guide*.
Environment variable files are objects in Amazon S3 and all Amazon S3 security considerations apply.
You must use the following platforms for the Fargate launch type:
 +  Linux platform version ``1.4.0`` or later.
 +  Windows platform version ``1.0.0`` or later.

Consider the following when using the Fargate launch type:
 +  The file is handled like a native Docker env-file.
 +  There is no support for shell escape handling.
 +  The container entry point interperts the ``VARIABLE`` values.

func (TaskDefinitionEnvironmentFileOutput) ElementType 

func (TaskDefinitionEnvironmentFileOutput) ElementType() reflect.Type

func (TaskDefinitionEnvironmentFileOutput) ToTaskDefinitionEnvironmentFileOutput 

func (o TaskDefinitionEnvironmentFileOutput) ToTaskDefinitionEnvironmentFileOutput() TaskDefinitionEnvironmentFileOutput

func (TaskDefinitionEnvironmentFileOutput) ToTaskDefinitionEnvironmentFileOutputWithContext 

func (o TaskDefinitionEnvironmentFileOutput) ToTaskDefinitionEnvironmentFileOutputWithContext(ctx context.Context) TaskDefinitionEnvironmentFileOutput

func (TaskDefinitionEnvironmentFileOutput) Type 

func (o TaskDefinitionEnvironmentFileOutput) Type() pulumi.StringPtrOutput

The file type to use. Environment files are objects in Amazon S3. The only supported value is “s3“.

func (TaskDefinitionEnvironmentFileOutput) Value 

func (o TaskDefinitionEnvironmentFileOutput) Value() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.

type TaskDefinitionEphemeralStorage 

type TaskDefinitionEphemeralStorage struct {
	// The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is “20“ GiB and the maximum supported value is “200“ GiB.
	SizeInGiB *int `pulumi:"sizeInGiB"`
}

The amount of ephemeral storage to allocate for the task. This parameter is used to expand the total amount of ephemeral storage available, beyond the default amount, for tasks hosted on FARGATElong. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html) in the *Amazon ECS Developer Guide;*. 

For tasks using the Fargate launch type, the task requires the following platforms:
+  Linux platform version ``1.4.0`` or later.
+  Windows platform version ``1.0.0`` or later.

type TaskDefinitionEphemeralStorageArgs 

type TaskDefinitionEphemeralStorageArgs struct {
	// The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is “20“ GiB and the maximum supported value is “200“ GiB.
	SizeInGiB pulumi.IntPtrInput `pulumi:"sizeInGiB"`
}

The amount of ephemeral storage to allocate for the task. This parameter is used to expand the total amount of ephemeral storage available, beyond the default amount, for tasks hosted on FARGATElong. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html) in the *Amazon ECS Developer Guide;*. 

For tasks using the Fargate launch type, the task requires the following platforms:
+  Linux platform version ``1.4.0`` or later.
+  Windows platform version ``1.0.0`` or later.

func (TaskDefinitionEphemeralStorageArgs) ElementType 

func (TaskDefinitionEphemeralStorageArgs) ElementType() reflect.Type

func (TaskDefinitionEphemeralStorageArgs) ToTaskDefinitionEphemeralStorageOutput 

func (i TaskDefinitionEphemeralStorageArgs) ToTaskDefinitionEphemeralStorageOutput() TaskDefinitionEphemeralStorageOutput

func (TaskDefinitionEphemeralStorageArgs) ToTaskDefinitionEphemeralStorageOutputWithContext 

func (i TaskDefinitionEphemeralStorageArgs) ToTaskDefinitionEphemeralStorageOutputWithContext(ctx context.Context) TaskDefinitionEphemeralStorageOutput

func (TaskDefinitionEphemeralStorageArgs) ToTaskDefinitionEphemeralStoragePtrOutput 

func (i TaskDefinitionEphemeralStorageArgs) ToTaskDefinitionEphemeralStoragePtrOutput() TaskDefinitionEphemeralStoragePtrOutput

func (TaskDefinitionEphemeralStorageArgs) ToTaskDefinitionEphemeralStoragePtrOutputWithContext 

func (i TaskDefinitionEphemeralStorageArgs) ToTaskDefinitionEphemeralStoragePtrOutputWithContext(ctx context.Context) TaskDefinitionEphemeralStoragePtrOutput

type TaskDefinitionEphemeralStorageInput 

type TaskDefinitionEphemeralStorageInput interface {
	pulumi.Input

	ToTaskDefinitionEphemeralStorageOutput() TaskDefinitionEphemeralStorageOutput
	ToTaskDefinitionEphemeralStorageOutputWithContext(context.Context) TaskDefinitionEphemeralStorageOutput
}

TaskDefinitionEphemeralStorageInput is an input type that accepts TaskDefinitionEphemeralStorageArgs and TaskDefinitionEphemeralStorageOutput values. You can construct a concrete instance of `TaskDefinitionEphemeralStorageInput` via: 

TaskDefinitionEphemeralStorageArgs{...}

type TaskDefinitionEphemeralStorageOutput 

type TaskDefinitionEphemeralStorageOutput struct{ *pulumi.OutputState }

The amount of ephemeral storage to allocate for the task. This parameter is used to expand the total amount of ephemeral storage available, beyond the default amount, for tasks hosted on FARGATElong. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html) in the *Amazon ECS Developer Guide;*. 

For tasks using the Fargate launch type, the task requires the following platforms:
+  Linux platform version ``1.4.0`` or later.
+  Windows platform version ``1.0.0`` or later.

func (TaskDefinitionEphemeralStorageOutput) ElementType 

func (TaskDefinitionEphemeralStorageOutput) ElementType() reflect.Type

func (TaskDefinitionEphemeralStorageOutput) SizeInGiB 

func (o TaskDefinitionEphemeralStorageOutput) SizeInGiB() pulumi.IntPtrOutput

The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is “20“ GiB and the maximum supported value is “200“ GiB.

func (TaskDefinitionEphemeralStorageOutput) ToTaskDefinitionEphemeralStorageOutput 

func (o TaskDefinitionEphemeralStorageOutput) ToTaskDefinitionEphemeralStorageOutput() TaskDefinitionEphemeralStorageOutput

func (TaskDefinitionEphemeralStorageOutput) ToTaskDefinitionEphemeralStorageOutputWithContext 

func (o TaskDefinitionEphemeralStorageOutput) ToTaskDefinitionEphemeralStorageOutputWithContext(ctx context.Context) TaskDefinitionEphemeralStorageOutput

func (TaskDefinitionEphemeralStorageOutput) ToTaskDefinitionEphemeralStoragePtrOutput 

func (o TaskDefinitionEphemeralStorageOutput) ToTaskDefinitionEphemeralStoragePtrOutput() TaskDefinitionEphemeralStoragePtrOutput

func (TaskDefinitionEphemeralStorageOutput) ToTaskDefinitionEphemeralStoragePtrOutputWithContext 

func (o TaskDefinitionEphemeralStorageOutput) ToTaskDefinitionEphemeralStoragePtrOutputWithContext(ctx context.Context) TaskDefinitionEphemeralStoragePtrOutput

type TaskDefinitionEphemeralStoragePtrInput 

type TaskDefinitionEphemeralStoragePtrInput interface {
	pulumi.Input

	ToTaskDefinitionEphemeralStoragePtrOutput() TaskDefinitionEphemeralStoragePtrOutput
	ToTaskDefinitionEphemeralStoragePtrOutputWithContext(context.Context) TaskDefinitionEphemeralStoragePtrOutput
}

TaskDefinitionEphemeralStoragePtrInput is an input type that accepts TaskDefinitionEphemeralStorageArgs, TaskDefinitionEphemeralStoragePtr and TaskDefinitionEphemeralStoragePtrOutput values. You can construct a concrete instance of `TaskDefinitionEphemeralStoragePtrInput` via: 

        TaskDefinitionEphemeralStorageArgs{...}

or:

        nil

func TaskDefinitionEphemeralStoragePtr 

func TaskDefinitionEphemeralStoragePtr(v *TaskDefinitionEphemeralStorageArgs) TaskDefinitionEphemeralStoragePtrInput

type TaskDefinitionEphemeralStoragePtrOutput 

type TaskDefinitionEphemeralStoragePtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionEphemeralStoragePtrOutput) Elem 

func (o TaskDefinitionEphemeralStoragePtrOutput) Elem() TaskDefinitionEphemeralStorageOutput

func (TaskDefinitionEphemeralStoragePtrOutput) ElementType 

func (TaskDefinitionEphemeralStoragePtrOutput) ElementType() reflect.Type

func (TaskDefinitionEphemeralStoragePtrOutput) SizeInGiB 

func (o TaskDefinitionEphemeralStoragePtrOutput) SizeInGiB() pulumi.IntPtrOutput

The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is “20“ GiB and the maximum supported value is “200“ GiB.

func (TaskDefinitionEphemeralStoragePtrOutput) ToTaskDefinitionEphemeralStoragePtrOutput 

func (o TaskDefinitionEphemeralStoragePtrOutput) ToTaskDefinitionEphemeralStoragePtrOutput() TaskDefinitionEphemeralStoragePtrOutput

func (TaskDefinitionEphemeralStoragePtrOutput) ToTaskDefinitionEphemeralStoragePtrOutputWithContext 

func (o TaskDefinitionEphemeralStoragePtrOutput) ToTaskDefinitionEphemeralStoragePtrOutputWithContext(ctx context.Context) TaskDefinitionEphemeralStoragePtrOutput

type TaskDefinitionFSxAuthorizationConfig added in v0.101.0 

type TaskDefinitionFSxAuthorizationConfig struct {
	CredentialsParameter string `pulumi:"credentialsParameter"`
	Domain               string `pulumi:"domain"`
}

type TaskDefinitionFSxAuthorizationConfigArgs added in v0.101.0 

type TaskDefinitionFSxAuthorizationConfigArgs struct {
	CredentialsParameter pulumi.StringInput `pulumi:"credentialsParameter"`
	Domain               pulumi.StringInput `pulumi:"domain"`
}

func (TaskDefinitionFSxAuthorizationConfigArgs) ElementType added in v0.101.0 

func (TaskDefinitionFSxAuthorizationConfigArgs) ElementType() reflect.Type

func (TaskDefinitionFSxAuthorizationConfigArgs) ToTaskDefinitionFSxAuthorizationConfigOutput added in v0.101.0 

func (i TaskDefinitionFSxAuthorizationConfigArgs) ToTaskDefinitionFSxAuthorizationConfigOutput() TaskDefinitionFSxAuthorizationConfigOutput

func (TaskDefinitionFSxAuthorizationConfigArgs) ToTaskDefinitionFSxAuthorizationConfigOutputWithContext added in v0.101.0 

func (i TaskDefinitionFSxAuthorizationConfigArgs) ToTaskDefinitionFSxAuthorizationConfigOutputWithContext(ctx context.Context) TaskDefinitionFSxAuthorizationConfigOutput

func (TaskDefinitionFSxAuthorizationConfigArgs) ToTaskDefinitionFSxAuthorizationConfigPtrOutput added in v0.101.0 

func (i TaskDefinitionFSxAuthorizationConfigArgs) ToTaskDefinitionFSxAuthorizationConfigPtrOutput() TaskDefinitionFSxAuthorizationConfigPtrOutput

func (TaskDefinitionFSxAuthorizationConfigArgs) ToTaskDefinitionFSxAuthorizationConfigPtrOutputWithContext added in v0.101.0 

func (i TaskDefinitionFSxAuthorizationConfigArgs) ToTaskDefinitionFSxAuthorizationConfigPtrOutputWithContext(ctx context.Context) TaskDefinitionFSxAuthorizationConfigPtrOutput

type TaskDefinitionFSxAuthorizationConfigInput added in v0.101.0 

type TaskDefinitionFSxAuthorizationConfigInput interface {
	pulumi.Input

	ToTaskDefinitionFSxAuthorizationConfigOutput() TaskDefinitionFSxAuthorizationConfigOutput
	ToTaskDefinitionFSxAuthorizationConfigOutputWithContext(context.Context) TaskDefinitionFSxAuthorizationConfigOutput
}

TaskDefinitionFSxAuthorizationConfigInput is an input type that accepts TaskDefinitionFSxAuthorizationConfigArgs and TaskDefinitionFSxAuthorizationConfigOutput values. You can construct a concrete instance of `TaskDefinitionFSxAuthorizationConfigInput` via: 

TaskDefinitionFSxAuthorizationConfigArgs{...}

type TaskDefinitionFSxAuthorizationConfigOutput added in v0.101.0 

type TaskDefinitionFSxAuthorizationConfigOutput struct{ *pulumi.OutputState }

func (TaskDefinitionFSxAuthorizationConfigOutput) CredentialsParameter added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigOutput) CredentialsParameter() pulumi.StringOutput

func (TaskDefinitionFSxAuthorizationConfigOutput) Domain added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigOutput) Domain() pulumi.StringOutput

func (TaskDefinitionFSxAuthorizationConfigOutput) ElementType added in v0.101.0 

func (TaskDefinitionFSxAuthorizationConfigOutput) ElementType() reflect.Type

func (TaskDefinitionFSxAuthorizationConfigOutput) ToTaskDefinitionFSxAuthorizationConfigOutput added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigOutput) ToTaskDefinitionFSxAuthorizationConfigOutput() TaskDefinitionFSxAuthorizationConfigOutput

func (TaskDefinitionFSxAuthorizationConfigOutput) ToTaskDefinitionFSxAuthorizationConfigOutputWithContext added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigOutput) ToTaskDefinitionFSxAuthorizationConfigOutputWithContext(ctx context.Context) TaskDefinitionFSxAuthorizationConfigOutput

func (TaskDefinitionFSxAuthorizationConfigOutput) ToTaskDefinitionFSxAuthorizationConfigPtrOutput added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigOutput) ToTaskDefinitionFSxAuthorizationConfigPtrOutput() TaskDefinitionFSxAuthorizationConfigPtrOutput

func (TaskDefinitionFSxAuthorizationConfigOutput) ToTaskDefinitionFSxAuthorizationConfigPtrOutputWithContext added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigOutput) ToTaskDefinitionFSxAuthorizationConfigPtrOutputWithContext(ctx context.Context) TaskDefinitionFSxAuthorizationConfigPtrOutput

type TaskDefinitionFSxAuthorizationConfigPtrInput added in v0.101.0 

type TaskDefinitionFSxAuthorizationConfigPtrInput interface {
	pulumi.Input

	ToTaskDefinitionFSxAuthorizationConfigPtrOutput() TaskDefinitionFSxAuthorizationConfigPtrOutput
	ToTaskDefinitionFSxAuthorizationConfigPtrOutputWithContext(context.Context) TaskDefinitionFSxAuthorizationConfigPtrOutput
}

TaskDefinitionFSxAuthorizationConfigPtrInput is an input type that accepts TaskDefinitionFSxAuthorizationConfigArgs, TaskDefinitionFSxAuthorizationConfigPtr and TaskDefinitionFSxAuthorizationConfigPtrOutput values. You can construct a concrete instance of `TaskDefinitionFSxAuthorizationConfigPtrInput` via: 

        TaskDefinitionFSxAuthorizationConfigArgs{...}

or:

        nil

func TaskDefinitionFSxAuthorizationConfigPtr added in v0.101.0 

func TaskDefinitionFSxAuthorizationConfigPtr(v *TaskDefinitionFSxAuthorizationConfigArgs) TaskDefinitionFSxAuthorizationConfigPtrInput

type TaskDefinitionFSxAuthorizationConfigPtrOutput added in v0.101.0 

type TaskDefinitionFSxAuthorizationConfigPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionFSxAuthorizationConfigPtrOutput) CredentialsParameter added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigPtrOutput) CredentialsParameter() pulumi.StringPtrOutput

func (TaskDefinitionFSxAuthorizationConfigPtrOutput) Domain added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigPtrOutput) Domain() pulumi.StringPtrOutput

func (TaskDefinitionFSxAuthorizationConfigPtrOutput) Elem added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigPtrOutput) Elem() TaskDefinitionFSxAuthorizationConfigOutput

func (TaskDefinitionFSxAuthorizationConfigPtrOutput) ElementType added in v0.101.0 

func (TaskDefinitionFSxAuthorizationConfigPtrOutput) ElementType() reflect.Type

func (TaskDefinitionFSxAuthorizationConfigPtrOutput) ToTaskDefinitionFSxAuthorizationConfigPtrOutput added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigPtrOutput) ToTaskDefinitionFSxAuthorizationConfigPtrOutput() TaskDefinitionFSxAuthorizationConfigPtrOutput

func (TaskDefinitionFSxAuthorizationConfigPtrOutput) ToTaskDefinitionFSxAuthorizationConfigPtrOutputWithContext added in v0.101.0 

func (o TaskDefinitionFSxAuthorizationConfigPtrOutput) ToTaskDefinitionFSxAuthorizationConfigPtrOutputWithContext(ctx context.Context) TaskDefinitionFSxAuthorizationConfigPtrOutput

type TaskDefinitionFSxWindowsFileServerVolumeConfiguration added in v0.101.0 

type TaskDefinitionFSxWindowsFileServerVolumeConfiguration struct {
	// The authorization configuration details for the Amazon FSx for Windows File Server file system.
	AuthorizationConfig *TaskDefinitionFSxAuthorizationConfig `pulumi:"authorizationConfig"`
	// The Amazon FSx for Windows File Server file system ID to use.
	FileSystemId string `pulumi:"fileSystemId"`
	// The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
	RootDirectory string `pulumi:"rootDirectory"`
}

This parameter is specified when you're using [Amazon FSx for Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) file system for task storage. 

For more information and the input format, see [Amazon FSx for Windows File Server volumes](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html) in the *Amazon Elastic Container Service Developer Guide*.

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs added in v0.101.0 

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs struct {
	// The authorization configuration details for the Amazon FSx for Windows File Server file system.
	AuthorizationConfig TaskDefinitionFSxAuthorizationConfigPtrInput `pulumi:"authorizationConfig"`
	// The Amazon FSx for Windows File Server file system ID to use.
	FileSystemId pulumi.StringInput `pulumi:"fileSystemId"`
	// The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
	RootDirectory pulumi.StringInput `pulumi:"rootDirectory"`
}

This parameter is specified when you're using [Amazon FSx for Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) file system for task storage. 

For more information and the input format, see [Amazon FSx for Windows File Server volumes](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ElementType added in v0.101.0 

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ElementType() reflect.Type

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput added in v0.101.0 

func (i TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput() TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutputWithContext added in v0.101.0 

func (i TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutputWithContext(ctx context.Context) TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput added in v0.101.0 

func (i TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput() TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutputWithContext added in v0.101.0 

func (i TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationInput added in v0.101.0 

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationInput interface {
	pulumi.Input

	ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput() TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput
	ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutputWithContext(context.Context) TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput
}

TaskDefinitionFSxWindowsFileServerVolumeConfigurationInput is an input type that accepts TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs and TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput values. You can construct a concrete instance of `TaskDefinitionFSxWindowsFileServerVolumeConfigurationInput` via: 

TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs{...}

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput added in v0.101.0 

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput struct{ *pulumi.OutputState }

This parameter is specified when you're using [Amazon FSx for Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) file system for task storage. 

For more information and the input format, see [Amazon FSx for Windows File Server volumes](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) AuthorizationConfig added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) AuthorizationConfig() TaskDefinitionFSxAuthorizationConfigPtrOutput

The authorization configuration details for the Amazon FSx for Windows File Server file system.

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ElementType added in v0.101.0 

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ElementType() reflect.Type

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) FileSystemId added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) FileSystemId() pulumi.StringOutput

The Amazon FSx for Windows File Server file system ID to use.

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) RootDirectory added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) RootDirectory() pulumi.StringOutput

The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput() TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutputWithContext added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationOutputWithContext(ctx context.Context) TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput() TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutputWithContext added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrInput added in v0.101.0 

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrInput interface {
	pulumi.Input

	ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput() TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput
	ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutputWithContext(context.Context) TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput
}

TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrInput is an input type that accepts TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs, TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtr and TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput values. You can construct a concrete instance of `TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrInput` via: 

        TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs{...}

or:

        nil

func TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtr added in v0.101.0 

func TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtr(v *TaskDefinitionFSxWindowsFileServerVolumeConfigurationArgs) TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrInput

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput added in v0.101.0 

type TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) AuthorizationConfig added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) AuthorizationConfig() TaskDefinitionFSxAuthorizationConfigPtrOutput

The authorization configuration details for the Amazon FSx for Windows File Server file system.

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) Elem added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) Elem() TaskDefinitionFSxWindowsFileServerVolumeConfigurationOutput

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) ElementType added in v0.101.0 

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) ElementType() reflect.Type

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) FileSystemId added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) FileSystemId() pulumi.StringPtrOutput

The Amazon FSx for Windows File Server file system ID to use.

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) RootDirectory added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) RootDirectory() pulumi.StringPtrOutput

The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput() TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput

func (TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutputWithContext added in v0.101.0 

func (o TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput) ToTaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput

type TaskDefinitionFirelensConfiguration 

type TaskDefinitionFirelensConfiguration struct {
	// The options to use when configuring the log router. This field is optional and can be used to add additional metadata, such as the task, task definition, cluster, and container instance details to the log event.
	//   If specified, valid option keys are:
	//   +   “enable-ecs-log-metadata“, which can be “true“ or “false“
	//   +   “config-file-type“, which can be “s3“ or “file“
	//   +   “config-file-value“, which is either an S3 ARN or a file path
	Options map[string]string `pulumi:"options"`
	// The log router to use. The valid values are “fluentd“ or “fluentbit“.
	Type *string `pulumi:"type"`
}

The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.

type TaskDefinitionFirelensConfigurationArgs 

type TaskDefinitionFirelensConfigurationArgs struct {
	// The options to use when configuring the log router. This field is optional and can be used to add additional metadata, such as the task, task definition, cluster, and container instance details to the log event.
	//   If specified, valid option keys are:
	//   +   “enable-ecs-log-metadata“, which can be “true“ or “false“
	//   +   “config-file-type“, which can be “s3“ or “file“
	//   +   “config-file-value“, which is either an S3 ARN or a file path
	Options pulumi.StringMapInput `pulumi:"options"`
	// The log router to use. The valid values are “fluentd“ or “fluentbit“.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionFirelensConfigurationArgs) ElementType 

func (TaskDefinitionFirelensConfigurationArgs) ElementType() reflect.Type

func (TaskDefinitionFirelensConfigurationArgs) ToTaskDefinitionFirelensConfigurationOutput 

func (i TaskDefinitionFirelensConfigurationArgs) ToTaskDefinitionFirelensConfigurationOutput() TaskDefinitionFirelensConfigurationOutput

func (TaskDefinitionFirelensConfigurationArgs) ToTaskDefinitionFirelensConfigurationOutputWithContext 

func (i TaskDefinitionFirelensConfigurationArgs) ToTaskDefinitionFirelensConfigurationOutputWithContext(ctx context.Context) TaskDefinitionFirelensConfigurationOutput

func (TaskDefinitionFirelensConfigurationArgs) ToTaskDefinitionFirelensConfigurationPtrOutput 

func (i TaskDefinitionFirelensConfigurationArgs) ToTaskDefinitionFirelensConfigurationPtrOutput() TaskDefinitionFirelensConfigurationPtrOutput

func (TaskDefinitionFirelensConfigurationArgs) ToTaskDefinitionFirelensConfigurationPtrOutputWithContext 

func (i TaskDefinitionFirelensConfigurationArgs) ToTaskDefinitionFirelensConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionFirelensConfigurationPtrOutput

type TaskDefinitionFirelensConfigurationInput 

type TaskDefinitionFirelensConfigurationInput interface {
	pulumi.Input

	ToTaskDefinitionFirelensConfigurationOutput() TaskDefinitionFirelensConfigurationOutput
	ToTaskDefinitionFirelensConfigurationOutputWithContext(context.Context) TaskDefinitionFirelensConfigurationOutput
}

TaskDefinitionFirelensConfigurationInput is an input type that accepts TaskDefinitionFirelensConfigurationArgs and TaskDefinitionFirelensConfigurationOutput values. You can construct a concrete instance of `TaskDefinitionFirelensConfigurationInput` via: 

TaskDefinitionFirelensConfigurationArgs{...}

type TaskDefinitionFirelensConfigurationOutput 

type TaskDefinitionFirelensConfigurationOutput struct{ *pulumi.OutputState }

The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionFirelensConfigurationOutput) ElementType 

func (TaskDefinitionFirelensConfigurationOutput) ElementType() reflect.Type

func (TaskDefinitionFirelensConfigurationOutput) Options 

func (o TaskDefinitionFirelensConfigurationOutput) Options() pulumi.StringMapOutput

The options to use when configuring the log router. This field is optional and can be used to add additional metadata, such as the task, task definition, cluster, and container instance details to the log event. 

If specified, valid option keys are:
+   ``enable-ecs-log-metadata``, which can be ``true`` or ``false``
+   ``config-file-type``, which can be ``s3`` or ``file``
+   ``config-file-value``, which is either an S3 ARN or a file path

func (TaskDefinitionFirelensConfigurationOutput) ToTaskDefinitionFirelensConfigurationOutput 

func (o TaskDefinitionFirelensConfigurationOutput) ToTaskDefinitionFirelensConfigurationOutput() TaskDefinitionFirelensConfigurationOutput

func (TaskDefinitionFirelensConfigurationOutput) ToTaskDefinitionFirelensConfigurationOutputWithContext 

func (o TaskDefinitionFirelensConfigurationOutput) ToTaskDefinitionFirelensConfigurationOutputWithContext(ctx context.Context) TaskDefinitionFirelensConfigurationOutput

func (TaskDefinitionFirelensConfigurationOutput) ToTaskDefinitionFirelensConfigurationPtrOutput 

func (o TaskDefinitionFirelensConfigurationOutput) ToTaskDefinitionFirelensConfigurationPtrOutput() TaskDefinitionFirelensConfigurationPtrOutput

func (TaskDefinitionFirelensConfigurationOutput) ToTaskDefinitionFirelensConfigurationPtrOutputWithContext 

func (o TaskDefinitionFirelensConfigurationOutput) ToTaskDefinitionFirelensConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionFirelensConfigurationPtrOutput

func (TaskDefinitionFirelensConfigurationOutput) Type 

func (o TaskDefinitionFirelensConfigurationOutput) Type() pulumi.StringPtrOutput

The log router to use. The valid values are “fluentd“ or “fluentbit“.

type TaskDefinitionFirelensConfigurationPtrInput 

type TaskDefinitionFirelensConfigurationPtrInput interface {
	pulumi.Input

	ToTaskDefinitionFirelensConfigurationPtrOutput() TaskDefinitionFirelensConfigurationPtrOutput
	ToTaskDefinitionFirelensConfigurationPtrOutputWithContext(context.Context) TaskDefinitionFirelensConfigurationPtrOutput
}

TaskDefinitionFirelensConfigurationPtrInput is an input type that accepts TaskDefinitionFirelensConfigurationArgs, TaskDefinitionFirelensConfigurationPtr and TaskDefinitionFirelensConfigurationPtrOutput values. You can construct a concrete instance of `TaskDefinitionFirelensConfigurationPtrInput` via: 

        TaskDefinitionFirelensConfigurationArgs{...}

or:

        nil

func TaskDefinitionFirelensConfigurationPtr 

func TaskDefinitionFirelensConfigurationPtr(v *TaskDefinitionFirelensConfigurationArgs) TaskDefinitionFirelensConfigurationPtrInput

type TaskDefinitionFirelensConfigurationPtrOutput 

type TaskDefinitionFirelensConfigurationPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionFirelensConfigurationPtrOutput) Elem 

func (o TaskDefinitionFirelensConfigurationPtrOutput) Elem() TaskDefinitionFirelensConfigurationOutput

func (TaskDefinitionFirelensConfigurationPtrOutput) ElementType 

func (TaskDefinitionFirelensConfigurationPtrOutput) ElementType() reflect.Type

func (TaskDefinitionFirelensConfigurationPtrOutput) Options 

func (o TaskDefinitionFirelensConfigurationPtrOutput) Options() pulumi.StringMapOutput

The options to use when configuring the log router. This field is optional and can be used to add additional metadata, such as the task, task definition, cluster, and container instance details to the log event. 

If specified, valid option keys are:
+   ``enable-ecs-log-metadata``, which can be ``true`` or ``false``
+   ``config-file-type``, which can be ``s3`` or ``file``
+   ``config-file-value``, which is either an S3 ARN or a file path

func (TaskDefinitionFirelensConfigurationPtrOutput) ToTaskDefinitionFirelensConfigurationPtrOutput 

func (o TaskDefinitionFirelensConfigurationPtrOutput) ToTaskDefinitionFirelensConfigurationPtrOutput() TaskDefinitionFirelensConfigurationPtrOutput

func (TaskDefinitionFirelensConfigurationPtrOutput) ToTaskDefinitionFirelensConfigurationPtrOutputWithContext 

func (o TaskDefinitionFirelensConfigurationPtrOutput) ToTaskDefinitionFirelensConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionFirelensConfigurationPtrOutput

func (TaskDefinitionFirelensConfigurationPtrOutput) Type 

func (o TaskDefinitionFirelensConfigurationPtrOutput) Type() pulumi.StringPtrOutput

The log router to use. The valid values are “fluentd“ or “fluentbit“.

type TaskDefinitionHealthCheck 

type TaskDefinitionHealthCheck struct {
	// A string array representing the command that the container runs to determine if it is healthy. The string array must start with “CMD“ to run the command arguments directly, or “CMD-SHELL“ to run the command with the container's default shell.
	//   When you use the AWS Management Console JSON panel, the CLIlong, or the APIs, enclose the list of commands in double quotes and brackets.
	//   “[ "CMD-SHELL", "curl -f http://localhost/ || exit 1" ]“
	//  You don't include the double quotes and brackets when you use the AWS Management Console.
	//   “CMD-SHELL, curl -f http://localhost/ || exit 1“
	//  An exit code of 0 indicates success, and non-zero exit code indicates failure. For more information, see “HealthCheck“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/).
	Command []string `pulumi:"command"`
	// The time period in seconds between each health check execution. You may specify between 5 and 300 seconds. The default value is 30 seconds.
	Interval *int `pulumi:"interval"`
	// The number of times to retry a failed health check before the container is considered unhealthy. You may specify between 1 and 10 retries. The default value is 3.
	Retries *int `pulumi:"retries"`
	// The optional grace period to provide containers time to bootstrap before failed health checks count towards the maximum number of retries. You can specify between 0 and 300 seconds. By default, the “startPeriod“ is off.
	//   If a health check succeeds within the “startPeriod“, then the container is considered healthy and any subsequent failures count toward the maximum number of retries.
	StartPeriod *int `pulumi:"startPeriod"`
	// The time period in seconds to wait for a health check to succeed before it is considered a failure. You may specify between 2 and 60 seconds. The default value is 5.
	Timeout *int `pulumi:"timeout"`
}

The “HealthCheck“ property specifies an object representing a container health check. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image (such as those specified in a parent image or from the image's Dockerfile). This configuration maps to the “HEALTHCHECK“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). 

 The Amazon ECS container agent only monitors and reports on the health checks specified in the task definition. Amazon ECS does not monitor Docker health checks that are embedded in a container image and not specified in the container definition. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image.
 If a task is run manually, and not as part of a service, the task will continue its lifecycle regardless of its health status. For tasks that are part of a service, if the task reports as unhealthy then the task will be stopped and the service scheduler will replace it.
The following are notes about container health check support:
 +  Container health checks require version 1.17.0 or greater of the Amazon ECS container agent. For more information, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html).
 +  Container health checks are supported for Fargate tasks if you are using platform version 1.1.0 or greater. For more information, see [Platform Versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).
 +  Container health checks are not supported for tasks that are part of a service that is configured to use a Classic Load Balancer.

type TaskDefinitionHealthCheckArgs 

type TaskDefinitionHealthCheckArgs struct {
	// A string array representing the command that the container runs to determine if it is healthy. The string array must start with “CMD“ to run the command arguments directly, or “CMD-SHELL“ to run the command with the container's default shell.
	//   When you use the AWS Management Console JSON panel, the CLIlong, or the APIs, enclose the list of commands in double quotes and brackets.
	//   “[ "CMD-SHELL", "curl -f http://localhost/ || exit 1" ]“
	//  You don't include the double quotes and brackets when you use the AWS Management Console.
	//   “CMD-SHELL, curl -f http://localhost/ || exit 1“
	//  An exit code of 0 indicates success, and non-zero exit code indicates failure. For more information, see “HealthCheck“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/).
	Command pulumi.StringArrayInput `pulumi:"command"`
	// The time period in seconds between each health check execution. You may specify between 5 and 300 seconds. The default value is 30 seconds.
	Interval pulumi.IntPtrInput `pulumi:"interval"`
	// The number of times to retry a failed health check before the container is considered unhealthy. You may specify between 1 and 10 retries. The default value is 3.
	Retries pulumi.IntPtrInput `pulumi:"retries"`
	// The optional grace period to provide containers time to bootstrap before failed health checks count towards the maximum number of retries. You can specify between 0 and 300 seconds. By default, the “startPeriod“ is off.
	//   If a health check succeeds within the “startPeriod“, then the container is considered healthy and any subsequent failures count toward the maximum number of retries.
	StartPeriod pulumi.IntPtrInput `pulumi:"startPeriod"`
	// The time period in seconds to wait for a health check to succeed before it is considered a failure. You may specify between 2 and 60 seconds. The default value is 5.
	Timeout pulumi.IntPtrInput `pulumi:"timeout"`
}

The “HealthCheck“ property specifies an object representing a container health check. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image (such as those specified in a parent image or from the image's Dockerfile). This configuration maps to the “HEALTHCHECK“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). 

 The Amazon ECS container agent only monitors and reports on the health checks specified in the task definition. Amazon ECS does not monitor Docker health checks that are embedded in a container image and not specified in the container definition. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image.
 If a task is run manually, and not as part of a service, the task will continue its lifecycle regardless of its health status. For tasks that are part of a service, if the task reports as unhealthy then the task will be stopped and the service scheduler will replace it.
The following are notes about container health check support:
 +  Container health checks require version 1.17.0 or greater of the Amazon ECS container agent. For more information, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html).
 +  Container health checks are supported for Fargate tasks if you are using platform version 1.1.0 or greater. For more information, see [Platform Versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).
 +  Container health checks are not supported for tasks that are part of a service that is configured to use a Classic Load Balancer.

func (TaskDefinitionHealthCheckArgs) ElementType 

func (TaskDefinitionHealthCheckArgs) ElementType() reflect.Type

func (TaskDefinitionHealthCheckArgs) ToTaskDefinitionHealthCheckOutput 

func (i TaskDefinitionHealthCheckArgs) ToTaskDefinitionHealthCheckOutput() TaskDefinitionHealthCheckOutput

func (TaskDefinitionHealthCheckArgs) ToTaskDefinitionHealthCheckOutputWithContext 

func (i TaskDefinitionHealthCheckArgs) ToTaskDefinitionHealthCheckOutputWithContext(ctx context.Context) TaskDefinitionHealthCheckOutput

func (TaskDefinitionHealthCheckArgs) ToTaskDefinitionHealthCheckPtrOutput 

func (i TaskDefinitionHealthCheckArgs) ToTaskDefinitionHealthCheckPtrOutput() TaskDefinitionHealthCheckPtrOutput

func (TaskDefinitionHealthCheckArgs) ToTaskDefinitionHealthCheckPtrOutputWithContext 

func (i TaskDefinitionHealthCheckArgs) ToTaskDefinitionHealthCheckPtrOutputWithContext(ctx context.Context) TaskDefinitionHealthCheckPtrOutput

type TaskDefinitionHealthCheckInput 

type TaskDefinitionHealthCheckInput interface {
	pulumi.Input

	ToTaskDefinitionHealthCheckOutput() TaskDefinitionHealthCheckOutput
	ToTaskDefinitionHealthCheckOutputWithContext(context.Context) TaskDefinitionHealthCheckOutput
}

TaskDefinitionHealthCheckInput is an input type that accepts TaskDefinitionHealthCheckArgs and TaskDefinitionHealthCheckOutput values. You can construct a concrete instance of `TaskDefinitionHealthCheckInput` via: 

TaskDefinitionHealthCheckArgs{...}

type TaskDefinitionHealthCheckOutput 

type TaskDefinitionHealthCheckOutput struct{ *pulumi.OutputState }

The “HealthCheck“ property specifies an object representing a container health check. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image (such as those specified in a parent image or from the image's Dockerfile). This configuration maps to the “HEALTHCHECK“ parameter of [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/). 

 The Amazon ECS container agent only monitors and reports on the health checks specified in the task definition. Amazon ECS does not monitor Docker health checks that are embedded in a container image and not specified in the container definition. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image.
 If a task is run manually, and not as part of a service, the task will continue its lifecycle regardless of its health status. For tasks that are part of a service, if the task reports as unhealthy then the task will be stopped and the service scheduler will replace it.
The following are notes about container health check support:
 +  Container health checks require version 1.17.0 or greater of the Amazon ECS container agent. For more information, see [Updating the Amazon ECS Container Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html).
 +  Container health checks are supported for Fargate tasks if you are using platform version 1.1.0 or greater. For more information, see [Platform Versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).
 +  Container health checks are not supported for tasks that are part of a service that is configured to use a Classic Load Balancer.

func (TaskDefinitionHealthCheckOutput) Command 

func (o TaskDefinitionHealthCheckOutput) Command() pulumi.StringArrayOutput

A string array representing the command that the container runs to determine if it is healthy. The string array must start with “CMD“ to run the command arguments directly, or “CMD-SHELL“ to run the command with the container's default shell. 

 When you use the AWS Management Console JSON panel, the CLIlong, or the APIs, enclose the list of commands in double quotes and brackets.
 ``[ "CMD-SHELL", "curl -f http://localhost/ || exit 1" ]``
You don't include the double quotes and brackets when you use the AWS Management Console.
 ``CMD-SHELL, curl -f http://localhost/ || exit 1``
An exit code of 0 indicates success, and non-zero exit code indicates failure. For more information, see ``HealthCheck`` in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/).

func (TaskDefinitionHealthCheckOutput) ElementType 

func (TaskDefinitionHealthCheckOutput) ElementType() reflect.Type

func (TaskDefinitionHealthCheckOutput) Interval 

func (o TaskDefinitionHealthCheckOutput) Interval() pulumi.IntPtrOutput

The time period in seconds between each health check execution. You may specify between 5 and 300 seconds. The default value is 30 seconds.

func (TaskDefinitionHealthCheckOutput) Retries 

func (o TaskDefinitionHealthCheckOutput) Retries() pulumi.IntPtrOutput

The number of times to retry a failed health check before the container is considered unhealthy. You may specify between 1 and 10 retries. The default value is 3.

func (TaskDefinitionHealthCheckOutput) StartPeriod 

func (o TaskDefinitionHealthCheckOutput) StartPeriod() pulumi.IntPtrOutput

The optional grace period to provide containers time to bootstrap before failed health checks count towards the maximum number of retries. You can specify between 0 and 300 seconds. By default, the “startPeriod“ is off. 

If a health check succeeds within the ``startPeriod``, then the container is considered healthy and any subsequent failures count toward the maximum number of retries.

func (TaskDefinitionHealthCheckOutput) Timeout 

func (o TaskDefinitionHealthCheckOutput) Timeout() pulumi.IntPtrOutput

The time period in seconds to wait for a health check to succeed before it is considered a failure. You may specify between 2 and 60 seconds. The default value is 5.

func (TaskDefinitionHealthCheckOutput) ToTaskDefinitionHealthCheckOutput 

func (o TaskDefinitionHealthCheckOutput) ToTaskDefinitionHealthCheckOutput() TaskDefinitionHealthCheckOutput

func (TaskDefinitionHealthCheckOutput) ToTaskDefinitionHealthCheckOutputWithContext 

func (o TaskDefinitionHealthCheckOutput) ToTaskDefinitionHealthCheckOutputWithContext(ctx context.Context) TaskDefinitionHealthCheckOutput

func (TaskDefinitionHealthCheckOutput) ToTaskDefinitionHealthCheckPtrOutput 

func (o TaskDefinitionHealthCheckOutput) ToTaskDefinitionHealthCheckPtrOutput() TaskDefinitionHealthCheckPtrOutput

func (TaskDefinitionHealthCheckOutput) ToTaskDefinitionHealthCheckPtrOutputWithContext 

func (o TaskDefinitionHealthCheckOutput) ToTaskDefinitionHealthCheckPtrOutputWithContext(ctx context.Context) TaskDefinitionHealthCheckPtrOutput

type TaskDefinitionHealthCheckPtrInput 

type TaskDefinitionHealthCheckPtrInput interface {
	pulumi.Input

	ToTaskDefinitionHealthCheckPtrOutput() TaskDefinitionHealthCheckPtrOutput
	ToTaskDefinitionHealthCheckPtrOutputWithContext(context.Context) TaskDefinitionHealthCheckPtrOutput
}

TaskDefinitionHealthCheckPtrInput is an input type that accepts TaskDefinitionHealthCheckArgs, TaskDefinitionHealthCheckPtr and TaskDefinitionHealthCheckPtrOutput values. You can construct a concrete instance of `TaskDefinitionHealthCheckPtrInput` via: 

        TaskDefinitionHealthCheckArgs{...}

or:

        nil

func TaskDefinitionHealthCheckPtr 

func TaskDefinitionHealthCheckPtr(v *TaskDefinitionHealthCheckArgs) TaskDefinitionHealthCheckPtrInput

type TaskDefinitionHealthCheckPtrOutput 

type TaskDefinitionHealthCheckPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionHealthCheckPtrOutput) Command 

func (o TaskDefinitionHealthCheckPtrOutput) Command() pulumi.StringArrayOutput

A string array representing the command that the container runs to determine if it is healthy. The string array must start with “CMD“ to run the command arguments directly, or “CMD-SHELL“ to run the command with the container's default shell. 

 When you use the AWS Management Console JSON panel, the CLIlong, or the APIs, enclose the list of commands in double quotes and brackets.
 ``[ "CMD-SHELL", "curl -f http://localhost/ || exit 1" ]``
You don't include the double quotes and brackets when you use the AWS Management Console.
 ``CMD-SHELL, curl -f http://localhost/ || exit 1``
An exit code of 0 indicates success, and non-zero exit code indicates failure. For more information, see ``HealthCheck`` in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/).

func (TaskDefinitionHealthCheckPtrOutput) Elem 

func (o TaskDefinitionHealthCheckPtrOutput) Elem() TaskDefinitionHealthCheckOutput

func (TaskDefinitionHealthCheckPtrOutput) ElementType 

func (TaskDefinitionHealthCheckPtrOutput) ElementType() reflect.Type

func (TaskDefinitionHealthCheckPtrOutput) Interval 

func (o TaskDefinitionHealthCheckPtrOutput) Interval() pulumi.IntPtrOutput

The time period in seconds between each health check execution. You may specify between 5 and 300 seconds. The default value is 30 seconds.

func (TaskDefinitionHealthCheckPtrOutput) Retries 

func (o TaskDefinitionHealthCheckPtrOutput) Retries() pulumi.IntPtrOutput

The number of times to retry a failed health check before the container is considered unhealthy. You may specify between 1 and 10 retries. The default value is 3.

func (TaskDefinitionHealthCheckPtrOutput) StartPeriod 

func (o TaskDefinitionHealthCheckPtrOutput) StartPeriod() pulumi.IntPtrOutput

The optional grace period to provide containers time to bootstrap before failed health checks count towards the maximum number of retries. You can specify between 0 and 300 seconds. By default, the “startPeriod“ is off. 

If a health check succeeds within the ``startPeriod``, then the container is considered healthy and any subsequent failures count toward the maximum number of retries.

func (TaskDefinitionHealthCheckPtrOutput) Timeout 

func (o TaskDefinitionHealthCheckPtrOutput) Timeout() pulumi.IntPtrOutput

The time period in seconds to wait for a health check to succeed before it is considered a failure. You may specify between 2 and 60 seconds. The default value is 5.

func (TaskDefinitionHealthCheckPtrOutput) ToTaskDefinitionHealthCheckPtrOutput 

func (o TaskDefinitionHealthCheckPtrOutput) ToTaskDefinitionHealthCheckPtrOutput() TaskDefinitionHealthCheckPtrOutput

func (TaskDefinitionHealthCheckPtrOutput) ToTaskDefinitionHealthCheckPtrOutputWithContext 

func (o TaskDefinitionHealthCheckPtrOutput) ToTaskDefinitionHealthCheckPtrOutputWithContext(ctx context.Context) TaskDefinitionHealthCheckPtrOutput

type TaskDefinitionHostEntry 

type TaskDefinitionHostEntry struct {
	// The hostname to use in the “/etc/hosts“ entry.
	Hostname *string `pulumi:"hostname"`
	// The IP address to use in the “/etc/hosts“ entry.
	IpAddress *string `pulumi:"ipAddress"`
}

The “HostEntry“ property specifies a hostname and an IP address that are added to the “/etc/hosts“ file of a container through the “extraHosts“ parameter of its “ContainerDefinition“ resource.

type TaskDefinitionHostEntryArgs 

type TaskDefinitionHostEntryArgs struct {
	// The hostname to use in the “/etc/hosts“ entry.
	Hostname pulumi.StringPtrInput `pulumi:"hostname"`
	// The IP address to use in the “/etc/hosts“ entry.
	IpAddress pulumi.StringPtrInput `pulumi:"ipAddress"`
}

The “HostEntry“ property specifies a hostname and an IP address that are added to the “/etc/hosts“ file of a container through the “extraHosts“ parameter of its “ContainerDefinition“ resource.

func (TaskDefinitionHostEntryArgs) ElementType 

func (TaskDefinitionHostEntryArgs) ElementType() reflect.Type

func (TaskDefinitionHostEntryArgs) ToTaskDefinitionHostEntryOutput 

func (i TaskDefinitionHostEntryArgs) ToTaskDefinitionHostEntryOutput() TaskDefinitionHostEntryOutput

func (TaskDefinitionHostEntryArgs) ToTaskDefinitionHostEntryOutputWithContext 

func (i TaskDefinitionHostEntryArgs) ToTaskDefinitionHostEntryOutputWithContext(ctx context.Context) TaskDefinitionHostEntryOutput

type TaskDefinitionHostEntryArray 

type TaskDefinitionHostEntryArray []TaskDefinitionHostEntryInput

func (TaskDefinitionHostEntryArray) ElementType 

func (TaskDefinitionHostEntryArray) ElementType() reflect.Type

func (TaskDefinitionHostEntryArray) ToTaskDefinitionHostEntryArrayOutput 

func (i TaskDefinitionHostEntryArray) ToTaskDefinitionHostEntryArrayOutput() TaskDefinitionHostEntryArrayOutput

func (TaskDefinitionHostEntryArray) ToTaskDefinitionHostEntryArrayOutputWithContext 

func (i TaskDefinitionHostEntryArray) ToTaskDefinitionHostEntryArrayOutputWithContext(ctx context.Context) TaskDefinitionHostEntryArrayOutput

type TaskDefinitionHostEntryArrayInput 

type TaskDefinitionHostEntryArrayInput interface {
	pulumi.Input

	ToTaskDefinitionHostEntryArrayOutput() TaskDefinitionHostEntryArrayOutput
	ToTaskDefinitionHostEntryArrayOutputWithContext(context.Context) TaskDefinitionHostEntryArrayOutput
}

TaskDefinitionHostEntryArrayInput is an input type that accepts TaskDefinitionHostEntryArray and TaskDefinitionHostEntryArrayOutput values. You can construct a concrete instance of `TaskDefinitionHostEntryArrayInput` via: 

TaskDefinitionHostEntryArray{ TaskDefinitionHostEntryArgs{...} }

type TaskDefinitionHostEntryArrayOutput 

type TaskDefinitionHostEntryArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionHostEntryArrayOutput) ElementType 

func (TaskDefinitionHostEntryArrayOutput) ElementType() reflect.Type

func (TaskDefinitionHostEntryArrayOutput) Index 

func (o TaskDefinitionHostEntryArrayOutput) Index(i pulumi.IntInput) TaskDefinitionHostEntryOutput

func (TaskDefinitionHostEntryArrayOutput) ToTaskDefinitionHostEntryArrayOutput 

func (o TaskDefinitionHostEntryArrayOutput) ToTaskDefinitionHostEntryArrayOutput() TaskDefinitionHostEntryArrayOutput

func (TaskDefinitionHostEntryArrayOutput) ToTaskDefinitionHostEntryArrayOutputWithContext 

func (o TaskDefinitionHostEntryArrayOutput) ToTaskDefinitionHostEntryArrayOutputWithContext(ctx context.Context) TaskDefinitionHostEntryArrayOutput

type TaskDefinitionHostEntryInput 

type TaskDefinitionHostEntryInput interface {
	pulumi.Input

	ToTaskDefinitionHostEntryOutput() TaskDefinitionHostEntryOutput
	ToTaskDefinitionHostEntryOutputWithContext(context.Context) TaskDefinitionHostEntryOutput
}

TaskDefinitionHostEntryInput is an input type that accepts TaskDefinitionHostEntryArgs and TaskDefinitionHostEntryOutput values. You can construct a concrete instance of `TaskDefinitionHostEntryInput` via: 

TaskDefinitionHostEntryArgs{...}

type TaskDefinitionHostEntryOutput 

type TaskDefinitionHostEntryOutput struct{ *pulumi.OutputState }

The “HostEntry“ property specifies a hostname and an IP address that are added to the “/etc/hosts“ file of a container through the “extraHosts“ parameter of its “ContainerDefinition“ resource.

func (TaskDefinitionHostEntryOutput) ElementType 

func (TaskDefinitionHostEntryOutput) ElementType() reflect.Type

func (TaskDefinitionHostEntryOutput) Hostname 

func (o TaskDefinitionHostEntryOutput) Hostname() pulumi.StringPtrOutput

The hostname to use in the “/etc/hosts“ entry.

func (TaskDefinitionHostEntryOutput) IpAddress 

func (o TaskDefinitionHostEntryOutput) IpAddress() pulumi.StringPtrOutput

The IP address to use in the “/etc/hosts“ entry.

func (TaskDefinitionHostEntryOutput) ToTaskDefinitionHostEntryOutput 

func (o TaskDefinitionHostEntryOutput) ToTaskDefinitionHostEntryOutput() TaskDefinitionHostEntryOutput

func (TaskDefinitionHostEntryOutput) ToTaskDefinitionHostEntryOutputWithContext 

func (o TaskDefinitionHostEntryOutput) ToTaskDefinitionHostEntryOutputWithContext(ctx context.Context) TaskDefinitionHostEntryOutput

type TaskDefinitionHostVolumeProperties 

type TaskDefinitionHostVolumeProperties struct {
	// When the “host“ parameter is used, specify a “sourcePath“ to declare the path on the host container instance that's presented to the container. If this parameter is empty, then the Docker daemon has assigned a host path for you. If the “host“ parameter contains a “sourcePath“ file location, then the data volume persists at the specified location on the host container instance until you delete it manually. If the “sourcePath“ value doesn't exist on the host container instance, the Docker daemon creates it. If the location does exist, the contents of the source path folder are exported.
	//  If you're using the Fargate launch type, the “sourcePath“ parameter is not supported.
	SourcePath *string `pulumi:"sourcePath"`
}

The “HostVolumeProperties“ property specifies details on a container instance bind mount host volume.

type TaskDefinitionHostVolumePropertiesArgs 

type TaskDefinitionHostVolumePropertiesArgs struct {
	// When the “host“ parameter is used, specify a “sourcePath“ to declare the path on the host container instance that's presented to the container. If this parameter is empty, then the Docker daemon has assigned a host path for you. If the “host“ parameter contains a “sourcePath“ file location, then the data volume persists at the specified location on the host container instance until you delete it manually. If the “sourcePath“ value doesn't exist on the host container instance, the Docker daemon creates it. If the location does exist, the contents of the source path folder are exported.
	//  If you're using the Fargate launch type, the “sourcePath“ parameter is not supported.
	SourcePath pulumi.StringPtrInput `pulumi:"sourcePath"`
}

The “HostVolumeProperties“ property specifies details on a container instance bind mount host volume.

func (TaskDefinitionHostVolumePropertiesArgs) ElementType 

func (TaskDefinitionHostVolumePropertiesArgs) ElementType() reflect.Type

func (TaskDefinitionHostVolumePropertiesArgs) ToTaskDefinitionHostVolumePropertiesOutput 

func (i TaskDefinitionHostVolumePropertiesArgs) ToTaskDefinitionHostVolumePropertiesOutput() TaskDefinitionHostVolumePropertiesOutput

func (TaskDefinitionHostVolumePropertiesArgs) ToTaskDefinitionHostVolumePropertiesOutputWithContext 

func (i TaskDefinitionHostVolumePropertiesArgs) ToTaskDefinitionHostVolumePropertiesOutputWithContext(ctx context.Context) TaskDefinitionHostVolumePropertiesOutput

func (TaskDefinitionHostVolumePropertiesArgs) ToTaskDefinitionHostVolumePropertiesPtrOutput 

func (i TaskDefinitionHostVolumePropertiesArgs) ToTaskDefinitionHostVolumePropertiesPtrOutput() TaskDefinitionHostVolumePropertiesPtrOutput

func (TaskDefinitionHostVolumePropertiesArgs) ToTaskDefinitionHostVolumePropertiesPtrOutputWithContext 

func (i TaskDefinitionHostVolumePropertiesArgs) ToTaskDefinitionHostVolumePropertiesPtrOutputWithContext(ctx context.Context) TaskDefinitionHostVolumePropertiesPtrOutput

type TaskDefinitionHostVolumePropertiesInput 

type TaskDefinitionHostVolumePropertiesInput interface {
	pulumi.Input

	ToTaskDefinitionHostVolumePropertiesOutput() TaskDefinitionHostVolumePropertiesOutput
	ToTaskDefinitionHostVolumePropertiesOutputWithContext(context.Context) TaskDefinitionHostVolumePropertiesOutput
}

TaskDefinitionHostVolumePropertiesInput is an input type that accepts TaskDefinitionHostVolumePropertiesArgs and TaskDefinitionHostVolumePropertiesOutput values. You can construct a concrete instance of `TaskDefinitionHostVolumePropertiesInput` via: 

TaskDefinitionHostVolumePropertiesArgs{...}

type TaskDefinitionHostVolumePropertiesOutput 

type TaskDefinitionHostVolumePropertiesOutput struct{ *pulumi.OutputState }

The “HostVolumeProperties“ property specifies details on a container instance bind mount host volume.

func (TaskDefinitionHostVolumePropertiesOutput) ElementType 

func (TaskDefinitionHostVolumePropertiesOutput) ElementType() reflect.Type

func (TaskDefinitionHostVolumePropertiesOutput) SourcePath 

func (o TaskDefinitionHostVolumePropertiesOutput) SourcePath() pulumi.StringPtrOutput

When the “host“ parameter is used, specify a “sourcePath“ to declare the path on the host container instance that's presented to the container. If this parameter is empty, then the Docker daemon has assigned a host path for you. If the “host“ parameter contains a “sourcePath“ file location, then the data volume persists at the specified location on the host container instance until you delete it manually. If the “sourcePath“ value doesn't exist on the host container instance, the Docker daemon creates it. If the location does exist, the contents of the source path folder are exported. 

If you're using the Fargate launch type, the ``sourcePath`` parameter is not supported.

func (TaskDefinitionHostVolumePropertiesOutput) ToTaskDefinitionHostVolumePropertiesOutput 

func (o TaskDefinitionHostVolumePropertiesOutput) ToTaskDefinitionHostVolumePropertiesOutput() TaskDefinitionHostVolumePropertiesOutput

func (TaskDefinitionHostVolumePropertiesOutput) ToTaskDefinitionHostVolumePropertiesOutputWithContext 

func (o TaskDefinitionHostVolumePropertiesOutput) ToTaskDefinitionHostVolumePropertiesOutputWithContext(ctx context.Context) TaskDefinitionHostVolumePropertiesOutput

func (TaskDefinitionHostVolumePropertiesOutput) ToTaskDefinitionHostVolumePropertiesPtrOutput 

func (o TaskDefinitionHostVolumePropertiesOutput) ToTaskDefinitionHostVolumePropertiesPtrOutput() TaskDefinitionHostVolumePropertiesPtrOutput

func (TaskDefinitionHostVolumePropertiesOutput) ToTaskDefinitionHostVolumePropertiesPtrOutputWithContext 

func (o TaskDefinitionHostVolumePropertiesOutput) ToTaskDefinitionHostVolumePropertiesPtrOutputWithContext(ctx context.Context) TaskDefinitionHostVolumePropertiesPtrOutput

type TaskDefinitionHostVolumePropertiesPtrInput 

type TaskDefinitionHostVolumePropertiesPtrInput interface {
	pulumi.Input

	ToTaskDefinitionHostVolumePropertiesPtrOutput() TaskDefinitionHostVolumePropertiesPtrOutput
	ToTaskDefinitionHostVolumePropertiesPtrOutputWithContext(context.Context) TaskDefinitionHostVolumePropertiesPtrOutput
}

TaskDefinitionHostVolumePropertiesPtrInput is an input type that accepts TaskDefinitionHostVolumePropertiesArgs, TaskDefinitionHostVolumePropertiesPtr and TaskDefinitionHostVolumePropertiesPtrOutput values. You can construct a concrete instance of `TaskDefinitionHostVolumePropertiesPtrInput` via: 

        TaskDefinitionHostVolumePropertiesArgs{...}

or:

        nil

func TaskDefinitionHostVolumePropertiesPtr 

func TaskDefinitionHostVolumePropertiesPtr(v *TaskDefinitionHostVolumePropertiesArgs) TaskDefinitionHostVolumePropertiesPtrInput

type TaskDefinitionHostVolumePropertiesPtrOutput 

type TaskDefinitionHostVolumePropertiesPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionHostVolumePropertiesPtrOutput) Elem 

func (o TaskDefinitionHostVolumePropertiesPtrOutput) Elem() TaskDefinitionHostVolumePropertiesOutput

func (TaskDefinitionHostVolumePropertiesPtrOutput) ElementType 

func (TaskDefinitionHostVolumePropertiesPtrOutput) ElementType() reflect.Type

func (TaskDefinitionHostVolumePropertiesPtrOutput) SourcePath 

func (o TaskDefinitionHostVolumePropertiesPtrOutput) SourcePath() pulumi.StringPtrOutput

When the “host“ parameter is used, specify a “sourcePath“ to declare the path on the host container instance that's presented to the container. If this parameter is empty, then the Docker daemon has assigned a host path for you. If the “host“ parameter contains a “sourcePath“ file location, then the data volume persists at the specified location on the host container instance until you delete it manually. If the “sourcePath“ value doesn't exist on the host container instance, the Docker daemon creates it. If the location does exist, the contents of the source path folder are exported. 

If you're using the Fargate launch type, the ``sourcePath`` parameter is not supported.

func (TaskDefinitionHostVolumePropertiesPtrOutput) ToTaskDefinitionHostVolumePropertiesPtrOutput 

func (o TaskDefinitionHostVolumePropertiesPtrOutput) ToTaskDefinitionHostVolumePropertiesPtrOutput() TaskDefinitionHostVolumePropertiesPtrOutput

func (TaskDefinitionHostVolumePropertiesPtrOutput) ToTaskDefinitionHostVolumePropertiesPtrOutputWithContext 

func (o TaskDefinitionHostVolumePropertiesPtrOutput) ToTaskDefinitionHostVolumePropertiesPtrOutputWithContext(ctx context.Context) TaskDefinitionHostVolumePropertiesPtrOutput

type TaskDefinitionInferenceAccelerator 

type TaskDefinitionInferenceAccelerator struct {
	// The Elastic Inference accelerator device name. The “deviceName“ must also be referenced in a container definition as a [ResourceRequirement](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ResourceRequirement.html).
	DeviceName *string `pulumi:"deviceName"`
	// The Elastic Inference accelerator type to use.
	DeviceType *string `pulumi:"deviceType"`
}

Details on an Elastic Inference accelerator. For more information, see [Working with Amazon Elastic Inference on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-inference.html) in the *Amazon Elastic Container Service Developer Guide*.

type TaskDefinitionInferenceAcceleratorArgs 

type TaskDefinitionInferenceAcceleratorArgs struct {
	// The Elastic Inference accelerator device name. The “deviceName“ must also be referenced in a container definition as a [ResourceRequirement](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ResourceRequirement.html).
	DeviceName pulumi.StringPtrInput `pulumi:"deviceName"`
	// The Elastic Inference accelerator type to use.
	DeviceType pulumi.StringPtrInput `pulumi:"deviceType"`
}

Details on an Elastic Inference accelerator. For more information, see [Working with Amazon Elastic Inference on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-inference.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionInferenceAcceleratorArgs) ElementType 

func (TaskDefinitionInferenceAcceleratorArgs) ElementType() reflect.Type

func (TaskDefinitionInferenceAcceleratorArgs) ToTaskDefinitionInferenceAcceleratorOutput 

func (i TaskDefinitionInferenceAcceleratorArgs) ToTaskDefinitionInferenceAcceleratorOutput() TaskDefinitionInferenceAcceleratorOutput

func (TaskDefinitionInferenceAcceleratorArgs) ToTaskDefinitionInferenceAcceleratorOutputWithContext 

func (i TaskDefinitionInferenceAcceleratorArgs) ToTaskDefinitionInferenceAcceleratorOutputWithContext(ctx context.Context) TaskDefinitionInferenceAcceleratorOutput

type TaskDefinitionInferenceAcceleratorArray 

type TaskDefinitionInferenceAcceleratorArray []TaskDefinitionInferenceAcceleratorInput

func (TaskDefinitionInferenceAcceleratorArray) ElementType 

func (TaskDefinitionInferenceAcceleratorArray) ElementType() reflect.Type

func (TaskDefinitionInferenceAcceleratorArray) ToTaskDefinitionInferenceAcceleratorArrayOutput 

func (i TaskDefinitionInferenceAcceleratorArray) ToTaskDefinitionInferenceAcceleratorArrayOutput() TaskDefinitionInferenceAcceleratorArrayOutput

func (TaskDefinitionInferenceAcceleratorArray) ToTaskDefinitionInferenceAcceleratorArrayOutputWithContext 

func (i TaskDefinitionInferenceAcceleratorArray) ToTaskDefinitionInferenceAcceleratorArrayOutputWithContext(ctx context.Context) TaskDefinitionInferenceAcceleratorArrayOutput

type TaskDefinitionInferenceAcceleratorArrayInput 

type TaskDefinitionInferenceAcceleratorArrayInput interface {
	pulumi.Input

	ToTaskDefinitionInferenceAcceleratorArrayOutput() TaskDefinitionInferenceAcceleratorArrayOutput
	ToTaskDefinitionInferenceAcceleratorArrayOutputWithContext(context.Context) TaskDefinitionInferenceAcceleratorArrayOutput
}

TaskDefinitionInferenceAcceleratorArrayInput is an input type that accepts TaskDefinitionInferenceAcceleratorArray and TaskDefinitionInferenceAcceleratorArrayOutput values. You can construct a concrete instance of `TaskDefinitionInferenceAcceleratorArrayInput` via: 

TaskDefinitionInferenceAcceleratorArray{ TaskDefinitionInferenceAcceleratorArgs{...} }

type TaskDefinitionInferenceAcceleratorArrayOutput 

type TaskDefinitionInferenceAcceleratorArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionInferenceAcceleratorArrayOutput) ElementType 

func (TaskDefinitionInferenceAcceleratorArrayOutput) ElementType() reflect.Type

func (TaskDefinitionInferenceAcceleratorArrayOutput) Index 

func (o TaskDefinitionInferenceAcceleratorArrayOutput) Index(i pulumi.IntInput) TaskDefinitionInferenceAcceleratorOutput

func (TaskDefinitionInferenceAcceleratorArrayOutput) ToTaskDefinitionInferenceAcceleratorArrayOutput 

func (o TaskDefinitionInferenceAcceleratorArrayOutput) ToTaskDefinitionInferenceAcceleratorArrayOutput() TaskDefinitionInferenceAcceleratorArrayOutput

func (TaskDefinitionInferenceAcceleratorArrayOutput) ToTaskDefinitionInferenceAcceleratorArrayOutputWithContext 

func (o TaskDefinitionInferenceAcceleratorArrayOutput) ToTaskDefinitionInferenceAcceleratorArrayOutputWithContext(ctx context.Context) TaskDefinitionInferenceAcceleratorArrayOutput

type TaskDefinitionInferenceAcceleratorInput 

type TaskDefinitionInferenceAcceleratorInput interface {
	pulumi.Input

	ToTaskDefinitionInferenceAcceleratorOutput() TaskDefinitionInferenceAcceleratorOutput
	ToTaskDefinitionInferenceAcceleratorOutputWithContext(context.Context) TaskDefinitionInferenceAcceleratorOutput
}

TaskDefinitionInferenceAcceleratorInput is an input type that accepts TaskDefinitionInferenceAcceleratorArgs and TaskDefinitionInferenceAcceleratorOutput values. You can construct a concrete instance of `TaskDefinitionInferenceAcceleratorInput` via: 

TaskDefinitionInferenceAcceleratorArgs{...}

type TaskDefinitionInferenceAcceleratorOutput 

type TaskDefinitionInferenceAcceleratorOutput struct{ *pulumi.OutputState }

Details on an Elastic Inference accelerator. For more information, see [Working with Amazon Elastic Inference on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-inference.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionInferenceAcceleratorOutput) DeviceName 

func (o TaskDefinitionInferenceAcceleratorOutput) DeviceName() pulumi.StringPtrOutput

The Elastic Inference accelerator device name. The “deviceName“ must also be referenced in a container definition as a [ResourceRequirement](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ResourceRequirement.html).

func (TaskDefinitionInferenceAcceleratorOutput) DeviceType 

func (o TaskDefinitionInferenceAcceleratorOutput) DeviceType() pulumi.StringPtrOutput

The Elastic Inference accelerator type to use.

func (TaskDefinitionInferenceAcceleratorOutput) ElementType 

func (TaskDefinitionInferenceAcceleratorOutput) ElementType() reflect.Type

func (TaskDefinitionInferenceAcceleratorOutput) ToTaskDefinitionInferenceAcceleratorOutput 

func (o TaskDefinitionInferenceAcceleratorOutput) ToTaskDefinitionInferenceAcceleratorOutput() TaskDefinitionInferenceAcceleratorOutput

func (TaskDefinitionInferenceAcceleratorOutput) ToTaskDefinitionInferenceAcceleratorOutputWithContext 

func (o TaskDefinitionInferenceAcceleratorOutput) ToTaskDefinitionInferenceAcceleratorOutputWithContext(ctx context.Context) TaskDefinitionInferenceAcceleratorOutput

type TaskDefinitionInput 

type TaskDefinitionInput interface {
	pulumi.Input

	ToTaskDefinitionOutput() TaskDefinitionOutput
	ToTaskDefinitionOutputWithContext(ctx context.Context) TaskDefinitionOutput
}

type TaskDefinitionKernelCapabilities 

type TaskDefinitionKernelCapabilities struct {
	// The Linux capabilities for the container that have been added to the default configuration provided by Docker. This parameter maps to “CapAdd“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cap-add“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   Tasks launched on FARGATElong only support adding the “SYS_PTRACE“ kernel capability.
	//   Valid values: “"ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"“
	Add []string `pulumi:"add"`
	// The Linux capabilities for the container that have been removed from the default configuration provided by Docker. This parameter maps to “CapDrop“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cap-drop“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  Valid values: “"ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"“
	Drop []string `pulumi:"drop"`
}

The Linux capabilities to add or remove from the default Docker configuration for a container defined in the task definition. For more information about the default capabilities and the non-default available capabilities, see [Runtime privilege and Linux capabilities](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) in the *Docker run reference*. For more detailed information about these Linux capabilities, see the [capabilities(7)](https://docs.aws.amazon.com/http://man7.org/linux/man-pages/man7/capabilities.7.html) Linux manual page.

type TaskDefinitionKernelCapabilitiesArgs 

type TaskDefinitionKernelCapabilitiesArgs struct {
	// The Linux capabilities for the container that have been added to the default configuration provided by Docker. This parameter maps to “CapAdd“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cap-add“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   Tasks launched on FARGATElong only support adding the “SYS_PTRACE“ kernel capability.
	//   Valid values: “"ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"“
	Add pulumi.StringArrayInput `pulumi:"add"`
	// The Linux capabilities for the container that have been removed from the default configuration provided by Docker. This parameter maps to “CapDrop“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cap-drop“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//  Valid values: “"ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"“
	Drop pulumi.StringArrayInput `pulumi:"drop"`
}

The Linux capabilities to add or remove from the default Docker configuration for a container defined in the task definition. For more information about the default capabilities and the non-default available capabilities, see [Runtime privilege and Linux capabilities](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) in the *Docker run reference*. For more detailed information about these Linux capabilities, see the [capabilities(7)](https://docs.aws.amazon.com/http://man7.org/linux/man-pages/man7/capabilities.7.html) Linux manual page.

func (TaskDefinitionKernelCapabilitiesArgs) ElementType 

func (TaskDefinitionKernelCapabilitiesArgs) ElementType() reflect.Type

func (TaskDefinitionKernelCapabilitiesArgs) ToTaskDefinitionKernelCapabilitiesOutput 

func (i TaskDefinitionKernelCapabilitiesArgs) ToTaskDefinitionKernelCapabilitiesOutput() TaskDefinitionKernelCapabilitiesOutput

func (TaskDefinitionKernelCapabilitiesArgs) ToTaskDefinitionKernelCapabilitiesOutputWithContext 

func (i TaskDefinitionKernelCapabilitiesArgs) ToTaskDefinitionKernelCapabilitiesOutputWithContext(ctx context.Context) TaskDefinitionKernelCapabilitiesOutput

func (TaskDefinitionKernelCapabilitiesArgs) ToTaskDefinitionKernelCapabilitiesPtrOutput 

func (i TaskDefinitionKernelCapabilitiesArgs) ToTaskDefinitionKernelCapabilitiesPtrOutput() TaskDefinitionKernelCapabilitiesPtrOutput

func (TaskDefinitionKernelCapabilitiesArgs) ToTaskDefinitionKernelCapabilitiesPtrOutputWithContext 

func (i TaskDefinitionKernelCapabilitiesArgs) ToTaskDefinitionKernelCapabilitiesPtrOutputWithContext(ctx context.Context) TaskDefinitionKernelCapabilitiesPtrOutput

type TaskDefinitionKernelCapabilitiesInput 

type TaskDefinitionKernelCapabilitiesInput interface {
	pulumi.Input

	ToTaskDefinitionKernelCapabilitiesOutput() TaskDefinitionKernelCapabilitiesOutput
	ToTaskDefinitionKernelCapabilitiesOutputWithContext(context.Context) TaskDefinitionKernelCapabilitiesOutput
}

TaskDefinitionKernelCapabilitiesInput is an input type that accepts TaskDefinitionKernelCapabilitiesArgs and TaskDefinitionKernelCapabilitiesOutput values. You can construct a concrete instance of `TaskDefinitionKernelCapabilitiesInput` via: 

TaskDefinitionKernelCapabilitiesArgs{...}

type TaskDefinitionKernelCapabilitiesOutput 

type TaskDefinitionKernelCapabilitiesOutput struct{ *pulumi.OutputState }

The Linux capabilities to add or remove from the default Docker configuration for a container defined in the task definition. For more information about the default capabilities and the non-default available capabilities, see [Runtime privilege and Linux capabilities](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#runtime-privilege-and-linux-capabilities) in the *Docker run reference*. For more detailed information about these Linux capabilities, see the [capabilities(7)](https://docs.aws.amazon.com/http://man7.org/linux/man-pages/man7/capabilities.7.html) Linux manual page.

func (TaskDefinitionKernelCapabilitiesOutput) Add 

func (o TaskDefinitionKernelCapabilitiesOutput) Add() pulumi.StringArrayOutput

The Linux capabilities for the container that have been added to the default configuration provided by Docker. This parameter maps to “CapAdd“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cap-add“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

Tasks launched on FARGATElong only support adding the ``SYS_PTRACE`` kernel capability.
Valid values: ``"ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"``

func (TaskDefinitionKernelCapabilitiesOutput) Drop 

func (o TaskDefinitionKernelCapabilitiesOutput) Drop() pulumi.StringArrayOutput

The Linux capabilities for the container that have been removed from the default configuration provided by Docker. This parameter maps to “CapDrop“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cap-drop“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

Valid values: ``"ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"``

func (TaskDefinitionKernelCapabilitiesOutput) ElementType 

func (TaskDefinitionKernelCapabilitiesOutput) ElementType() reflect.Type

func (TaskDefinitionKernelCapabilitiesOutput) ToTaskDefinitionKernelCapabilitiesOutput 

func (o TaskDefinitionKernelCapabilitiesOutput) ToTaskDefinitionKernelCapabilitiesOutput() TaskDefinitionKernelCapabilitiesOutput

func (TaskDefinitionKernelCapabilitiesOutput) ToTaskDefinitionKernelCapabilitiesOutputWithContext 

func (o TaskDefinitionKernelCapabilitiesOutput) ToTaskDefinitionKernelCapabilitiesOutputWithContext(ctx context.Context) TaskDefinitionKernelCapabilitiesOutput

func (TaskDefinitionKernelCapabilitiesOutput) ToTaskDefinitionKernelCapabilitiesPtrOutput 

func (o TaskDefinitionKernelCapabilitiesOutput) ToTaskDefinitionKernelCapabilitiesPtrOutput() TaskDefinitionKernelCapabilitiesPtrOutput

func (TaskDefinitionKernelCapabilitiesOutput) ToTaskDefinitionKernelCapabilitiesPtrOutputWithContext 

func (o TaskDefinitionKernelCapabilitiesOutput) ToTaskDefinitionKernelCapabilitiesPtrOutputWithContext(ctx context.Context) TaskDefinitionKernelCapabilitiesPtrOutput

type TaskDefinitionKernelCapabilitiesPtrInput 

type TaskDefinitionKernelCapabilitiesPtrInput interface {
	pulumi.Input

	ToTaskDefinitionKernelCapabilitiesPtrOutput() TaskDefinitionKernelCapabilitiesPtrOutput
	ToTaskDefinitionKernelCapabilitiesPtrOutputWithContext(context.Context) TaskDefinitionKernelCapabilitiesPtrOutput
}

TaskDefinitionKernelCapabilitiesPtrInput is an input type that accepts TaskDefinitionKernelCapabilitiesArgs, TaskDefinitionKernelCapabilitiesPtr and TaskDefinitionKernelCapabilitiesPtrOutput values. You can construct a concrete instance of `TaskDefinitionKernelCapabilitiesPtrInput` via: 

        TaskDefinitionKernelCapabilitiesArgs{...}

or:

        nil

func TaskDefinitionKernelCapabilitiesPtr 

func TaskDefinitionKernelCapabilitiesPtr(v *TaskDefinitionKernelCapabilitiesArgs) TaskDefinitionKernelCapabilitiesPtrInput

type TaskDefinitionKernelCapabilitiesPtrOutput 

type TaskDefinitionKernelCapabilitiesPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionKernelCapabilitiesPtrOutput) Add 

func (o TaskDefinitionKernelCapabilitiesPtrOutput) Add() pulumi.StringArrayOutput

The Linux capabilities for the container that have been added to the default configuration provided by Docker. This parameter maps to “CapAdd“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cap-add“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

Tasks launched on FARGATElong only support adding the ``SYS_PTRACE`` kernel capability.
Valid values: ``"ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"``

func (TaskDefinitionKernelCapabilitiesPtrOutput) Drop 

func (o TaskDefinitionKernelCapabilitiesPtrOutput) Drop() pulumi.StringArrayOutput

The Linux capabilities for the container that have been removed from the default configuration provided by Docker. This parameter maps to “CapDrop“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--cap-drop“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

Valid values: ``"ALL" | "AUDIT_CONTROL" | "AUDIT_WRITE" | "BLOCK_SUSPEND" | "CHOWN" | "DAC_OVERRIDE" | "DAC_READ_SEARCH" | "FOWNER" | "FSETID" | "IPC_LOCK" | "IPC_OWNER" | "KILL" | "LEASE" | "LINUX_IMMUTABLE" | "MAC_ADMIN" | "MAC_OVERRIDE" | "MKNOD" | "NET_ADMIN" | "NET_BIND_SERVICE" | "NET_BROADCAST" | "NET_RAW" | "SETFCAP" | "SETGID" | "SETPCAP" | "SETUID" | "SYS_ADMIN" | "SYS_BOOT" | "SYS_CHROOT" | "SYS_MODULE" | "SYS_NICE" | "SYS_PACCT" | "SYS_PTRACE" | "SYS_RAWIO" | "SYS_RESOURCE" | "SYS_TIME" | "SYS_TTY_CONFIG" | "SYSLOG" | "WAKE_ALARM"``

func (TaskDefinitionKernelCapabilitiesPtrOutput) Elem 

func (o TaskDefinitionKernelCapabilitiesPtrOutput) Elem() TaskDefinitionKernelCapabilitiesOutput

func (TaskDefinitionKernelCapabilitiesPtrOutput) ElementType 

func (TaskDefinitionKernelCapabilitiesPtrOutput) ElementType() reflect.Type

func (TaskDefinitionKernelCapabilitiesPtrOutput) ToTaskDefinitionKernelCapabilitiesPtrOutput 

func (o TaskDefinitionKernelCapabilitiesPtrOutput) ToTaskDefinitionKernelCapabilitiesPtrOutput() TaskDefinitionKernelCapabilitiesPtrOutput

func (TaskDefinitionKernelCapabilitiesPtrOutput) ToTaskDefinitionKernelCapabilitiesPtrOutputWithContext 

func (o TaskDefinitionKernelCapabilitiesPtrOutput) ToTaskDefinitionKernelCapabilitiesPtrOutputWithContext(ctx context.Context) TaskDefinitionKernelCapabilitiesPtrOutput

type TaskDefinitionKeyValuePair 

type TaskDefinitionKeyValuePair struct {
	// The name of the key-value pair. For environment variables, this is the name of the environment variable.
	Name *string `pulumi:"name"`
	// The value of the key-value pair. For environment variables, this is the value of the environment variable.
	Value *string `pulumi:"value"`
}

A key-value pair object.

type TaskDefinitionKeyValuePairArgs 

type TaskDefinitionKeyValuePairArgs struct {
	// The name of the key-value pair. For environment variables, this is the name of the environment variable.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The value of the key-value pair. For environment variables, this is the value of the environment variable.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

A key-value pair object.

func (TaskDefinitionKeyValuePairArgs) ElementType 

func (TaskDefinitionKeyValuePairArgs) ElementType() reflect.Type

func (TaskDefinitionKeyValuePairArgs) ToTaskDefinitionKeyValuePairOutput 

func (i TaskDefinitionKeyValuePairArgs) ToTaskDefinitionKeyValuePairOutput() TaskDefinitionKeyValuePairOutput

func (TaskDefinitionKeyValuePairArgs) ToTaskDefinitionKeyValuePairOutputWithContext 

func (i TaskDefinitionKeyValuePairArgs) ToTaskDefinitionKeyValuePairOutputWithContext(ctx context.Context) TaskDefinitionKeyValuePairOutput

type TaskDefinitionKeyValuePairArray 

type TaskDefinitionKeyValuePairArray []TaskDefinitionKeyValuePairInput

func (TaskDefinitionKeyValuePairArray) ElementType 

func (TaskDefinitionKeyValuePairArray) ElementType() reflect.Type

func (TaskDefinitionKeyValuePairArray) ToTaskDefinitionKeyValuePairArrayOutput 

func (i TaskDefinitionKeyValuePairArray) ToTaskDefinitionKeyValuePairArrayOutput() TaskDefinitionKeyValuePairArrayOutput

func (TaskDefinitionKeyValuePairArray) ToTaskDefinitionKeyValuePairArrayOutputWithContext 

func (i TaskDefinitionKeyValuePairArray) ToTaskDefinitionKeyValuePairArrayOutputWithContext(ctx context.Context) TaskDefinitionKeyValuePairArrayOutput

type TaskDefinitionKeyValuePairArrayInput 

type TaskDefinitionKeyValuePairArrayInput interface {
	pulumi.Input

	ToTaskDefinitionKeyValuePairArrayOutput() TaskDefinitionKeyValuePairArrayOutput
	ToTaskDefinitionKeyValuePairArrayOutputWithContext(context.Context) TaskDefinitionKeyValuePairArrayOutput
}

TaskDefinitionKeyValuePairArrayInput is an input type that accepts TaskDefinitionKeyValuePairArray and TaskDefinitionKeyValuePairArrayOutput values. You can construct a concrete instance of `TaskDefinitionKeyValuePairArrayInput` via: 

TaskDefinitionKeyValuePairArray{ TaskDefinitionKeyValuePairArgs{...} }

type TaskDefinitionKeyValuePairArrayOutput 

type TaskDefinitionKeyValuePairArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionKeyValuePairArrayOutput) ElementType 

func (TaskDefinitionKeyValuePairArrayOutput) ElementType() reflect.Type

func (TaskDefinitionKeyValuePairArrayOutput) Index 

func (o TaskDefinitionKeyValuePairArrayOutput) Index(i pulumi.IntInput) TaskDefinitionKeyValuePairOutput

func (TaskDefinitionKeyValuePairArrayOutput) ToTaskDefinitionKeyValuePairArrayOutput 

func (o TaskDefinitionKeyValuePairArrayOutput) ToTaskDefinitionKeyValuePairArrayOutput() TaskDefinitionKeyValuePairArrayOutput

func (TaskDefinitionKeyValuePairArrayOutput) ToTaskDefinitionKeyValuePairArrayOutputWithContext 

func (o TaskDefinitionKeyValuePairArrayOutput) ToTaskDefinitionKeyValuePairArrayOutputWithContext(ctx context.Context) TaskDefinitionKeyValuePairArrayOutput

type TaskDefinitionKeyValuePairInput 

type TaskDefinitionKeyValuePairInput interface {
	pulumi.Input

	ToTaskDefinitionKeyValuePairOutput() TaskDefinitionKeyValuePairOutput
	ToTaskDefinitionKeyValuePairOutputWithContext(context.Context) TaskDefinitionKeyValuePairOutput
}

TaskDefinitionKeyValuePairInput is an input type that accepts TaskDefinitionKeyValuePairArgs and TaskDefinitionKeyValuePairOutput values. You can construct a concrete instance of `TaskDefinitionKeyValuePairInput` via: 

TaskDefinitionKeyValuePairArgs{...}

type TaskDefinitionKeyValuePairOutput 

type TaskDefinitionKeyValuePairOutput struct{ *pulumi.OutputState }

A key-value pair object.

func (TaskDefinitionKeyValuePairOutput) ElementType 

func (TaskDefinitionKeyValuePairOutput) ElementType() reflect.Type

func (TaskDefinitionKeyValuePairOutput) Name 

func (o TaskDefinitionKeyValuePairOutput) Name() pulumi.StringPtrOutput

The name of the key-value pair. For environment variables, this is the name of the environment variable.

func (TaskDefinitionKeyValuePairOutput) ToTaskDefinitionKeyValuePairOutput 

func (o TaskDefinitionKeyValuePairOutput) ToTaskDefinitionKeyValuePairOutput() TaskDefinitionKeyValuePairOutput

func (TaskDefinitionKeyValuePairOutput) ToTaskDefinitionKeyValuePairOutputWithContext 

func (o TaskDefinitionKeyValuePairOutput) ToTaskDefinitionKeyValuePairOutputWithContext(ctx context.Context) TaskDefinitionKeyValuePairOutput

func (TaskDefinitionKeyValuePairOutput) Value 

func (o TaskDefinitionKeyValuePairOutput) Value() pulumi.StringPtrOutput

The value of the key-value pair. For environment variables, this is the value of the environment variable.

type TaskDefinitionLinuxParameters 

type TaskDefinitionLinuxParameters struct {
	// The Linux capabilities for the container that are added to or dropped from the default configuration provided by Docker.
	//   For tasks that use the Fargate launch type, “capabilities“ is supported for all platform versions but the “add“ parameter is only supported if using platform version 1.4.0 or later.
	Capabilities *TaskDefinitionKernelCapabilities `pulumi:"capabilities"`
	// Any host devices to expose to the container. This parameter maps to “Devices“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--device“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   If you're using tasks that use the Fargate launch type, the “devices“ parameter isn't supported.
	Devices []TaskDefinitionDevice `pulumi:"devices"`
	// Run an “init“ process inside the container that forwards signals and reaps processes. This parameter maps to the “--init“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This parameter requires version 1.25 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	InitProcessEnabled *bool `pulumi:"initProcessEnabled"`
	// The total amount of swap memory (in MiB) a container can use. This parameter will be translated to the “--memory-swap“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration) where the value would be the sum of the container memory plus the “maxSwap“ value.
	//  If a “maxSwap“ value of “0“ is specified, the container will not use swap. Accepted values are “0“ or any positive integer. If the “maxSwap“ parameter is omitted, the container will use the swap configuration for the container instance it is running on. A “maxSwap“ value must be set for the “swappiness“ parameter to be used.
	//   If you're using tasks that use the Fargate launch type, the “maxSwap“ parameter isn't supported.
	//  If you're using tasks on Amazon Linux 2023 the “swappiness“ parameter isn't supported.
	MaxSwap *int `pulumi:"maxSwap"`
	// The value for the size (in MiB) of the “/dev/shm“ volume. This parameter maps to the “--shm-size“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   If you are using tasks that use the Fargate launch type, the “sharedMemorySize“ parameter is not supported.
	SharedMemorySize *int `pulumi:"sharedMemorySize"`
	// This allows you to tune a container's memory swappiness behavior. A “swappiness“ value of “0“ will cause swapping to not happen unless absolutely necessary. A “swappiness“ value of “100“ will cause pages to be swapped very aggressively. Accepted values are whole numbers between “0“ and “100“. If the “swappiness“ parameter is not specified, a default value of “60“ is used. If a value is not specified for “maxSwap“ then this parameter is ignored. This parameter maps to the “--memory-swappiness“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   If you're using tasks that use the Fargate launch type, the “swappiness“ parameter isn't supported.
	//  If you're using tasks on Amazon Linux 2023 the “swappiness“ parameter isn't supported.
	Swappiness *int `pulumi:"swappiness"`
	// The container path, mount options, and size (in MiB) of the tmpfs mount. This parameter maps to the “--tmpfs“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   If you're using tasks that use the Fargate launch type, the “tmpfs“ parameter isn't supported.
	Tmpfs []TaskDefinitionTmpfs `pulumi:"tmpfs"`
}

The Linux-specific options that are applied to the container, such as Linux [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).

type TaskDefinitionLinuxParametersArgs 

type TaskDefinitionLinuxParametersArgs struct {
	// The Linux capabilities for the container that are added to or dropped from the default configuration provided by Docker.
	//   For tasks that use the Fargate launch type, “capabilities“ is supported for all platform versions but the “add“ parameter is only supported if using platform version 1.4.0 or later.
	Capabilities TaskDefinitionKernelCapabilitiesPtrInput `pulumi:"capabilities"`
	// Any host devices to expose to the container. This parameter maps to “Devices“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--device“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   If you're using tasks that use the Fargate launch type, the “devices“ parameter isn't supported.
	Devices TaskDefinitionDeviceArrayInput `pulumi:"devices"`
	// Run an “init“ process inside the container that forwards signals and reaps processes. This parameter maps to the “--init“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This parameter requires version 1.25 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	InitProcessEnabled pulumi.BoolPtrInput `pulumi:"initProcessEnabled"`
	// The total amount of swap memory (in MiB) a container can use. This parameter will be translated to the “--memory-swap“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration) where the value would be the sum of the container memory plus the “maxSwap“ value.
	//  If a “maxSwap“ value of “0“ is specified, the container will not use swap. Accepted values are “0“ or any positive integer. If the “maxSwap“ parameter is omitted, the container will use the swap configuration for the container instance it is running on. A “maxSwap“ value must be set for the “swappiness“ parameter to be used.
	//   If you're using tasks that use the Fargate launch type, the “maxSwap“ parameter isn't supported.
	//  If you're using tasks on Amazon Linux 2023 the “swappiness“ parameter isn't supported.
	MaxSwap pulumi.IntPtrInput `pulumi:"maxSwap"`
	// The value for the size (in MiB) of the “/dev/shm“ volume. This parameter maps to the “--shm-size“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   If you are using tasks that use the Fargate launch type, the “sharedMemorySize“ parameter is not supported.
	SharedMemorySize pulumi.IntPtrInput `pulumi:"sharedMemorySize"`
	// This allows you to tune a container's memory swappiness behavior. A “swappiness“ value of “0“ will cause swapping to not happen unless absolutely necessary. A “swappiness“ value of “100“ will cause pages to be swapped very aggressively. Accepted values are whole numbers between “0“ and “100“. If the “swappiness“ parameter is not specified, a default value of “60“ is used. If a value is not specified for “maxSwap“ then this parameter is ignored. This parameter maps to the “--memory-swappiness“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   If you're using tasks that use the Fargate launch type, the “swappiness“ parameter isn't supported.
	//  If you're using tasks on Amazon Linux 2023 the “swappiness“ parameter isn't supported.
	Swappiness pulumi.IntPtrInput `pulumi:"swappiness"`
	// The container path, mount options, and size (in MiB) of the tmpfs mount. This parameter maps to the “--tmpfs“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration).
	//   If you're using tasks that use the Fargate launch type, the “tmpfs“ parameter isn't supported.
	Tmpfs TaskDefinitionTmpfsArrayInput `pulumi:"tmpfs"`
}

The Linux-specific options that are applied to the container, such as Linux [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).

func (TaskDefinitionLinuxParametersArgs) ElementType 

func (TaskDefinitionLinuxParametersArgs) ElementType() reflect.Type

func (TaskDefinitionLinuxParametersArgs) ToTaskDefinitionLinuxParametersOutput 

func (i TaskDefinitionLinuxParametersArgs) ToTaskDefinitionLinuxParametersOutput() TaskDefinitionLinuxParametersOutput

func (TaskDefinitionLinuxParametersArgs) ToTaskDefinitionLinuxParametersOutputWithContext 

func (i TaskDefinitionLinuxParametersArgs) ToTaskDefinitionLinuxParametersOutputWithContext(ctx context.Context) TaskDefinitionLinuxParametersOutput

func (TaskDefinitionLinuxParametersArgs) ToTaskDefinitionLinuxParametersPtrOutput 

func (i TaskDefinitionLinuxParametersArgs) ToTaskDefinitionLinuxParametersPtrOutput() TaskDefinitionLinuxParametersPtrOutput

func (TaskDefinitionLinuxParametersArgs) ToTaskDefinitionLinuxParametersPtrOutputWithContext 

func (i TaskDefinitionLinuxParametersArgs) ToTaskDefinitionLinuxParametersPtrOutputWithContext(ctx context.Context) TaskDefinitionLinuxParametersPtrOutput

type TaskDefinitionLinuxParametersInput 

type TaskDefinitionLinuxParametersInput interface {
	pulumi.Input

	ToTaskDefinitionLinuxParametersOutput() TaskDefinitionLinuxParametersOutput
	ToTaskDefinitionLinuxParametersOutputWithContext(context.Context) TaskDefinitionLinuxParametersOutput
}

TaskDefinitionLinuxParametersInput is an input type that accepts TaskDefinitionLinuxParametersArgs and TaskDefinitionLinuxParametersOutput values. You can construct a concrete instance of `TaskDefinitionLinuxParametersInput` via: 

TaskDefinitionLinuxParametersArgs{...}

type TaskDefinitionLinuxParametersOutput 

type TaskDefinitionLinuxParametersOutput struct{ *pulumi.OutputState }

The Linux-specific options that are applied to the container, such as Linux [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).

func (TaskDefinitionLinuxParametersOutput) Capabilities 

func (o TaskDefinitionLinuxParametersOutput) Capabilities() TaskDefinitionKernelCapabilitiesPtrOutput

The Linux capabilities for the container that are added to or dropped from the default configuration provided by Docker. 

For tasks that use the Fargate launch type, ``capabilities`` is supported for all platform versions but the ``add`` parameter is only supported if using platform version 1.4.0 or later.

func (TaskDefinitionLinuxParametersOutput) Devices 

func (o TaskDefinitionLinuxParametersOutput) Devices() TaskDefinitionDeviceArrayOutput

Any host devices to expose to the container. This parameter maps to “Devices“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--device“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

If you're using tasks that use the Fargate launch type, the ``devices`` parameter isn't supported.

func (TaskDefinitionLinuxParametersOutput) ElementType 

func (TaskDefinitionLinuxParametersOutput) ElementType() reflect.Type

func (TaskDefinitionLinuxParametersOutput) InitProcessEnabled 

func (o TaskDefinitionLinuxParametersOutput) InitProcessEnabled() pulumi.BoolPtrOutput

Run an “init“ process inside the container that forwards signals and reaps processes. This parameter maps to the “--init“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This parameter requires version 1.25 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“

func (TaskDefinitionLinuxParametersOutput) MaxSwap 

func (o TaskDefinitionLinuxParametersOutput) MaxSwap() pulumi.IntPtrOutput

The total amount of swap memory (in MiB) a container can use. This parameter will be translated to the “--memory-swap“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration) where the value would be the sum of the container memory plus the “maxSwap“ value. 

If a ``maxSwap`` value of ``0`` is specified, the container will not use swap. Accepted values are ``0`` or any positive integer. If the ``maxSwap`` parameter is omitted, the container will use the swap configuration for the container instance it is running on. A ``maxSwap`` value must be set for the ``swappiness`` parameter to be used.
 If you're using tasks that use the Fargate launch type, the ``maxSwap`` parameter isn't supported.
If you're using tasks on Amazon Linux 2023 the ``swappiness`` parameter isn't supported.

func (TaskDefinitionLinuxParametersOutput) SharedMemorySize 

func (o TaskDefinitionLinuxParametersOutput) SharedMemorySize() pulumi.IntPtrOutput

The value for the size (in MiB) of the “/dev/shm“ volume. This parameter maps to the “--shm-size“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

If you are using tasks that use the Fargate launch type, the ``sharedMemorySize`` parameter is not supported.

func (TaskDefinitionLinuxParametersOutput) Swappiness 

func (o TaskDefinitionLinuxParametersOutput) Swappiness() pulumi.IntPtrOutput

This allows you to tune a container's memory swappiness behavior. A “swappiness“ value of “0“ will cause swapping to not happen unless absolutely necessary. A “swappiness“ value of “100“ will cause pages to be swapped very aggressively. Accepted values are whole numbers between “0“ and “100“. If the “swappiness“ parameter is not specified, a default value of “60“ is used. If a value is not specified for “maxSwap“ then this parameter is ignored. This parameter maps to the “--memory-swappiness“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

 If you're using tasks that use the Fargate launch type, the ``swappiness`` parameter isn't supported.
If you're using tasks on Amazon Linux 2023 the ``swappiness`` parameter isn't supported.

func (TaskDefinitionLinuxParametersOutput) Tmpfs 

func (o TaskDefinitionLinuxParametersOutput) Tmpfs() TaskDefinitionTmpfsArrayOutput

The container path, mount options, and size (in MiB) of the tmpfs mount. This parameter maps to the “--tmpfs“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

If you're using tasks that use the Fargate launch type, the ``tmpfs`` parameter isn't supported.

func (TaskDefinitionLinuxParametersOutput) ToTaskDefinitionLinuxParametersOutput 

func (o TaskDefinitionLinuxParametersOutput) ToTaskDefinitionLinuxParametersOutput() TaskDefinitionLinuxParametersOutput

func (TaskDefinitionLinuxParametersOutput) ToTaskDefinitionLinuxParametersOutputWithContext 

func (o TaskDefinitionLinuxParametersOutput) ToTaskDefinitionLinuxParametersOutputWithContext(ctx context.Context) TaskDefinitionLinuxParametersOutput

func (TaskDefinitionLinuxParametersOutput) ToTaskDefinitionLinuxParametersPtrOutput 

func (o TaskDefinitionLinuxParametersOutput) ToTaskDefinitionLinuxParametersPtrOutput() TaskDefinitionLinuxParametersPtrOutput

func (TaskDefinitionLinuxParametersOutput) ToTaskDefinitionLinuxParametersPtrOutputWithContext 

func (o TaskDefinitionLinuxParametersOutput) ToTaskDefinitionLinuxParametersPtrOutputWithContext(ctx context.Context) TaskDefinitionLinuxParametersPtrOutput

type TaskDefinitionLinuxParametersPtrInput 

type TaskDefinitionLinuxParametersPtrInput interface {
	pulumi.Input

	ToTaskDefinitionLinuxParametersPtrOutput() TaskDefinitionLinuxParametersPtrOutput
	ToTaskDefinitionLinuxParametersPtrOutputWithContext(context.Context) TaskDefinitionLinuxParametersPtrOutput
}

TaskDefinitionLinuxParametersPtrInput is an input type that accepts TaskDefinitionLinuxParametersArgs, TaskDefinitionLinuxParametersPtr and TaskDefinitionLinuxParametersPtrOutput values. You can construct a concrete instance of `TaskDefinitionLinuxParametersPtrInput` via: 

        TaskDefinitionLinuxParametersArgs{...}

or:

        nil

func TaskDefinitionLinuxParametersPtr 

func TaskDefinitionLinuxParametersPtr(v *TaskDefinitionLinuxParametersArgs) TaskDefinitionLinuxParametersPtrInput

type TaskDefinitionLinuxParametersPtrOutput 

type TaskDefinitionLinuxParametersPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionLinuxParametersPtrOutput) Capabilities 

func (o TaskDefinitionLinuxParametersPtrOutput) Capabilities() TaskDefinitionKernelCapabilitiesPtrOutput

The Linux capabilities for the container that are added to or dropped from the default configuration provided by Docker. 

For tasks that use the Fargate launch type, ``capabilities`` is supported for all platform versions but the ``add`` parameter is only supported if using platform version 1.4.0 or later.

func (TaskDefinitionLinuxParametersPtrOutput) Devices 

func (o TaskDefinitionLinuxParametersPtrOutput) Devices() TaskDefinitionDeviceArrayOutput

Any host devices to expose to the container. This parameter maps to “Devices“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--device“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

If you're using tasks that use the Fargate launch type, the ``devices`` parameter isn't supported.

func (TaskDefinitionLinuxParametersPtrOutput) Elem 

func (o TaskDefinitionLinuxParametersPtrOutput) Elem() TaskDefinitionLinuxParametersOutput

func (TaskDefinitionLinuxParametersPtrOutput) ElementType 

func (TaskDefinitionLinuxParametersPtrOutput) ElementType() reflect.Type

func (TaskDefinitionLinuxParametersPtrOutput) InitProcessEnabled 

func (o TaskDefinitionLinuxParametersPtrOutput) InitProcessEnabled() pulumi.BoolPtrOutput

Run an “init“ process inside the container that forwards signals and reaps processes. This parameter maps to the “--init“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). This parameter requires version 1.25 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“

func (TaskDefinitionLinuxParametersPtrOutput) MaxSwap 

func (o TaskDefinitionLinuxParametersPtrOutput) MaxSwap() pulumi.IntPtrOutput

The total amount of swap memory (in MiB) a container can use. This parameter will be translated to the “--memory-swap“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration) where the value would be the sum of the container memory plus the “maxSwap“ value. 

If a ``maxSwap`` value of ``0`` is specified, the container will not use swap. Accepted values are ``0`` or any positive integer. If the ``maxSwap`` parameter is omitted, the container will use the swap configuration for the container instance it is running on. A ``maxSwap`` value must be set for the ``swappiness`` parameter to be used.
 If you're using tasks that use the Fargate launch type, the ``maxSwap`` parameter isn't supported.
If you're using tasks on Amazon Linux 2023 the ``swappiness`` parameter isn't supported.

func (TaskDefinitionLinuxParametersPtrOutput) SharedMemorySize 

func (o TaskDefinitionLinuxParametersPtrOutput) SharedMemorySize() pulumi.IntPtrOutput

The value for the size (in MiB) of the “/dev/shm“ volume. This parameter maps to the “--shm-size“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

If you are using tasks that use the Fargate launch type, the ``sharedMemorySize`` parameter is not supported.

func (TaskDefinitionLinuxParametersPtrOutput) Swappiness 

func (o TaskDefinitionLinuxParametersPtrOutput) Swappiness() pulumi.IntPtrOutput

This allows you to tune a container's memory swappiness behavior. A “swappiness“ value of “0“ will cause swapping to not happen unless absolutely necessary. A “swappiness“ value of “100“ will cause pages to be swapped very aggressively. Accepted values are whole numbers between “0“ and “100“. If the “swappiness“ parameter is not specified, a default value of “60“ is used. If a value is not specified for “maxSwap“ then this parameter is ignored. This parameter maps to the “--memory-swappiness“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

 If you're using tasks that use the Fargate launch type, the ``swappiness`` parameter isn't supported.
If you're using tasks on Amazon Linux 2023 the ``swappiness`` parameter isn't supported.

func (TaskDefinitionLinuxParametersPtrOutput) Tmpfs 

func (o TaskDefinitionLinuxParametersPtrOutput) Tmpfs() TaskDefinitionTmpfsArrayOutput

The container path, mount options, and size (in MiB) of the tmpfs mount. This parameter maps to the “--tmpfs“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). 

If you're using tasks that use the Fargate launch type, the ``tmpfs`` parameter isn't supported.

func (TaskDefinitionLinuxParametersPtrOutput) ToTaskDefinitionLinuxParametersPtrOutput 

func (o TaskDefinitionLinuxParametersPtrOutput) ToTaskDefinitionLinuxParametersPtrOutput() TaskDefinitionLinuxParametersPtrOutput

func (TaskDefinitionLinuxParametersPtrOutput) ToTaskDefinitionLinuxParametersPtrOutputWithContext 

func (o TaskDefinitionLinuxParametersPtrOutput) ToTaskDefinitionLinuxParametersPtrOutputWithContext(ctx context.Context) TaskDefinitionLinuxParametersPtrOutput

type TaskDefinitionLogConfiguration 

type TaskDefinitionLogConfiguration struct {
	// The log driver to use for the container.
	//  For tasks on FARGATElong, the supported log drivers are “awslogs“, “splunk“, and “awsfirelens“.
	//  For tasks hosted on Amazon EC2 instances, the supported log drivers are “awslogs“, “fluentd“, “gelf“, “json-file“, “journald“, “logentries“,“syslog“, “splunk“, and “awsfirelens“.
	//  For more information about using the “awslogs“ log driver, see [Using the awslogs log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  For more information about using the “awsfirelens“ log driver, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.
	LogDriver string `pulumi:"logDriver"`
	// The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	Options map[string]string `pulumi:"options"`
	// The secrets to pass to the log configuration. For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.
	SecretOptions []TaskDefinitionSecret `pulumi:"secretOptions"`
}

The “LogConfiguration“ property specifies log configuration options to send to a custom log driver for the container.

type TaskDefinitionLogConfigurationArgs 

type TaskDefinitionLogConfigurationArgs struct {
	// The log driver to use for the container.
	//  For tasks on FARGATElong, the supported log drivers are “awslogs“, “splunk“, and “awsfirelens“.
	//  For tasks hosted on Amazon EC2 instances, the supported log drivers are “awslogs“, “fluentd“, “gelf“, “json-file“, “journald“, “logentries“,“syslog“, “splunk“, and “awsfirelens“.
	//  For more information about using the “awslogs“ log driver, see [Using the awslogs log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.
	//  For more information about using the “awsfirelens“ log driver, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
	//   If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.
	LogDriver pulumi.StringInput `pulumi:"logDriver"`
	// The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“
	Options pulumi.StringMapInput `pulumi:"options"`
	// The secrets to pass to the log configuration. For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.
	SecretOptions TaskDefinitionSecretArrayInput `pulumi:"secretOptions"`
}

The “LogConfiguration“ property specifies log configuration options to send to a custom log driver for the container.

func (TaskDefinitionLogConfigurationArgs) ElementType 

func (TaskDefinitionLogConfigurationArgs) ElementType() reflect.Type

func (TaskDefinitionLogConfigurationArgs) ToTaskDefinitionLogConfigurationOutput 

func (i TaskDefinitionLogConfigurationArgs) ToTaskDefinitionLogConfigurationOutput() TaskDefinitionLogConfigurationOutput

func (TaskDefinitionLogConfigurationArgs) ToTaskDefinitionLogConfigurationOutputWithContext 

func (i TaskDefinitionLogConfigurationArgs) ToTaskDefinitionLogConfigurationOutputWithContext(ctx context.Context) TaskDefinitionLogConfigurationOutput

func (TaskDefinitionLogConfigurationArgs) ToTaskDefinitionLogConfigurationPtrOutput 

func (i TaskDefinitionLogConfigurationArgs) ToTaskDefinitionLogConfigurationPtrOutput() TaskDefinitionLogConfigurationPtrOutput

func (TaskDefinitionLogConfigurationArgs) ToTaskDefinitionLogConfigurationPtrOutputWithContext 

func (i TaskDefinitionLogConfigurationArgs) ToTaskDefinitionLogConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionLogConfigurationPtrOutput

type TaskDefinitionLogConfigurationInput 

type TaskDefinitionLogConfigurationInput interface {
	pulumi.Input

	ToTaskDefinitionLogConfigurationOutput() TaskDefinitionLogConfigurationOutput
	ToTaskDefinitionLogConfigurationOutputWithContext(context.Context) TaskDefinitionLogConfigurationOutput
}

TaskDefinitionLogConfigurationInput is an input type that accepts TaskDefinitionLogConfigurationArgs and TaskDefinitionLogConfigurationOutput values. You can construct a concrete instance of `TaskDefinitionLogConfigurationInput` via: 

TaskDefinitionLogConfigurationArgs{...}

type TaskDefinitionLogConfigurationOutput 

type TaskDefinitionLogConfigurationOutput struct{ *pulumi.OutputState }

The “LogConfiguration“ property specifies log configuration options to send to a custom log driver for the container.

func (TaskDefinitionLogConfigurationOutput) ElementType 

func (TaskDefinitionLogConfigurationOutput) ElementType() reflect.Type

func (TaskDefinitionLogConfigurationOutput) LogDriver 

func (o TaskDefinitionLogConfigurationOutput) LogDriver() pulumi.StringOutput

The log driver to use for the container. 

For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
For more information about using the ``awslogs`` log driver, see [Using the awslogs log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.
For more information about using the ``awsfirelens`` log driver, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
 If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.

func (TaskDefinitionLogConfigurationOutput) Options 

func (o TaskDefinitionLogConfigurationOutput) Options() pulumi.StringMapOutput

The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“

func (TaskDefinitionLogConfigurationOutput) SecretOptions 

func (o TaskDefinitionLogConfigurationOutput) SecretOptions() TaskDefinitionSecretArrayOutput

The secrets to pass to the log configuration. For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionLogConfigurationOutput) ToTaskDefinitionLogConfigurationOutput 

func (o TaskDefinitionLogConfigurationOutput) ToTaskDefinitionLogConfigurationOutput() TaskDefinitionLogConfigurationOutput

func (TaskDefinitionLogConfigurationOutput) ToTaskDefinitionLogConfigurationOutputWithContext 

func (o TaskDefinitionLogConfigurationOutput) ToTaskDefinitionLogConfigurationOutputWithContext(ctx context.Context) TaskDefinitionLogConfigurationOutput

func (TaskDefinitionLogConfigurationOutput) ToTaskDefinitionLogConfigurationPtrOutput 

func (o TaskDefinitionLogConfigurationOutput) ToTaskDefinitionLogConfigurationPtrOutput() TaskDefinitionLogConfigurationPtrOutput

func (TaskDefinitionLogConfigurationOutput) ToTaskDefinitionLogConfigurationPtrOutputWithContext 

func (o TaskDefinitionLogConfigurationOutput) ToTaskDefinitionLogConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionLogConfigurationPtrOutput

type TaskDefinitionLogConfigurationPtrInput 

type TaskDefinitionLogConfigurationPtrInput interface {
	pulumi.Input

	ToTaskDefinitionLogConfigurationPtrOutput() TaskDefinitionLogConfigurationPtrOutput
	ToTaskDefinitionLogConfigurationPtrOutputWithContext(context.Context) TaskDefinitionLogConfigurationPtrOutput
}

TaskDefinitionLogConfigurationPtrInput is an input type that accepts TaskDefinitionLogConfigurationArgs, TaskDefinitionLogConfigurationPtr and TaskDefinitionLogConfigurationPtrOutput values. You can construct a concrete instance of `TaskDefinitionLogConfigurationPtrInput` via: 

        TaskDefinitionLogConfigurationArgs{...}

or:

        nil

func TaskDefinitionLogConfigurationPtr 

func TaskDefinitionLogConfigurationPtr(v *TaskDefinitionLogConfigurationArgs) TaskDefinitionLogConfigurationPtrInput

type TaskDefinitionLogConfigurationPtrOutput 

type TaskDefinitionLogConfigurationPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionLogConfigurationPtrOutput) Elem 

func (o TaskDefinitionLogConfigurationPtrOutput) Elem() TaskDefinitionLogConfigurationOutput

func (TaskDefinitionLogConfigurationPtrOutput) ElementType 

func (TaskDefinitionLogConfigurationPtrOutput) ElementType() reflect.Type

func (TaskDefinitionLogConfigurationPtrOutput) LogDriver 

func (o TaskDefinitionLogConfigurationPtrOutput) LogDriver() pulumi.StringPtrOutput

The log driver to use for the container. 

For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.
For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``logentries``,``syslog``, ``splunk``, and ``awsfirelens``.
For more information about using the ``awslogs`` log driver, see [Using the awslogs log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.
For more information about using the ``awsfirelens`` log driver, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.
 If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.

func (TaskDefinitionLogConfigurationPtrOutput) Options 

func (o TaskDefinitionLogConfigurationPtrOutput) Options() pulumi.StringMapOutput

The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: “sudo docker version --format '{{.Server.APIVersion}}'“

func (TaskDefinitionLogConfigurationPtrOutput) SecretOptions 

func (o TaskDefinitionLogConfigurationPtrOutput) SecretOptions() TaskDefinitionSecretArrayOutput

The secrets to pass to the log configuration. For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionLogConfigurationPtrOutput) ToTaskDefinitionLogConfigurationPtrOutput 

func (o TaskDefinitionLogConfigurationPtrOutput) ToTaskDefinitionLogConfigurationPtrOutput() TaskDefinitionLogConfigurationPtrOutput

func (TaskDefinitionLogConfigurationPtrOutput) ToTaskDefinitionLogConfigurationPtrOutputWithContext 

func (o TaskDefinitionLogConfigurationPtrOutput) ToTaskDefinitionLogConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionLogConfigurationPtrOutput

type TaskDefinitionMountPoint 

type TaskDefinitionMountPoint struct {
	// The path on the container to mount the host volume at.
	ContainerPath *string `pulumi:"containerPath"`
	// If this value is “true“, the container has read-only access to the volume. If this value is “false“, then the container can write to the volume. The default value is “false“.
	ReadOnly *bool `pulumi:"readOnly"`
	// The name of the volume to mount. Must be a volume name referenced in the “name“ parameter of task definition “volume“.
	SourceVolume *string `pulumi:"sourceVolume"`
}

The details for a volume mount point that's used in a container definition.

type TaskDefinitionMountPointArgs 

type TaskDefinitionMountPointArgs struct {
	// The path on the container to mount the host volume at.
	ContainerPath pulumi.StringPtrInput `pulumi:"containerPath"`
	// If this value is “true“, the container has read-only access to the volume. If this value is “false“, then the container can write to the volume. The default value is “false“.
	ReadOnly pulumi.BoolPtrInput `pulumi:"readOnly"`
	// The name of the volume to mount. Must be a volume name referenced in the “name“ parameter of task definition “volume“.
	SourceVolume pulumi.StringPtrInput `pulumi:"sourceVolume"`
}

The details for a volume mount point that's used in a container definition.

func (TaskDefinitionMountPointArgs) ElementType 

func (TaskDefinitionMountPointArgs) ElementType() reflect.Type

func (TaskDefinitionMountPointArgs) ToTaskDefinitionMountPointOutput 

func (i TaskDefinitionMountPointArgs) ToTaskDefinitionMountPointOutput() TaskDefinitionMountPointOutput

func (TaskDefinitionMountPointArgs) ToTaskDefinitionMountPointOutputWithContext 

func (i TaskDefinitionMountPointArgs) ToTaskDefinitionMountPointOutputWithContext(ctx context.Context) TaskDefinitionMountPointOutput

type TaskDefinitionMountPointArray 

type TaskDefinitionMountPointArray []TaskDefinitionMountPointInput

func (TaskDefinitionMountPointArray) ElementType 

func (TaskDefinitionMountPointArray) ElementType() reflect.Type

func (TaskDefinitionMountPointArray) ToTaskDefinitionMountPointArrayOutput 

func (i TaskDefinitionMountPointArray) ToTaskDefinitionMountPointArrayOutput() TaskDefinitionMountPointArrayOutput

func (TaskDefinitionMountPointArray) ToTaskDefinitionMountPointArrayOutputWithContext 

func (i TaskDefinitionMountPointArray) ToTaskDefinitionMountPointArrayOutputWithContext(ctx context.Context) TaskDefinitionMountPointArrayOutput

type TaskDefinitionMountPointArrayInput 

type TaskDefinitionMountPointArrayInput interface {
	pulumi.Input

	ToTaskDefinitionMountPointArrayOutput() TaskDefinitionMountPointArrayOutput
	ToTaskDefinitionMountPointArrayOutputWithContext(context.Context) TaskDefinitionMountPointArrayOutput
}

TaskDefinitionMountPointArrayInput is an input type that accepts TaskDefinitionMountPointArray and TaskDefinitionMountPointArrayOutput values. You can construct a concrete instance of `TaskDefinitionMountPointArrayInput` via: 

TaskDefinitionMountPointArray{ TaskDefinitionMountPointArgs{...} }

type TaskDefinitionMountPointArrayOutput 

type TaskDefinitionMountPointArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionMountPointArrayOutput) ElementType 

func (TaskDefinitionMountPointArrayOutput) ElementType() reflect.Type

func (TaskDefinitionMountPointArrayOutput) Index 

func (o TaskDefinitionMountPointArrayOutput) Index(i pulumi.IntInput) TaskDefinitionMountPointOutput

func (TaskDefinitionMountPointArrayOutput) ToTaskDefinitionMountPointArrayOutput 

func (o TaskDefinitionMountPointArrayOutput) ToTaskDefinitionMountPointArrayOutput() TaskDefinitionMountPointArrayOutput

func (TaskDefinitionMountPointArrayOutput) ToTaskDefinitionMountPointArrayOutputWithContext 

func (o TaskDefinitionMountPointArrayOutput) ToTaskDefinitionMountPointArrayOutputWithContext(ctx context.Context) TaskDefinitionMountPointArrayOutput

type TaskDefinitionMountPointInput 

type TaskDefinitionMountPointInput interface {
	pulumi.Input

	ToTaskDefinitionMountPointOutput() TaskDefinitionMountPointOutput
	ToTaskDefinitionMountPointOutputWithContext(context.Context) TaskDefinitionMountPointOutput
}

TaskDefinitionMountPointInput is an input type that accepts TaskDefinitionMountPointArgs and TaskDefinitionMountPointOutput values. You can construct a concrete instance of `TaskDefinitionMountPointInput` via: 

TaskDefinitionMountPointArgs{...}

type TaskDefinitionMountPointOutput 

type TaskDefinitionMountPointOutput struct{ *pulumi.OutputState }

The details for a volume mount point that's used in a container definition.

func (TaskDefinitionMountPointOutput) ContainerPath 

func (o TaskDefinitionMountPointOutput) ContainerPath() pulumi.StringPtrOutput

The path on the container to mount the host volume at.

func (TaskDefinitionMountPointOutput) ElementType 

func (TaskDefinitionMountPointOutput) ElementType() reflect.Type

func (TaskDefinitionMountPointOutput) ReadOnly 

func (o TaskDefinitionMountPointOutput) ReadOnly() pulumi.BoolPtrOutput

If this value is “true“, the container has read-only access to the volume. If this value is “false“, then the container can write to the volume. The default value is “false“.

func (TaskDefinitionMountPointOutput) SourceVolume 

func (o TaskDefinitionMountPointOutput) SourceVolume() pulumi.StringPtrOutput

The name of the volume to mount. Must be a volume name referenced in the “name“ parameter of task definition “volume“.

func (TaskDefinitionMountPointOutput) ToTaskDefinitionMountPointOutput 

func (o TaskDefinitionMountPointOutput) ToTaskDefinitionMountPointOutput() TaskDefinitionMountPointOutput

func (TaskDefinitionMountPointOutput) ToTaskDefinitionMountPointOutputWithContext 

func (o TaskDefinitionMountPointOutput) ToTaskDefinitionMountPointOutputWithContext(ctx context.Context) TaskDefinitionMountPointOutput

type TaskDefinitionOutput 

type TaskDefinitionOutput struct{ *pulumi.OutputState }

func (TaskDefinitionOutput) ContainerDefinitions added in v0.17.0 

func (o TaskDefinitionOutput) ContainerDefinitions() TaskDefinitionContainerDefinitionArrayOutput

A list of container definitions in JSON format that describe the different containers that make up your task. For more information about container definition parameters and defaults, see [Amazon ECS Task Definitions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_defintions.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionOutput) Cpu added in v0.17.0 

func (o TaskDefinitionOutput) Cpu() pulumi.StringPtrOutput

The number of “cpu“ units used by the task. If you use the EC2 launch type, this field is optional. Any value can be used. If you use the Fargate launch type, this field is required. You must use one of the following values. The value that you choose determines your range of valid values for the “memory“ parameter. 

The CPU units cannot be less than 1 vCPU when you use Windows containers on Fargate.
 +  256 (.25 vCPU) - Available ``memory`` values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)
 +  512 (.5 vCPU) - Available ``memory`` values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)
 +  1024 (1 vCPU) - Available ``memory`` values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
 +  2048 (2 vCPU) - Available ``memory`` values: 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)
 +  4096 (4 vCPU) - Available ``memory`` values: 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)
 +  8192 (8 vCPU) - Available ``memory`` values: 16 GB and 60 GB in 4 GB increments
     This option requires Linux platform ``1.4.0`` or later.
 +  16384 (16vCPU) - Available ``memory`` values: 32GB and 120 GB in 8 GB increments
     This option requires Linux platform ``1.4.0`` or later.

func (TaskDefinitionOutput) ElementType 

func (TaskDefinitionOutput) ElementType() reflect.Type

func (TaskDefinitionOutput) EphemeralStorage added in v0.17.0 

func (o TaskDefinitionOutput) EphemeralStorage() TaskDefinitionEphemeralStoragePtrOutput

The ephemeral storage settings to use for tasks run with the task definition.

func (TaskDefinitionOutput) ExecutionRoleArn added in v0.17.0 

func (o TaskDefinitionOutput) ExecutionRoleArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the task execution role that grants the Amazon ECS container agent permission to make AWS API calls on your behalf. The task execution IAM role is required depending on the requirements of your task. For more information, see [Amazon ECS task execution IAM role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_execution_IAM_role.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionOutput) Family added in v0.17.0 

func (o TaskDefinitionOutput) Family() pulumi.StringPtrOutput

The name of a family that this task definition is registered to. Up to 255 letters (uppercase and lowercase), numbers, hyphens, and underscores are allowed. 

A family groups multiple versions of a task definition. Amazon ECS gives the first task definition that you registered to a family a revision number of 1. Amazon ECS gives sequential revision numbers to each task definition that you add.
 To use revision numbers when you update a task definition, specify this property. If you don't specify a value, CFNlong generates a new task definition each time that you update it.

func (TaskDefinitionOutput) InferenceAccelerators added in v0.17.0 

func (o TaskDefinitionOutput) InferenceAccelerators() TaskDefinitionInferenceAcceleratorArrayOutput

The Elastic Inference accelerators to use for the containers in the task.

func (TaskDefinitionOutput) IpcMode added in v0.17.0 

func (o TaskDefinitionOutput) IpcMode() pulumi.StringPtrOutput

The IPC resource namespace to use for the containers in the task. The valid values are “host“, “task“, or “none“. If “host“ is specified, then all containers within the tasks that specified the “host“ IPC mode on the same container instance share the same IPC resources with the host Amazon EC2 instance. If “task“ is specified, all containers within the specified task share the same IPC resources. If “none“ is specified, then IPC resources within the containers of a task are private and not shared with other containers in a task or on the container instance. If no value is specified, then the IPC resource namespace sharing depends on the Docker daemon setting on the container instance. For more information, see [IPC settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#ipc-settings---ipc) in the *Docker run reference*. 

If the ``host`` IPC mode is used, be aware that there is a heightened risk of undesired IPC namespace expose. For more information, see [Docker security](https://docs.aws.amazon.com/https://docs.docker.com/engine/security/security/).
If you are setting namespaced kernel parameters using ``systemControls`` for the containers in the task, the following will apply to your IPC resource namespace. For more information, see [System Controls](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html) in the *Amazon Elastic Container Service Developer Guide*.
 +  For tasks that use the ``host`` IPC mode, IPC namespace related ``systemControls`` are not supported.
 +  For tasks that use the ``task`` IPC mode, IPC namespace related ``systemControls`` will apply to all containers within a task.

 This parameter is not supported for Windows containers or tasks run on FARGATElong.

func (TaskDefinitionOutput) Memory added in v0.17.0 

func (o TaskDefinitionOutput) Memory() pulumi.StringPtrOutput

The amount (in MiB) of memory used by the task. 

If your tasks runs on Amazon EC2 instances, you must specify either a task-level memory value or a container-level memory value. This field is optional and any value can be used. If a task-level memory value is specified, the container-level memory value is optional. For more information regarding container-level memory and memory reservation, see [ContainerDefinition](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html).
If your tasks runs on FARGATElong, this field is required. You must use one of the following values. The value you choose determines your range of valid values for the ``cpu`` parameter.
 +  512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available ``cpu`` values: 256 (.25 vCPU)
 +  1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available ``cpu`` values: 512 (.5 vCPU)
 +  2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available ``cpu`` values: 1024 (1 vCPU)
 +  Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available ``cpu`` values: 2048 (2 vCPU)
 +  Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available ``cpu`` values: 4096 (4 vCPU)
 +  Between 16 GB and 60 GB in 4 GB increments - Available ``cpu`` values: 8192 (8 vCPU)
     This option requires Linux platform ``1.4.0`` or later.
 +  Between 32GB and 120 GB in 8 GB increments - Available ``cpu`` values: 16384 (16 vCPU)
     This option requires Linux platform ``1.4.0`` or later.

func (TaskDefinitionOutput) NetworkMode added in v0.17.0 

func (o TaskDefinitionOutput) NetworkMode() pulumi.StringPtrOutput

The Docker networking mode to use for the containers in the task. The valid values are “none“, “bridge“, “awsvpc“, and “host“. If no network mode is specified, the default is “bridge“. 

For Amazon ECS tasks on Fargate, the ``awsvpc`` network mode is required. For Amazon ECS tasks on Amazon EC2 Linux instances, any network mode can be used. For Amazon ECS tasks on Amazon EC2 Windows instances, ``<default>`` or ``awsvpc`` can be used. If the network mode is set to ``none``, you cannot specify port mappings in your container definitions, and the tasks containers do not have external connectivity. The ``host`` and ``awsvpc`` network modes offer the highest networking performance for containers because they use the EC2 network stack instead of the virtualized network stack provided by the ``bridge`` mode.
With the ``host`` and ``awsvpc`` network modes, exposed container ports are mapped directly to the corresponding host port (for the ``host`` network mode) or the attached elastic network interface port (for the ``awsvpc`` network mode), so you cannot take advantage of dynamic host port mappings.
 When using the ``host`` network mode, you should not run containers using the root user (UID 0). It is considered best practice to use a non-root user.
 If the network mode is ``awsvpc``, the task is allocated an elastic network interface, and you must specify a NetworkConfiguration value when you create a service or run a task with the task definition. For more information, see [Task Networking](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html) in the *Amazon Elastic Container Service Developer Guide*.
If the network mode is ``host``, you cannot run multiple instantiations of the same task on a single container instance when port mappings are used.
For more information, see [Network settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#network-settings) in the *Docker run reference*.

func (TaskDefinitionOutput) PidMode added in v0.17.0 

func (o TaskDefinitionOutput) PidMode() pulumi.StringPtrOutput

The process namespace to use for the containers in the task. The valid values are “host“ or “task“. On Fargate for Linux containers, the only valid value is “task“. For example, monitoring sidecars might need “pidMode“ to access information about other containers running in the same task. 

If ``host`` is specified, all containers within the tasks that specified the ``host`` PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance.
If ``task`` is specified, all containers within the specified task share the same process namespace.
If no value is specified, the default is a private namespace for each container. For more information, see [PID settings](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#pid-settings---pid) in the *Docker run reference*.
If the ``host`` PID mode is used, there's a heightened risk of undesired process namespace exposure. For more information, see [Docker security](https://docs.aws.amazon.com/https://docs.docker.com/engine/security/security/).
 This parameter is not supported for Windows containers.
  This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.

func (TaskDefinitionOutput) PlacementConstraints added in v0.17.0 

func (o TaskDefinitionOutput) PlacementConstraints() TaskDefinitionPlacementConstraintArrayOutput

An array of placement constraint objects to use for tasks. 

This parameter isn't supported for tasks run on FARGATElong.

func (TaskDefinitionOutput) ProxyConfiguration added in v0.17.0 

func (o TaskDefinitionOutput) ProxyConfiguration() TaskDefinitionProxyConfigurationPtrOutput

The configuration details for the App Mesh proxy. 

Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionOutput) RequiresCompatibilities added in v0.17.0 

func (o TaskDefinitionOutput) RequiresCompatibilities() pulumi.StringArrayOutput

The task launch types the task definition was validated against. The valid values are “EC2“, “FARGATE“, and “EXTERNAL“. For more information, see [Amazon ECS launch types](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionOutput) RuntimePlatform added in v0.17.0 

func (o TaskDefinitionOutput) RuntimePlatform() TaskDefinitionRuntimePlatformPtrOutput

The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type. 

When you specify a task definition in a service, this value must match the ``runtimePlatform`` value of the service.

func (TaskDefinitionOutput) Tags added in v0.17.0 

func (o TaskDefinitionOutput) Tags() aws.TagArrayOutput

The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

func (TaskDefinitionOutput) TaskDefinitionArn added in v0.17.0 

func (o TaskDefinitionOutput) TaskDefinitionArn() pulumi.StringOutput

func (TaskDefinitionOutput) TaskRoleArn added in v0.17.0 

func (o TaskDefinitionOutput) TaskRoleArn() pulumi.StringPtrOutput

The short name or full Amazon Resource Name (ARN) of the IAMlong role that grants containers in the task permission to call AWS APIs on your behalf. For more information, see [Amazon ECS Task Role](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) in the *Amazon Elastic Container Service Developer Guide*. 

IAM roles for tasks on Windows require that the ``-EnableTaskIAMRole`` option is set when you launch the Amazon ECS-optimized Windows AMI. Your containers must also run some configuration code to use the feature. For more information, see [Windows IAM roles for tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionOutput) ToTaskDefinitionOutput 

func (o TaskDefinitionOutput) ToTaskDefinitionOutput() TaskDefinitionOutput

func (TaskDefinitionOutput) ToTaskDefinitionOutputWithContext 

func (o TaskDefinitionOutput) ToTaskDefinitionOutputWithContext(ctx context.Context) TaskDefinitionOutput

func (TaskDefinitionOutput) Volumes added in v0.17.0 

func (o TaskDefinitionOutput) Volumes() TaskDefinitionVolumeArrayOutput

The list of data volume definitions for the task. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html) in the *Amazon Elastic Container Service Developer Guide*. 

The ``host`` and ``sourcePath`` parameters aren't supported for tasks run on FARGATElong.

type TaskDefinitionPlacementConstraint added in v0.2.0 

type TaskDefinitionPlacementConstraint struct {
	// A cluster query language expression to apply to the constraint. For more information, see [Cluster query language](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html) in the *Amazon Elastic Container Service Developer Guide*.
	Expression *string `pulumi:"expression"`
	// The type of constraint. The “MemberOf“ constraint restricts selection to be from a group of valid candidates.
	Type string `pulumi:"type"`
}

The constraint on task placement in the task definition. For more information, see [Task placement constraints](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) in the *Amazon Elastic Container Service Developer Guide*. 

Task placement constraints aren't supported for tasks run on FARGATElong.

type TaskDefinitionPlacementConstraintArgs added in v0.2.0 

type TaskDefinitionPlacementConstraintArgs struct {
	// A cluster query language expression to apply to the constraint. For more information, see [Cluster query language](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html) in the *Amazon Elastic Container Service Developer Guide*.
	Expression pulumi.StringPtrInput `pulumi:"expression"`
	// The type of constraint. The “MemberOf“ constraint restricts selection to be from a group of valid candidates.
	Type pulumi.StringInput `pulumi:"type"`
}

The constraint on task placement in the task definition. For more information, see [Task placement constraints](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) in the *Amazon Elastic Container Service Developer Guide*. 

Task placement constraints aren't supported for tasks run on FARGATElong.

func (TaskDefinitionPlacementConstraintArgs) ElementType added in v0.2.0 

func (TaskDefinitionPlacementConstraintArgs) ElementType() reflect.Type

func (TaskDefinitionPlacementConstraintArgs) ToTaskDefinitionPlacementConstraintOutput added in v0.2.0 

func (i TaskDefinitionPlacementConstraintArgs) ToTaskDefinitionPlacementConstraintOutput() TaskDefinitionPlacementConstraintOutput

func (TaskDefinitionPlacementConstraintArgs) ToTaskDefinitionPlacementConstraintOutputWithContext added in v0.2.0 

func (i TaskDefinitionPlacementConstraintArgs) ToTaskDefinitionPlacementConstraintOutputWithContext(ctx context.Context) TaskDefinitionPlacementConstraintOutput

type TaskDefinitionPlacementConstraintArray added in v0.2.0 

type TaskDefinitionPlacementConstraintArray []TaskDefinitionPlacementConstraintInput

func (TaskDefinitionPlacementConstraintArray) ElementType added in v0.2.0 

func (TaskDefinitionPlacementConstraintArray) ElementType() reflect.Type

func (TaskDefinitionPlacementConstraintArray) ToTaskDefinitionPlacementConstraintArrayOutput added in v0.2.0 

func (i TaskDefinitionPlacementConstraintArray) ToTaskDefinitionPlacementConstraintArrayOutput() TaskDefinitionPlacementConstraintArrayOutput

func (TaskDefinitionPlacementConstraintArray) ToTaskDefinitionPlacementConstraintArrayOutputWithContext added in v0.2.0 

func (i TaskDefinitionPlacementConstraintArray) ToTaskDefinitionPlacementConstraintArrayOutputWithContext(ctx context.Context) TaskDefinitionPlacementConstraintArrayOutput

type TaskDefinitionPlacementConstraintArrayInput added in v0.2.0 

type TaskDefinitionPlacementConstraintArrayInput interface {
	pulumi.Input

	ToTaskDefinitionPlacementConstraintArrayOutput() TaskDefinitionPlacementConstraintArrayOutput
	ToTaskDefinitionPlacementConstraintArrayOutputWithContext(context.Context) TaskDefinitionPlacementConstraintArrayOutput
}

TaskDefinitionPlacementConstraintArrayInput is an input type that accepts TaskDefinitionPlacementConstraintArray and TaskDefinitionPlacementConstraintArrayOutput values. You can construct a concrete instance of `TaskDefinitionPlacementConstraintArrayInput` via: 

TaskDefinitionPlacementConstraintArray{ TaskDefinitionPlacementConstraintArgs{...} }

type TaskDefinitionPlacementConstraintArrayOutput added in v0.2.0 

type TaskDefinitionPlacementConstraintArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionPlacementConstraintArrayOutput) ElementType added in v0.2.0 

func (TaskDefinitionPlacementConstraintArrayOutput) ElementType() reflect.Type

func (TaskDefinitionPlacementConstraintArrayOutput) Index added in v0.2.0 

func (o TaskDefinitionPlacementConstraintArrayOutput) Index(i pulumi.IntInput) TaskDefinitionPlacementConstraintOutput

func (TaskDefinitionPlacementConstraintArrayOutput) ToTaskDefinitionPlacementConstraintArrayOutput added in v0.2.0 

func (o TaskDefinitionPlacementConstraintArrayOutput) ToTaskDefinitionPlacementConstraintArrayOutput() TaskDefinitionPlacementConstraintArrayOutput

func (TaskDefinitionPlacementConstraintArrayOutput) ToTaskDefinitionPlacementConstraintArrayOutputWithContext added in v0.2.0 

func (o TaskDefinitionPlacementConstraintArrayOutput) ToTaskDefinitionPlacementConstraintArrayOutputWithContext(ctx context.Context) TaskDefinitionPlacementConstraintArrayOutput

type TaskDefinitionPlacementConstraintInput added in v0.2.0 

type TaskDefinitionPlacementConstraintInput interface {
	pulumi.Input

	ToTaskDefinitionPlacementConstraintOutput() TaskDefinitionPlacementConstraintOutput
	ToTaskDefinitionPlacementConstraintOutputWithContext(context.Context) TaskDefinitionPlacementConstraintOutput
}

TaskDefinitionPlacementConstraintInput is an input type that accepts TaskDefinitionPlacementConstraintArgs and TaskDefinitionPlacementConstraintOutput values. You can construct a concrete instance of `TaskDefinitionPlacementConstraintInput` via: 

TaskDefinitionPlacementConstraintArgs{...}

type TaskDefinitionPlacementConstraintOutput added in v0.2.0 

type TaskDefinitionPlacementConstraintOutput struct{ *pulumi.OutputState }

The constraint on task placement in the task definition. For more information, see [Task placement constraints](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html) in the *Amazon Elastic Container Service Developer Guide*. 

Task placement constraints aren't supported for tasks run on FARGATElong.

func (TaskDefinitionPlacementConstraintOutput) ElementType added in v0.2.0 

func (TaskDefinitionPlacementConstraintOutput) ElementType() reflect.Type

func (TaskDefinitionPlacementConstraintOutput) Expression added in v0.2.0 

func (o TaskDefinitionPlacementConstraintOutput) Expression() pulumi.StringPtrOutput

A cluster query language expression to apply to the constraint. For more information, see [Cluster query language](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/cluster-query-language.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionPlacementConstraintOutput) ToTaskDefinitionPlacementConstraintOutput added in v0.2.0 

func (o TaskDefinitionPlacementConstraintOutput) ToTaskDefinitionPlacementConstraintOutput() TaskDefinitionPlacementConstraintOutput

func (TaskDefinitionPlacementConstraintOutput) ToTaskDefinitionPlacementConstraintOutputWithContext added in v0.2.0 

func (o TaskDefinitionPlacementConstraintOutput) ToTaskDefinitionPlacementConstraintOutputWithContext(ctx context.Context) TaskDefinitionPlacementConstraintOutput

func (TaskDefinitionPlacementConstraintOutput) Type added in v0.2.0 

func (o TaskDefinitionPlacementConstraintOutput) Type() pulumi.StringOutput

The type of constraint. The “MemberOf“ constraint restricts selection to be from a group of valid candidates.

type TaskDefinitionPortMapping 

type TaskDefinitionPortMapping struct {
	// The application protocol that's used for the port mapping. This parameter only applies to Service Connect. We recommend that you set this parameter to be consistent with the protocol that your application uses. If you set this parameter, Amazon ECS adds protocol-specific connection handling to the Service Connect proxy. If you set this parameter, Amazon ECS adds protocol-specific telemetry in the Amazon ECS console and CloudWatch.
	//  If you don't set a value for this parameter, then TCP is used. However, Amazon ECS doesn't add protocol-specific telemetry for TCP.
	//   “appProtocol“ is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.
	//  Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	AppProtocol *TaskDefinitionPortMappingAppProtocol `pulumi:"appProtocol"`
	// The port number on the container that's bound to the user-specified or automatically assigned host port.
	//  If you use containers in a task with the “awsvpc“ or “host“ network mode, specify the exposed ports using “containerPort“.
	//  If you use containers in a task with the “bridge“ network mode and you specify a container port and not a host port, your container automatically receives a host port in the ephemeral port range. For more information, see “hostPort“. Port mappings that are automatically assigned in this way do not count toward the 100 reserved ports limit of a container instance.
	ContainerPort *int `pulumi:"containerPort"`
	// The port number range on the container that's bound to the dynamically mapped host port range.
	//  The following rules apply when you specify a “containerPortRange“:
	//   +  You must use either the “bridge“ network mode or the “awsvpc“ network mode.
	//   +  This parameter is available for both the EC2 and FARGATElong launch types.
	//   +  This parameter is available for both the Linux and Windows operating systems.
	//   +  The container instance must have at least version 1.67.0 of the container agent and at least version 1.67.0-1 of the “ecs-init“ package
	//   +  You can specify a maximum of 100 port ranges per container.
	//   +  You do not specify a “hostPortRange“. The value of the “hostPortRange“ is set as follows:
	//   +  For containers in a task with the “awsvpc“ network mode, the “hostPortRange“ is set to the same value as the “containerPortRange“. This is a static mapping strategy.
	//   +  For containers in a task with the “bridge“ network mode, the Amazon ECS agent finds open host ports from the default ephemeral range and passes it to docker to bind them to the container ports.
	//
	//   +  The “containerPortRange“ valid values are between 1 and 65535.
	//   +  A port can only be included in one port mapping per container.
	//   +  You cannot specify overlapping port ranges.
	//   +  The first port in the range must be less than last port in the range.
	//   +  Docker recommends that you turn off the docker-proxy in the Docker daemon config file when you have a large number of ports.
	//  For more information, see [Issue #11185](https://docs.aws.amazon.com/https://github.com/moby/moby/issues/11185) on the Github website.
	//  For information about how to turn off the docker-proxy in the Docker daemon config file, see [Docker daemon](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon) in the *Amazon ECS Developer Guide*.
	//
	//  You can call [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) to view the “hostPortRange“ which are the host ports that are bound to the container ports.
	ContainerPortRange *string `pulumi:"containerPortRange"`
	// The port number on the container instance to reserve for your container.
	//  If you specify a “containerPortRange“, leave this field empty and the value of the “hostPort“ is set as follows:
	//   +  For containers in a task with the “awsvpc“ network mode, the “hostPort“ is set to the same value as the “containerPort“. This is a static mapping strategy.
	//   +  For containers in a task with the “bridge“ network mode, the Amazon ECS agent finds open ports on the host and automatically binds them to the container ports. This is a dynamic mapping strategy.
	//
	//  If you use containers in a task with the “awsvpc“ or “host“ network mode, the “hostPort“ can either be left blank or set to the same value as the “containerPort“.
	//  If you use containers in a task with the “bridge“ network mode, you can specify a non-reserved host port for your container port mapping, or you can omit the “hostPort“ (or set it to “0“) while specifying a “containerPort“ and your container automatically receives a port in the ephemeral port range for your container instance operating system and Docker version.
	//  The default ephemeral port range for Docker version 1.6.0 and later is listed on the instance under “/proc/sys/net/ipv4/ip_local_port_range“. If this kernel parameter is unavailable, the default ephemeral port range from 49153 through 65535 (Linux) or 49152 through 65535 (Windows) is used. Do not attempt to specify a host port in the ephemeral port range as these are reserved for automatic assignment. In general, ports below 32768 are outside of the ephemeral port range.
	//  The default reserved ports are 22 for SSH, the Docker ports 2375 and 2376, and the Amazon ECS container agent ports 51678-51680. Any host port that was previously specified in a running task is also reserved while the task is running. That is, after a task stops, the host port is released. The current reserved ports are displayed in the “remainingResources“ of [DescribeContainerInstances](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html) output. A container instance can have up to 100 reserved ports at a time. This number includes the default reserved ports. Automatically assigned ports aren't included in the 100 reserved ports quota.
	HostPort *int `pulumi:"hostPort"`
	// The name that's used for the port mapping. This parameter only applies to Service Connect. This parameter is the name that you use in the “serviceConnectConfiguration“ of a service. The name can include up to 64 characters. The characters can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen.
	//  For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	Name *string `pulumi:"name"`
	// The protocol used for the port mapping. Valid values are “tcp“ and “udp“. The default is “tcp“. “protocol“ is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.
	Protocol *string `pulumi:"protocol"`
}

The “PortMapping“ property specifies a port mapping. Port mappings allow containers to access ports on the host container instance to send or receive traffic. Port mappings are specified as part of the container definition. 

If you are using containers in a task with the ``awsvpc`` or ``host`` network mode, exposed ports should be specified using ``containerPort``. The ``hostPort`` can be left blank or it must be the same value as the ``containerPort``.
After a task reaches the ``RUNNING`` status, manual and automatic host and container port assignments are visible in the ``networkBindings`` section of [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) API responses.

type TaskDefinitionPortMappingAppProtocol added in v0.42.0 

type TaskDefinitionPortMappingAppProtocol string

The application protocol that's used for the port mapping. This parameter only applies to Service Connect. We recommend that you set this parameter to be consistent with the protocol that your application uses. If you set this parameter, Amazon ECS adds protocol-specific connection handling to the Service Connect proxy. If you set this parameter, Amazon ECS adds protocol-specific telemetry in the Amazon ECS console and CloudWatch. 

If you don't set a value for this parameter, then TCP is used. However, Amazon ECS doesn't add protocol-specific telemetry for TCP.
 ``appProtocol`` is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.
Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionPortMappingAppProtocol) ElementType added in v0.42.0 

func (TaskDefinitionPortMappingAppProtocol) ElementType() reflect.Type

func (TaskDefinitionPortMappingAppProtocol) ToStringOutput added in v0.42.0 

func (e TaskDefinitionPortMappingAppProtocol) ToStringOutput() pulumi.StringOutput

func (TaskDefinitionPortMappingAppProtocol) ToStringOutputWithContext added in v0.42.0 

func (e TaskDefinitionPortMappingAppProtocol) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskDefinitionPortMappingAppProtocol) ToStringPtrOutput added in v0.42.0 

func (e TaskDefinitionPortMappingAppProtocol) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionPortMappingAppProtocol) ToStringPtrOutputWithContext added in v0.42.0 

func (e TaskDefinitionPortMappingAppProtocol) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionPortMappingAppProtocol) ToTaskDefinitionPortMappingAppProtocolOutput added in v0.42.0 

func (e TaskDefinitionPortMappingAppProtocol) ToTaskDefinitionPortMappingAppProtocolOutput() TaskDefinitionPortMappingAppProtocolOutput

func (TaskDefinitionPortMappingAppProtocol) ToTaskDefinitionPortMappingAppProtocolOutputWithContext added in v0.42.0 

func (e TaskDefinitionPortMappingAppProtocol) ToTaskDefinitionPortMappingAppProtocolOutputWithContext(ctx context.Context) TaskDefinitionPortMappingAppProtocolOutput

func (TaskDefinitionPortMappingAppProtocol) ToTaskDefinitionPortMappingAppProtocolPtrOutput added in v0.42.0 

func (e TaskDefinitionPortMappingAppProtocol) ToTaskDefinitionPortMappingAppProtocolPtrOutput() TaskDefinitionPortMappingAppProtocolPtrOutput

func (TaskDefinitionPortMappingAppProtocol) ToTaskDefinitionPortMappingAppProtocolPtrOutputWithContext added in v0.42.0 

func (e TaskDefinitionPortMappingAppProtocol) ToTaskDefinitionPortMappingAppProtocolPtrOutputWithContext(ctx context.Context) TaskDefinitionPortMappingAppProtocolPtrOutput

type TaskDefinitionPortMappingAppProtocolInput added in v0.42.0 

type TaskDefinitionPortMappingAppProtocolInput interface {
	pulumi.Input

	ToTaskDefinitionPortMappingAppProtocolOutput() TaskDefinitionPortMappingAppProtocolOutput
	ToTaskDefinitionPortMappingAppProtocolOutputWithContext(context.Context) TaskDefinitionPortMappingAppProtocolOutput
}

TaskDefinitionPortMappingAppProtocolInput is an input type that accepts values of the TaskDefinitionPortMappingAppProtocol enum A concrete instance of `TaskDefinitionPortMappingAppProtocolInput` can be one of the following: 

TaskDefinitionPortMappingAppProtocolHttp
TaskDefinitionPortMappingAppProtocolHttp2
TaskDefinitionPortMappingAppProtocolGrpc

type TaskDefinitionPortMappingAppProtocolOutput added in v0.42.0 

type TaskDefinitionPortMappingAppProtocolOutput struct{ *pulumi.OutputState }

func (TaskDefinitionPortMappingAppProtocolOutput) ElementType added in v0.42.0 

func (TaskDefinitionPortMappingAppProtocolOutput) ElementType() reflect.Type

func (TaskDefinitionPortMappingAppProtocolOutput) ToStringOutput added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolOutput) ToStringOutput() pulumi.StringOutput

func (TaskDefinitionPortMappingAppProtocolOutput) ToStringOutputWithContext added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskDefinitionPortMappingAppProtocolOutput) ToStringPtrOutput added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionPortMappingAppProtocolOutput) ToStringPtrOutputWithContext added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionPortMappingAppProtocolOutput) ToTaskDefinitionPortMappingAppProtocolOutput added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolOutput) ToTaskDefinitionPortMappingAppProtocolOutput() TaskDefinitionPortMappingAppProtocolOutput

func (TaskDefinitionPortMappingAppProtocolOutput) ToTaskDefinitionPortMappingAppProtocolOutputWithContext added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolOutput) ToTaskDefinitionPortMappingAppProtocolOutputWithContext(ctx context.Context) TaskDefinitionPortMappingAppProtocolOutput

func (TaskDefinitionPortMappingAppProtocolOutput) ToTaskDefinitionPortMappingAppProtocolPtrOutput added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolOutput) ToTaskDefinitionPortMappingAppProtocolPtrOutput() TaskDefinitionPortMappingAppProtocolPtrOutput

func (TaskDefinitionPortMappingAppProtocolOutput) ToTaskDefinitionPortMappingAppProtocolPtrOutputWithContext added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolOutput) ToTaskDefinitionPortMappingAppProtocolPtrOutputWithContext(ctx context.Context) TaskDefinitionPortMappingAppProtocolPtrOutput

type TaskDefinitionPortMappingAppProtocolPtrInput added in v0.42.0 

type TaskDefinitionPortMappingAppProtocolPtrInput interface {
	pulumi.Input

	ToTaskDefinitionPortMappingAppProtocolPtrOutput() TaskDefinitionPortMappingAppProtocolPtrOutput
	ToTaskDefinitionPortMappingAppProtocolPtrOutputWithContext(context.Context) TaskDefinitionPortMappingAppProtocolPtrOutput
}

func TaskDefinitionPortMappingAppProtocolPtr added in v0.42.0 

func TaskDefinitionPortMappingAppProtocolPtr(v string) TaskDefinitionPortMappingAppProtocolPtrInput

type TaskDefinitionPortMappingAppProtocolPtrOutput added in v0.42.0 

type TaskDefinitionPortMappingAppProtocolPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionPortMappingAppProtocolPtrOutput) Elem added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolPtrOutput) Elem() TaskDefinitionPortMappingAppProtocolOutput

func (TaskDefinitionPortMappingAppProtocolPtrOutput) ElementType added in v0.42.0 

func (TaskDefinitionPortMappingAppProtocolPtrOutput) ElementType() reflect.Type

func (TaskDefinitionPortMappingAppProtocolPtrOutput) ToStringPtrOutput added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskDefinitionPortMappingAppProtocolPtrOutput) ToStringPtrOutputWithContext added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskDefinitionPortMappingAppProtocolPtrOutput) ToTaskDefinitionPortMappingAppProtocolPtrOutput added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolPtrOutput) ToTaskDefinitionPortMappingAppProtocolPtrOutput() TaskDefinitionPortMappingAppProtocolPtrOutput

func (TaskDefinitionPortMappingAppProtocolPtrOutput) ToTaskDefinitionPortMappingAppProtocolPtrOutputWithContext added in v0.42.0 

func (o TaskDefinitionPortMappingAppProtocolPtrOutput) ToTaskDefinitionPortMappingAppProtocolPtrOutputWithContext(ctx context.Context) TaskDefinitionPortMappingAppProtocolPtrOutput

type TaskDefinitionPortMappingArgs 

type TaskDefinitionPortMappingArgs struct {
	// The application protocol that's used for the port mapping. This parameter only applies to Service Connect. We recommend that you set this parameter to be consistent with the protocol that your application uses. If you set this parameter, Amazon ECS adds protocol-specific connection handling to the Service Connect proxy. If you set this parameter, Amazon ECS adds protocol-specific telemetry in the Amazon ECS console and CloudWatch.
	//  If you don't set a value for this parameter, then TCP is used. However, Amazon ECS doesn't add protocol-specific telemetry for TCP.
	//   “appProtocol“ is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.
	//  Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	AppProtocol TaskDefinitionPortMappingAppProtocolPtrInput `pulumi:"appProtocol"`
	// The port number on the container that's bound to the user-specified or automatically assigned host port.
	//  If you use containers in a task with the “awsvpc“ or “host“ network mode, specify the exposed ports using “containerPort“.
	//  If you use containers in a task with the “bridge“ network mode and you specify a container port and not a host port, your container automatically receives a host port in the ephemeral port range. For more information, see “hostPort“. Port mappings that are automatically assigned in this way do not count toward the 100 reserved ports limit of a container instance.
	ContainerPort pulumi.IntPtrInput `pulumi:"containerPort"`
	// The port number range on the container that's bound to the dynamically mapped host port range.
	//  The following rules apply when you specify a “containerPortRange“:
	//   +  You must use either the “bridge“ network mode or the “awsvpc“ network mode.
	//   +  This parameter is available for both the EC2 and FARGATElong launch types.
	//   +  This parameter is available for both the Linux and Windows operating systems.
	//   +  The container instance must have at least version 1.67.0 of the container agent and at least version 1.67.0-1 of the “ecs-init“ package
	//   +  You can specify a maximum of 100 port ranges per container.
	//   +  You do not specify a “hostPortRange“. The value of the “hostPortRange“ is set as follows:
	//   +  For containers in a task with the “awsvpc“ network mode, the “hostPortRange“ is set to the same value as the “containerPortRange“. This is a static mapping strategy.
	//   +  For containers in a task with the “bridge“ network mode, the Amazon ECS agent finds open host ports from the default ephemeral range and passes it to docker to bind them to the container ports.
	//
	//   +  The “containerPortRange“ valid values are between 1 and 65535.
	//   +  A port can only be included in one port mapping per container.
	//   +  You cannot specify overlapping port ranges.
	//   +  The first port in the range must be less than last port in the range.
	//   +  Docker recommends that you turn off the docker-proxy in the Docker daemon config file when you have a large number of ports.
	//  For more information, see [Issue #11185](https://docs.aws.amazon.com/https://github.com/moby/moby/issues/11185) on the Github website.
	//  For information about how to turn off the docker-proxy in the Docker daemon config file, see [Docker daemon](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon) in the *Amazon ECS Developer Guide*.
	//
	//  You can call [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) to view the “hostPortRange“ which are the host ports that are bound to the container ports.
	ContainerPortRange pulumi.StringPtrInput `pulumi:"containerPortRange"`
	// The port number on the container instance to reserve for your container.
	//  If you specify a “containerPortRange“, leave this field empty and the value of the “hostPort“ is set as follows:
	//   +  For containers in a task with the “awsvpc“ network mode, the “hostPort“ is set to the same value as the “containerPort“. This is a static mapping strategy.
	//   +  For containers in a task with the “bridge“ network mode, the Amazon ECS agent finds open ports on the host and automatically binds them to the container ports. This is a dynamic mapping strategy.
	//
	//  If you use containers in a task with the “awsvpc“ or “host“ network mode, the “hostPort“ can either be left blank or set to the same value as the “containerPort“.
	//  If you use containers in a task with the “bridge“ network mode, you can specify a non-reserved host port for your container port mapping, or you can omit the “hostPort“ (or set it to “0“) while specifying a “containerPort“ and your container automatically receives a port in the ephemeral port range for your container instance operating system and Docker version.
	//  The default ephemeral port range for Docker version 1.6.0 and later is listed on the instance under “/proc/sys/net/ipv4/ip_local_port_range“. If this kernel parameter is unavailable, the default ephemeral port range from 49153 through 65535 (Linux) or 49152 through 65535 (Windows) is used. Do not attempt to specify a host port in the ephemeral port range as these are reserved for automatic assignment. In general, ports below 32768 are outside of the ephemeral port range.
	//  The default reserved ports are 22 for SSH, the Docker ports 2375 and 2376, and the Amazon ECS container agent ports 51678-51680. Any host port that was previously specified in a running task is also reserved while the task is running. That is, after a task stops, the host port is released. The current reserved ports are displayed in the “remainingResources“ of [DescribeContainerInstances](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html) output. A container instance can have up to 100 reserved ports at a time. This number includes the default reserved ports. Automatically assigned ports aren't included in the 100 reserved ports quota.
	HostPort pulumi.IntPtrInput `pulumi:"hostPort"`
	// The name that's used for the port mapping. This parameter only applies to Service Connect. This parameter is the name that you use in the “serviceConnectConfiguration“ of a service. The name can include up to 64 characters. The characters can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen.
	//  For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The protocol used for the port mapping. Valid values are “tcp“ and “udp“. The default is “tcp“. “protocol“ is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.
	Protocol pulumi.StringPtrInput `pulumi:"protocol"`
}

The “PortMapping“ property specifies a port mapping. Port mappings allow containers to access ports on the host container instance to send or receive traffic. Port mappings are specified as part of the container definition. 

If you are using containers in a task with the ``awsvpc`` or ``host`` network mode, exposed ports should be specified using ``containerPort``. The ``hostPort`` can be left blank or it must be the same value as the ``containerPort``.
After a task reaches the ``RUNNING`` status, manual and automatic host and container port assignments are visible in the ``networkBindings`` section of [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) API responses.

func (TaskDefinitionPortMappingArgs) ElementType 

func (TaskDefinitionPortMappingArgs) ElementType() reflect.Type

func (TaskDefinitionPortMappingArgs) ToTaskDefinitionPortMappingOutput 

func (i TaskDefinitionPortMappingArgs) ToTaskDefinitionPortMappingOutput() TaskDefinitionPortMappingOutput

func (TaskDefinitionPortMappingArgs) ToTaskDefinitionPortMappingOutputWithContext 

func (i TaskDefinitionPortMappingArgs) ToTaskDefinitionPortMappingOutputWithContext(ctx context.Context) TaskDefinitionPortMappingOutput

type TaskDefinitionPortMappingArray 

type TaskDefinitionPortMappingArray []TaskDefinitionPortMappingInput

func (TaskDefinitionPortMappingArray) ElementType 

func (TaskDefinitionPortMappingArray) ElementType() reflect.Type

func (TaskDefinitionPortMappingArray) ToTaskDefinitionPortMappingArrayOutput 

func (i TaskDefinitionPortMappingArray) ToTaskDefinitionPortMappingArrayOutput() TaskDefinitionPortMappingArrayOutput

func (TaskDefinitionPortMappingArray) ToTaskDefinitionPortMappingArrayOutputWithContext 

func (i TaskDefinitionPortMappingArray) ToTaskDefinitionPortMappingArrayOutputWithContext(ctx context.Context) TaskDefinitionPortMappingArrayOutput

type TaskDefinitionPortMappingArrayInput 

type TaskDefinitionPortMappingArrayInput interface {
	pulumi.Input

	ToTaskDefinitionPortMappingArrayOutput() TaskDefinitionPortMappingArrayOutput
	ToTaskDefinitionPortMappingArrayOutputWithContext(context.Context) TaskDefinitionPortMappingArrayOutput
}

TaskDefinitionPortMappingArrayInput is an input type that accepts TaskDefinitionPortMappingArray and TaskDefinitionPortMappingArrayOutput values. You can construct a concrete instance of `TaskDefinitionPortMappingArrayInput` via: 

TaskDefinitionPortMappingArray{ TaskDefinitionPortMappingArgs{...} }

type TaskDefinitionPortMappingArrayOutput 

type TaskDefinitionPortMappingArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionPortMappingArrayOutput) ElementType 

func (TaskDefinitionPortMappingArrayOutput) ElementType() reflect.Type

func (TaskDefinitionPortMappingArrayOutput) Index 

func (o TaskDefinitionPortMappingArrayOutput) Index(i pulumi.IntInput) TaskDefinitionPortMappingOutput

func (TaskDefinitionPortMappingArrayOutput) ToTaskDefinitionPortMappingArrayOutput 

func (o TaskDefinitionPortMappingArrayOutput) ToTaskDefinitionPortMappingArrayOutput() TaskDefinitionPortMappingArrayOutput

func (TaskDefinitionPortMappingArrayOutput) ToTaskDefinitionPortMappingArrayOutputWithContext 

func (o TaskDefinitionPortMappingArrayOutput) ToTaskDefinitionPortMappingArrayOutputWithContext(ctx context.Context) TaskDefinitionPortMappingArrayOutput

type TaskDefinitionPortMappingInput 

type TaskDefinitionPortMappingInput interface {
	pulumi.Input

	ToTaskDefinitionPortMappingOutput() TaskDefinitionPortMappingOutput
	ToTaskDefinitionPortMappingOutputWithContext(context.Context) TaskDefinitionPortMappingOutput
}

TaskDefinitionPortMappingInput is an input type that accepts TaskDefinitionPortMappingArgs and TaskDefinitionPortMappingOutput values. You can construct a concrete instance of `TaskDefinitionPortMappingInput` via: 

TaskDefinitionPortMappingArgs{...}

type TaskDefinitionPortMappingOutput 

type TaskDefinitionPortMappingOutput struct{ *pulumi.OutputState }

The “PortMapping“ property specifies a port mapping. Port mappings allow containers to access ports on the host container instance to send or receive traffic. Port mappings are specified as part of the container definition. 

If you are using containers in a task with the ``awsvpc`` or ``host`` network mode, exposed ports should be specified using ``containerPort``. The ``hostPort`` can be left blank or it must be the same value as the ``containerPort``.
After a task reaches the ``RUNNING`` status, manual and automatic host and container port assignments are visible in the ``networkBindings`` section of [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) API responses.

func (TaskDefinitionPortMappingOutput) AppProtocol added in v0.42.0 

func (o TaskDefinitionPortMappingOutput) AppProtocol() TaskDefinitionPortMappingAppProtocolPtrOutput

The application protocol that's used for the port mapping. This parameter only applies to Service Connect. We recommend that you set this parameter to be consistent with the protocol that your application uses. If you set this parameter, Amazon ECS adds protocol-specific connection handling to the Service Connect proxy. If you set this parameter, Amazon ECS adds protocol-specific telemetry in the Amazon ECS console and CloudWatch. 

If you don't set a value for this parameter, then TCP is used. However, Amazon ECS doesn't add protocol-specific telemetry for TCP.
 ``appProtocol`` is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.
Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionPortMappingOutput) ContainerPort 

func (o TaskDefinitionPortMappingOutput) ContainerPort() pulumi.IntPtrOutput

The port number on the container that's bound to the user-specified or automatically assigned host port. 

If you use containers in a task with the ``awsvpc`` or ``host`` network mode, specify the exposed ports using ``containerPort``.
If you use containers in a task with the ``bridge`` network mode and you specify a container port and not a host port, your container automatically receives a host port in the ephemeral port range. For more information, see ``hostPort``. Port mappings that are automatically assigned in this way do not count toward the 100 reserved ports limit of a container instance.

func (TaskDefinitionPortMappingOutput) ContainerPortRange added in v0.45.0 

func (o TaskDefinitionPortMappingOutput) ContainerPortRange() pulumi.StringPtrOutput

The port number range on the container that's bound to the dynamically mapped host port range. 

The following rules apply when you specify a ``containerPortRange``:
 +  You must use either the ``bridge`` network mode or the ``awsvpc`` network mode.
 +  This parameter is available for both the EC2 and FARGATElong launch types.
 +  This parameter is available for both the Linux and Windows operating systems.
 +  The container instance must have at least version 1.67.0 of the container agent and at least version 1.67.0-1 of the ``ecs-init`` package
 +  You can specify a maximum of 100 port ranges per container.
 +  You do not specify a ``hostPortRange``. The value of the ``hostPortRange`` is set as follows:
 +  For containers in a task with the ``awsvpc`` network mode, the ``hostPortRange`` is set to the same value as the ``containerPortRange``. This is a static mapping strategy.
 +  For containers in a task with the ``bridge`` network mode, the Amazon ECS agent finds open host ports from the default ephemeral range and passes it to docker to bind them to the container ports.

 +  The ``containerPortRange`` valid values are between 1 and 65535.
 +  A port can only be included in one port mapping per container.
 +  You cannot specify overlapping port ranges.
 +  The first port in the range must be less than last port in the range.
 +  Docker recommends that you turn off the docker-proxy in the Docker daemon config file when you have a large number of ports.
For more information, see [Issue #11185](https://docs.aws.amazon.com/https://github.com/moby/moby/issues/11185) on the Github website.
For information about how to turn off the docker-proxy in the Docker daemon config file, see [Docker daemon](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon) in the *Amazon ECS Developer Guide*.

You can call [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) to view the ``hostPortRange`` which are the host ports that are bound to the container ports.

func (TaskDefinitionPortMappingOutput) ElementType 

func (TaskDefinitionPortMappingOutput) ElementType() reflect.Type

func (TaskDefinitionPortMappingOutput) HostPort 

func (o TaskDefinitionPortMappingOutput) HostPort() pulumi.IntPtrOutput

The port number on the container instance to reserve for your container. 

If you specify a ``containerPortRange``, leave this field empty and the value of the ``hostPort`` is set as follows:
 +  For containers in a task with the ``awsvpc`` network mode, the ``hostPort`` is set to the same value as the ``containerPort``. This is a static mapping strategy.
 +  For containers in a task with the ``bridge`` network mode, the Amazon ECS agent finds open ports on the host and automatically binds them to the container ports. This is a dynamic mapping strategy.

If you use containers in a task with the ``awsvpc`` or ``host`` network mode, the ``hostPort`` can either be left blank or set to the same value as the ``containerPort``.
If you use containers in a task with the ``bridge`` network mode, you can specify a non-reserved host port for your container port mapping, or you can omit the ``hostPort`` (or set it to ``0``) while specifying a ``containerPort`` and your container automatically receives a port in the ephemeral port range for your container instance operating system and Docker version.
The default ephemeral port range for Docker version 1.6.0 and later is listed on the instance under ``/proc/sys/net/ipv4/ip_local_port_range``. If this kernel parameter is unavailable, the default ephemeral port range from 49153 through 65535 (Linux) or 49152 through 65535 (Windows) is used. Do not attempt to specify a host port in the ephemeral port range as these are reserved for automatic assignment. In general, ports below 32768 are outside of the ephemeral port range.
The default reserved ports are 22 for SSH, the Docker ports 2375 and 2376, and the Amazon ECS container agent ports 51678-51680. Any host port that was previously specified in a running task is also reserved while the task is running. That is, after a task stops, the host port is released. The current reserved ports are displayed in the ``remainingResources`` of [DescribeContainerInstances](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html) output. A container instance can have up to 100 reserved ports at a time. This number includes the default reserved ports. Automatically assigned ports aren't included in the 100 reserved ports quota.

func (TaskDefinitionPortMappingOutput) Name added in v0.42.0 

func (o TaskDefinitionPortMappingOutput) Name() pulumi.StringPtrOutput

The name that's used for the port mapping. This parameter only applies to Service Connect. This parameter is the name that you use in the “serviceConnectConfiguration“ of a service. The name can include up to 64 characters. The characters can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen. 

For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionPortMappingOutput) Protocol 

func (o TaskDefinitionPortMappingOutput) Protocol() pulumi.StringPtrOutput

The protocol used for the port mapping. Valid values are “tcp“ and “udp“. The default is “tcp“. “protocol“ is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.

func (TaskDefinitionPortMappingOutput) ToTaskDefinitionPortMappingOutput 

func (o TaskDefinitionPortMappingOutput) ToTaskDefinitionPortMappingOutput() TaskDefinitionPortMappingOutput

func (TaskDefinitionPortMappingOutput) ToTaskDefinitionPortMappingOutputWithContext 

func (o TaskDefinitionPortMappingOutput) ToTaskDefinitionPortMappingOutputWithContext(ctx context.Context) TaskDefinitionPortMappingOutput

type TaskDefinitionProxyConfiguration 

type TaskDefinitionProxyConfiguration struct {
	// The name of the container that will serve as the App Mesh proxy.
	ContainerName string `pulumi:"containerName"`
	// The set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified as key-value pairs.
	//   +   “IgnoredUID“ - (Required) The user ID (UID) of the proxy container as defined by the “user“ parameter in a container definition. This is used to ensure the proxy ignores its own traffic. If “IgnoredGID“ is specified, this field can be empty.
	//   +   “IgnoredGID“ - (Required) The group ID (GID) of the proxy container as defined by the “user“ parameter in a container definition. This is used to ensure the proxy ignores its own traffic. If “IgnoredUID“ is specified, this field can be empty.
	//   +   “AppPorts“ - (Required) The list of ports that the application uses. Network traffic to these ports is forwarded to the “ProxyIngressPort“ and “ProxyEgressPort“.
	//   +   “ProxyIngressPort“ - (Required) Specifies the port that incoming traffic to the “AppPorts“ is directed to.
	//   +   “ProxyEgressPort“ - (Required) Specifies the port that outgoing traffic from the “AppPorts“ is directed to.
	//   +   “EgressIgnoredPorts“ - (Required) The egress traffic going to the specified ports is ignored and not redirected to the “ProxyEgressPort“. It can be an empty list.
	//   +   “EgressIgnoredIPs“ - (Required) The egress traffic going to the specified IP addresses is ignored and not redirected to the “ProxyEgressPort“. It can be an empty list.
	ProxyConfigurationProperties []TaskDefinitionKeyValuePair `pulumi:"proxyConfigurationProperties"`
	// The proxy type. The only supported value is “APPMESH“.
	Type *string `pulumi:"type"`
}

The configuration details for the App Mesh proxy. 

For tasks that use the EC2 launch type, the container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)

type TaskDefinitionProxyConfigurationArgs 

type TaskDefinitionProxyConfigurationArgs struct {
	// The name of the container that will serve as the App Mesh proxy.
	ContainerName pulumi.StringInput `pulumi:"containerName"`
	// The set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified as key-value pairs.
	//   +   “IgnoredUID“ - (Required) The user ID (UID) of the proxy container as defined by the “user“ parameter in a container definition. This is used to ensure the proxy ignores its own traffic. If “IgnoredGID“ is specified, this field can be empty.
	//   +   “IgnoredGID“ - (Required) The group ID (GID) of the proxy container as defined by the “user“ parameter in a container definition. This is used to ensure the proxy ignores its own traffic. If “IgnoredUID“ is specified, this field can be empty.
	//   +   “AppPorts“ - (Required) The list of ports that the application uses. Network traffic to these ports is forwarded to the “ProxyIngressPort“ and “ProxyEgressPort“.
	//   +   “ProxyIngressPort“ - (Required) Specifies the port that incoming traffic to the “AppPorts“ is directed to.
	//   +   “ProxyEgressPort“ - (Required) Specifies the port that outgoing traffic from the “AppPorts“ is directed to.
	//   +   “EgressIgnoredPorts“ - (Required) The egress traffic going to the specified ports is ignored and not redirected to the “ProxyEgressPort“. It can be an empty list.
	//   +   “EgressIgnoredIPs“ - (Required) The egress traffic going to the specified IP addresses is ignored and not redirected to the “ProxyEgressPort“. It can be an empty list.
	ProxyConfigurationProperties TaskDefinitionKeyValuePairArrayInput `pulumi:"proxyConfigurationProperties"`
	// The proxy type. The only supported value is “APPMESH“.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

The configuration details for the App Mesh proxy. 

For tasks that use the EC2 launch type, the container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)

func (TaskDefinitionProxyConfigurationArgs) ElementType 

func (TaskDefinitionProxyConfigurationArgs) ElementType() reflect.Type

func (TaskDefinitionProxyConfigurationArgs) ToTaskDefinitionProxyConfigurationOutput 

func (i TaskDefinitionProxyConfigurationArgs) ToTaskDefinitionProxyConfigurationOutput() TaskDefinitionProxyConfigurationOutput

func (TaskDefinitionProxyConfigurationArgs) ToTaskDefinitionProxyConfigurationOutputWithContext 

func (i TaskDefinitionProxyConfigurationArgs) ToTaskDefinitionProxyConfigurationOutputWithContext(ctx context.Context) TaskDefinitionProxyConfigurationOutput

func (TaskDefinitionProxyConfigurationArgs) ToTaskDefinitionProxyConfigurationPtrOutput 

func (i TaskDefinitionProxyConfigurationArgs) ToTaskDefinitionProxyConfigurationPtrOutput() TaskDefinitionProxyConfigurationPtrOutput

func (TaskDefinitionProxyConfigurationArgs) ToTaskDefinitionProxyConfigurationPtrOutputWithContext 

func (i TaskDefinitionProxyConfigurationArgs) ToTaskDefinitionProxyConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionProxyConfigurationPtrOutput

type TaskDefinitionProxyConfigurationInput 

type TaskDefinitionProxyConfigurationInput interface {
	pulumi.Input

	ToTaskDefinitionProxyConfigurationOutput() TaskDefinitionProxyConfigurationOutput
	ToTaskDefinitionProxyConfigurationOutputWithContext(context.Context) TaskDefinitionProxyConfigurationOutput
}

TaskDefinitionProxyConfigurationInput is an input type that accepts TaskDefinitionProxyConfigurationArgs and TaskDefinitionProxyConfigurationOutput values. You can construct a concrete instance of `TaskDefinitionProxyConfigurationInput` via: 

TaskDefinitionProxyConfigurationArgs{...}

type TaskDefinitionProxyConfigurationOutput 

type TaskDefinitionProxyConfigurationOutput struct{ *pulumi.OutputState }

The configuration details for the App Mesh proxy. 

For tasks that use the EC2 launch type, the container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, then they contain the required versions of the container agent and ``ecs-init``. For more information, see [Amazon ECS-optimized Linux AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html)

func (TaskDefinitionProxyConfigurationOutput) ContainerName 

func (o TaskDefinitionProxyConfigurationOutput) ContainerName() pulumi.StringOutput

The name of the container that will serve as the App Mesh proxy.

func (TaskDefinitionProxyConfigurationOutput) ElementType 

func (TaskDefinitionProxyConfigurationOutput) ElementType() reflect.Type

func (TaskDefinitionProxyConfigurationOutput) ProxyConfigurationProperties 

func (o TaskDefinitionProxyConfigurationOutput) ProxyConfigurationProperties() TaskDefinitionKeyValuePairArrayOutput

The set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified as key-value pairs.

  • “IgnoredUID“ - (Required) The user ID (UID) of the proxy container as defined by the “user“ parameter in a container definition. This is used to ensure the proxy ignores its own traffic. If “IgnoredGID“ is specified, this field can be empty.
  • “IgnoredGID“ - (Required) The group ID (GID) of the proxy container as defined by the “user“ parameter in a container definition. This is used to ensure the proxy ignores its own traffic. If “IgnoredUID“ is specified, this field can be empty.
  • “AppPorts“ - (Required) The list of ports that the application uses. Network traffic to these ports is forwarded to the “ProxyIngressPort“ and “ProxyEgressPort“.
  • “ProxyIngressPort“ - (Required) Specifies the port that incoming traffic to the “AppPorts“ is directed to.
  • “ProxyEgressPort“ - (Required) Specifies the port that outgoing traffic from the “AppPorts“ is directed to.
  • “EgressIgnoredPorts“ - (Required) The egress traffic going to the specified ports is ignored and not redirected to the “ProxyEgressPort“. It can be an empty list.
  • “EgressIgnoredIPs“ - (Required) The egress traffic going to the specified IP addresses is ignored and not redirected to the “ProxyEgressPort“. It can be an empty list.

func (TaskDefinitionProxyConfigurationOutput) ToTaskDefinitionProxyConfigurationOutput 

func (o TaskDefinitionProxyConfigurationOutput) ToTaskDefinitionProxyConfigurationOutput() TaskDefinitionProxyConfigurationOutput

func (TaskDefinitionProxyConfigurationOutput) ToTaskDefinitionProxyConfigurationOutputWithContext 

func (o TaskDefinitionProxyConfigurationOutput) ToTaskDefinitionProxyConfigurationOutputWithContext(ctx context.Context) TaskDefinitionProxyConfigurationOutput

func (TaskDefinitionProxyConfigurationOutput) ToTaskDefinitionProxyConfigurationPtrOutput 

func (o TaskDefinitionProxyConfigurationOutput) ToTaskDefinitionProxyConfigurationPtrOutput() TaskDefinitionProxyConfigurationPtrOutput

func (TaskDefinitionProxyConfigurationOutput) ToTaskDefinitionProxyConfigurationPtrOutputWithContext 

func (o TaskDefinitionProxyConfigurationOutput) ToTaskDefinitionProxyConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionProxyConfigurationPtrOutput

func (TaskDefinitionProxyConfigurationOutput) Type 

func (o TaskDefinitionProxyConfigurationOutput) Type() pulumi.StringPtrOutput

The proxy type. The only supported value is “APPMESH“.

type TaskDefinitionProxyConfigurationPtrInput 

type TaskDefinitionProxyConfigurationPtrInput interface {
	pulumi.Input

	ToTaskDefinitionProxyConfigurationPtrOutput() TaskDefinitionProxyConfigurationPtrOutput
	ToTaskDefinitionProxyConfigurationPtrOutputWithContext(context.Context) TaskDefinitionProxyConfigurationPtrOutput
}

TaskDefinitionProxyConfigurationPtrInput is an input type that accepts TaskDefinitionProxyConfigurationArgs, TaskDefinitionProxyConfigurationPtr and TaskDefinitionProxyConfigurationPtrOutput values. You can construct a concrete instance of `TaskDefinitionProxyConfigurationPtrInput` via: 

        TaskDefinitionProxyConfigurationArgs{...}

or:

        nil

func TaskDefinitionProxyConfigurationPtr 

func TaskDefinitionProxyConfigurationPtr(v *TaskDefinitionProxyConfigurationArgs) TaskDefinitionProxyConfigurationPtrInput

type TaskDefinitionProxyConfigurationPtrOutput 

type TaskDefinitionProxyConfigurationPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionProxyConfigurationPtrOutput) ContainerName 

func (o TaskDefinitionProxyConfigurationPtrOutput) ContainerName() pulumi.StringPtrOutput

The name of the container that will serve as the App Mesh proxy.

func (TaskDefinitionProxyConfigurationPtrOutput) Elem 

func (o TaskDefinitionProxyConfigurationPtrOutput) Elem() TaskDefinitionProxyConfigurationOutput

func (TaskDefinitionProxyConfigurationPtrOutput) ElementType 

func (TaskDefinitionProxyConfigurationPtrOutput) ElementType() reflect.Type

func (TaskDefinitionProxyConfigurationPtrOutput) ProxyConfigurationProperties 

func (o TaskDefinitionProxyConfigurationPtrOutput) ProxyConfigurationProperties() TaskDefinitionKeyValuePairArrayOutput

The set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified as key-value pairs.

  • “IgnoredUID“ - (Required) The user ID (UID) of the proxy container as defined by the “user“ parameter in a container definition. This is used to ensure the proxy ignores its own traffic. If “IgnoredGID“ is specified, this field can be empty.
  • “IgnoredGID“ - (Required) The group ID (GID) of the proxy container as defined by the “user“ parameter in a container definition. This is used to ensure the proxy ignores its own traffic. If “IgnoredUID“ is specified, this field can be empty.
  • “AppPorts“ - (Required) The list of ports that the application uses. Network traffic to these ports is forwarded to the “ProxyIngressPort“ and “ProxyEgressPort“.
  • “ProxyIngressPort“ - (Required) Specifies the port that incoming traffic to the “AppPorts“ is directed to.
  • “ProxyEgressPort“ - (Required) Specifies the port that outgoing traffic from the “AppPorts“ is directed to.
  • “EgressIgnoredPorts“ - (Required) The egress traffic going to the specified ports is ignored and not redirected to the “ProxyEgressPort“. It can be an empty list.
  • “EgressIgnoredIPs“ - (Required) The egress traffic going to the specified IP addresses is ignored and not redirected to the “ProxyEgressPort“. It can be an empty list.

func (TaskDefinitionProxyConfigurationPtrOutput) ToTaskDefinitionProxyConfigurationPtrOutput 

func (o TaskDefinitionProxyConfigurationPtrOutput) ToTaskDefinitionProxyConfigurationPtrOutput() TaskDefinitionProxyConfigurationPtrOutput

func (TaskDefinitionProxyConfigurationPtrOutput) ToTaskDefinitionProxyConfigurationPtrOutputWithContext 

func (o TaskDefinitionProxyConfigurationPtrOutput) ToTaskDefinitionProxyConfigurationPtrOutputWithContext(ctx context.Context) TaskDefinitionProxyConfigurationPtrOutput

func (TaskDefinitionProxyConfigurationPtrOutput) Type 

func (o TaskDefinitionProxyConfigurationPtrOutput) Type() pulumi.StringPtrOutput

The proxy type. The only supported value is “APPMESH“.

type TaskDefinitionRepositoryCredentials 

type TaskDefinitionRepositoryCredentials struct {
	// The Amazon Resource Name (ARN) of the secret containing the private repository credentials.
	//   When you use the Amazon ECS API, CLI, or AWS SDK, if the secret exists in the same Region as the task that you're launching then you can use either the full ARN or the name of the secret. When you use the AWS Management Console, you must specify the full ARN of the secret.
	CredentialsParameter *string `pulumi:"credentialsParameter"`
}

The repository credentials for private registry authentication.

type TaskDefinitionRepositoryCredentialsArgs 

type TaskDefinitionRepositoryCredentialsArgs struct {
	// The Amazon Resource Name (ARN) of the secret containing the private repository credentials.
	//   When you use the Amazon ECS API, CLI, or AWS SDK, if the secret exists in the same Region as the task that you're launching then you can use either the full ARN or the name of the secret. When you use the AWS Management Console, you must specify the full ARN of the secret.
	CredentialsParameter pulumi.StringPtrInput `pulumi:"credentialsParameter"`
}

The repository credentials for private registry authentication.

func (TaskDefinitionRepositoryCredentialsArgs) ElementType 

func (TaskDefinitionRepositoryCredentialsArgs) ElementType() reflect.Type

func (TaskDefinitionRepositoryCredentialsArgs) ToTaskDefinitionRepositoryCredentialsOutput 

func (i TaskDefinitionRepositoryCredentialsArgs) ToTaskDefinitionRepositoryCredentialsOutput() TaskDefinitionRepositoryCredentialsOutput

func (TaskDefinitionRepositoryCredentialsArgs) ToTaskDefinitionRepositoryCredentialsOutputWithContext 

func (i TaskDefinitionRepositoryCredentialsArgs) ToTaskDefinitionRepositoryCredentialsOutputWithContext(ctx context.Context) TaskDefinitionRepositoryCredentialsOutput

func (TaskDefinitionRepositoryCredentialsArgs) ToTaskDefinitionRepositoryCredentialsPtrOutput 

func (i TaskDefinitionRepositoryCredentialsArgs) ToTaskDefinitionRepositoryCredentialsPtrOutput() TaskDefinitionRepositoryCredentialsPtrOutput

func (TaskDefinitionRepositoryCredentialsArgs) ToTaskDefinitionRepositoryCredentialsPtrOutputWithContext 

func (i TaskDefinitionRepositoryCredentialsArgs) ToTaskDefinitionRepositoryCredentialsPtrOutputWithContext(ctx context.Context) TaskDefinitionRepositoryCredentialsPtrOutput

type TaskDefinitionRepositoryCredentialsInput 

type TaskDefinitionRepositoryCredentialsInput interface {
	pulumi.Input

	ToTaskDefinitionRepositoryCredentialsOutput() TaskDefinitionRepositoryCredentialsOutput
	ToTaskDefinitionRepositoryCredentialsOutputWithContext(context.Context) TaskDefinitionRepositoryCredentialsOutput
}

TaskDefinitionRepositoryCredentialsInput is an input type that accepts TaskDefinitionRepositoryCredentialsArgs and TaskDefinitionRepositoryCredentialsOutput values. You can construct a concrete instance of `TaskDefinitionRepositoryCredentialsInput` via: 

TaskDefinitionRepositoryCredentialsArgs{...}

type TaskDefinitionRepositoryCredentialsOutput 

type TaskDefinitionRepositoryCredentialsOutput struct{ *pulumi.OutputState }

The repository credentials for private registry authentication.

func (TaskDefinitionRepositoryCredentialsOutput) CredentialsParameter 

func (o TaskDefinitionRepositoryCredentialsOutput) CredentialsParameter() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the secret containing the private repository credentials. 

When you use the Amazon ECS API, CLI, or AWS SDK, if the secret exists in the same Region as the task that you're launching then you can use either the full ARN or the name of the secret. When you use the AWS Management Console, you must specify the full ARN of the secret.

func (TaskDefinitionRepositoryCredentialsOutput) ElementType 

func (TaskDefinitionRepositoryCredentialsOutput) ElementType() reflect.Type

func (TaskDefinitionRepositoryCredentialsOutput) ToTaskDefinitionRepositoryCredentialsOutput 

func (o TaskDefinitionRepositoryCredentialsOutput) ToTaskDefinitionRepositoryCredentialsOutput() TaskDefinitionRepositoryCredentialsOutput

func (TaskDefinitionRepositoryCredentialsOutput) ToTaskDefinitionRepositoryCredentialsOutputWithContext 

func (o TaskDefinitionRepositoryCredentialsOutput) ToTaskDefinitionRepositoryCredentialsOutputWithContext(ctx context.Context) TaskDefinitionRepositoryCredentialsOutput

func (TaskDefinitionRepositoryCredentialsOutput) ToTaskDefinitionRepositoryCredentialsPtrOutput 

func (o TaskDefinitionRepositoryCredentialsOutput) ToTaskDefinitionRepositoryCredentialsPtrOutput() TaskDefinitionRepositoryCredentialsPtrOutput

func (TaskDefinitionRepositoryCredentialsOutput) ToTaskDefinitionRepositoryCredentialsPtrOutputWithContext 

func (o TaskDefinitionRepositoryCredentialsOutput) ToTaskDefinitionRepositoryCredentialsPtrOutputWithContext(ctx context.Context) TaskDefinitionRepositoryCredentialsPtrOutput

type TaskDefinitionRepositoryCredentialsPtrInput 

type TaskDefinitionRepositoryCredentialsPtrInput interface {
	pulumi.Input

	ToTaskDefinitionRepositoryCredentialsPtrOutput() TaskDefinitionRepositoryCredentialsPtrOutput
	ToTaskDefinitionRepositoryCredentialsPtrOutputWithContext(context.Context) TaskDefinitionRepositoryCredentialsPtrOutput
}

TaskDefinitionRepositoryCredentialsPtrInput is an input type that accepts TaskDefinitionRepositoryCredentialsArgs, TaskDefinitionRepositoryCredentialsPtr and TaskDefinitionRepositoryCredentialsPtrOutput values. You can construct a concrete instance of `TaskDefinitionRepositoryCredentialsPtrInput` via: 

        TaskDefinitionRepositoryCredentialsArgs{...}

or:

        nil

func TaskDefinitionRepositoryCredentialsPtr 

func TaskDefinitionRepositoryCredentialsPtr(v *TaskDefinitionRepositoryCredentialsArgs) TaskDefinitionRepositoryCredentialsPtrInput

type TaskDefinitionRepositoryCredentialsPtrOutput 

type TaskDefinitionRepositoryCredentialsPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionRepositoryCredentialsPtrOutput) CredentialsParameter 

func (o TaskDefinitionRepositoryCredentialsPtrOutput) CredentialsParameter() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the secret containing the private repository credentials. 

When you use the Amazon ECS API, CLI, or AWS SDK, if the secret exists in the same Region as the task that you're launching then you can use either the full ARN or the name of the secret. When you use the AWS Management Console, you must specify the full ARN of the secret.

func (TaskDefinitionRepositoryCredentialsPtrOutput) Elem 

func (o TaskDefinitionRepositoryCredentialsPtrOutput) Elem() TaskDefinitionRepositoryCredentialsOutput

func (TaskDefinitionRepositoryCredentialsPtrOutput) ElementType 

func (TaskDefinitionRepositoryCredentialsPtrOutput) ElementType() reflect.Type

func (TaskDefinitionRepositoryCredentialsPtrOutput) ToTaskDefinitionRepositoryCredentialsPtrOutput 

func (o TaskDefinitionRepositoryCredentialsPtrOutput) ToTaskDefinitionRepositoryCredentialsPtrOutput() TaskDefinitionRepositoryCredentialsPtrOutput

func (TaskDefinitionRepositoryCredentialsPtrOutput) ToTaskDefinitionRepositoryCredentialsPtrOutputWithContext 

func (o TaskDefinitionRepositoryCredentialsPtrOutput) ToTaskDefinitionRepositoryCredentialsPtrOutputWithContext(ctx context.Context) TaskDefinitionRepositoryCredentialsPtrOutput

type TaskDefinitionResourceRequirement 

type TaskDefinitionResourceRequirement struct {
	// The type of resource to assign to a container. The supported values are “GPU“ or “InferenceAccelerator“.
	Type string `pulumi:"type"`
	// The value for the specified resource type.
	//  If the “GPU“ type is used, the value is the number of physical “GPUs“ the Amazon ECS container agent reserves for the container. The number of GPUs that's reserved for all containers in a task can't exceed the number of available GPUs on the container instance that the task is launched on.
	//  If the “InferenceAccelerator“ type is used, the “value“ matches the “deviceName“ for an [InferenceAccelerator](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_InferenceAccelerator.html) specified in a task definition.
	Value string `pulumi:"value"`
}

The type and amount of a resource to assign to a container. The supported resource types are GPUs and Elastic Inference accelerators. For more information, see [Working with GPUs on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-gpu.html) or [Working with Amazon Elastic Inference on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-inference.html) in the *Amazon Elastic Container Service Developer Guide*

type TaskDefinitionResourceRequirementArgs 

type TaskDefinitionResourceRequirementArgs struct {
	// The type of resource to assign to a container. The supported values are “GPU“ or “InferenceAccelerator“.
	Type pulumi.StringInput `pulumi:"type"`
	// The value for the specified resource type.
	//  If the “GPU“ type is used, the value is the number of physical “GPUs“ the Amazon ECS container agent reserves for the container. The number of GPUs that's reserved for all containers in a task can't exceed the number of available GPUs on the container instance that the task is launched on.
	//  If the “InferenceAccelerator“ type is used, the “value“ matches the “deviceName“ for an [InferenceAccelerator](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_InferenceAccelerator.html) specified in a task definition.
	Value pulumi.StringInput `pulumi:"value"`
}

The type and amount of a resource to assign to a container. The supported resource types are GPUs and Elastic Inference accelerators. For more information, see [Working with GPUs on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-gpu.html) or [Working with Amazon Elastic Inference on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-inference.html) in the *Amazon Elastic Container Service Developer Guide*

func (TaskDefinitionResourceRequirementArgs) ElementType 

func (TaskDefinitionResourceRequirementArgs) ElementType() reflect.Type

func (TaskDefinitionResourceRequirementArgs) ToTaskDefinitionResourceRequirementOutput 

func (i TaskDefinitionResourceRequirementArgs) ToTaskDefinitionResourceRequirementOutput() TaskDefinitionResourceRequirementOutput

func (TaskDefinitionResourceRequirementArgs) ToTaskDefinitionResourceRequirementOutputWithContext 

func (i TaskDefinitionResourceRequirementArgs) ToTaskDefinitionResourceRequirementOutputWithContext(ctx context.Context) TaskDefinitionResourceRequirementOutput

type TaskDefinitionResourceRequirementArray 

type TaskDefinitionResourceRequirementArray []TaskDefinitionResourceRequirementInput

func (TaskDefinitionResourceRequirementArray) ElementType 

func (TaskDefinitionResourceRequirementArray) ElementType() reflect.Type

func (TaskDefinitionResourceRequirementArray) ToTaskDefinitionResourceRequirementArrayOutput 

func (i TaskDefinitionResourceRequirementArray) ToTaskDefinitionResourceRequirementArrayOutput() TaskDefinitionResourceRequirementArrayOutput

func (TaskDefinitionResourceRequirementArray) ToTaskDefinitionResourceRequirementArrayOutputWithContext 

func (i TaskDefinitionResourceRequirementArray) ToTaskDefinitionResourceRequirementArrayOutputWithContext(ctx context.Context) TaskDefinitionResourceRequirementArrayOutput

type TaskDefinitionResourceRequirementArrayInput 

type TaskDefinitionResourceRequirementArrayInput interface {
	pulumi.Input

	ToTaskDefinitionResourceRequirementArrayOutput() TaskDefinitionResourceRequirementArrayOutput
	ToTaskDefinitionResourceRequirementArrayOutputWithContext(context.Context) TaskDefinitionResourceRequirementArrayOutput
}

TaskDefinitionResourceRequirementArrayInput is an input type that accepts TaskDefinitionResourceRequirementArray and TaskDefinitionResourceRequirementArrayOutput values. You can construct a concrete instance of `TaskDefinitionResourceRequirementArrayInput` via: 

TaskDefinitionResourceRequirementArray{ TaskDefinitionResourceRequirementArgs{...} }

type TaskDefinitionResourceRequirementArrayOutput 

type TaskDefinitionResourceRequirementArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionResourceRequirementArrayOutput) ElementType 

func (TaskDefinitionResourceRequirementArrayOutput) ElementType() reflect.Type

func (TaskDefinitionResourceRequirementArrayOutput) Index 

func (o TaskDefinitionResourceRequirementArrayOutput) Index(i pulumi.IntInput) TaskDefinitionResourceRequirementOutput

func (TaskDefinitionResourceRequirementArrayOutput) ToTaskDefinitionResourceRequirementArrayOutput 

func (o TaskDefinitionResourceRequirementArrayOutput) ToTaskDefinitionResourceRequirementArrayOutput() TaskDefinitionResourceRequirementArrayOutput

func (TaskDefinitionResourceRequirementArrayOutput) ToTaskDefinitionResourceRequirementArrayOutputWithContext 

func (o TaskDefinitionResourceRequirementArrayOutput) ToTaskDefinitionResourceRequirementArrayOutputWithContext(ctx context.Context) TaskDefinitionResourceRequirementArrayOutput

type TaskDefinitionResourceRequirementInput 

type TaskDefinitionResourceRequirementInput interface {
	pulumi.Input

	ToTaskDefinitionResourceRequirementOutput() TaskDefinitionResourceRequirementOutput
	ToTaskDefinitionResourceRequirementOutputWithContext(context.Context) TaskDefinitionResourceRequirementOutput
}

TaskDefinitionResourceRequirementInput is an input type that accepts TaskDefinitionResourceRequirementArgs and TaskDefinitionResourceRequirementOutput values. You can construct a concrete instance of `TaskDefinitionResourceRequirementInput` via: 

TaskDefinitionResourceRequirementArgs{...}

type TaskDefinitionResourceRequirementOutput 

type TaskDefinitionResourceRequirementOutput struct{ *pulumi.OutputState }

The type and amount of a resource to assign to a container. The supported resource types are GPUs and Elastic Inference accelerators. For more information, see [Working with GPUs on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-gpu.html) or [Working with Amazon Elastic Inference on Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-inference.html) in the *Amazon Elastic Container Service Developer Guide*

func (TaskDefinitionResourceRequirementOutput) ElementType 

func (TaskDefinitionResourceRequirementOutput) ElementType() reflect.Type

func (TaskDefinitionResourceRequirementOutput) ToTaskDefinitionResourceRequirementOutput 

func (o TaskDefinitionResourceRequirementOutput) ToTaskDefinitionResourceRequirementOutput() TaskDefinitionResourceRequirementOutput

func (TaskDefinitionResourceRequirementOutput) ToTaskDefinitionResourceRequirementOutputWithContext 

func (o TaskDefinitionResourceRequirementOutput) ToTaskDefinitionResourceRequirementOutputWithContext(ctx context.Context) TaskDefinitionResourceRequirementOutput

func (TaskDefinitionResourceRequirementOutput) Type 

func (o TaskDefinitionResourceRequirementOutput) Type() pulumi.StringOutput

The type of resource to assign to a container. The supported values are “GPU“ or “InferenceAccelerator“.

func (TaskDefinitionResourceRequirementOutput) Value 

func (o TaskDefinitionResourceRequirementOutput) Value() pulumi.StringOutput

The value for the specified resource type. 

If the ``GPU`` type is used, the value is the number of physical ``GPUs`` the Amazon ECS container agent reserves for the container. The number of GPUs that's reserved for all containers in a task can't exceed the number of available GPUs on the container instance that the task is launched on.
If the ``InferenceAccelerator`` type is used, the ``value`` matches the ``deviceName`` for an [InferenceAccelerator](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_InferenceAccelerator.html) specified in a task definition.

type TaskDefinitionRuntimePlatform added in v0.3.0 

type TaskDefinitionRuntimePlatform struct {
	// The CPU architecture.
	//  You can run your Linux tasks on an ARM-based platform by setting the value to “ARM64“. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.
	CpuArchitecture *string `pulumi:"cpuArchitecture"`
	// The operating system.
	OperatingSystemFamily *string `pulumi:"operatingSystemFamily"`
}

Information about the platform for the Amazon ECS service or task. 

For more information about ``RuntimePlatform``, see [RuntimePlatform](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#runtime-platform) in the *Amazon Elastic Container Service Developer Guide*.

type TaskDefinitionRuntimePlatformArgs added in v0.3.0 

type TaskDefinitionRuntimePlatformArgs struct {
	// The CPU architecture.
	//  You can run your Linux tasks on an ARM-based platform by setting the value to “ARM64“. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.
	CpuArchitecture pulumi.StringPtrInput `pulumi:"cpuArchitecture"`
	// The operating system.
	OperatingSystemFamily pulumi.StringPtrInput `pulumi:"operatingSystemFamily"`
}

Information about the platform for the Amazon ECS service or task. 

For more information about ``RuntimePlatform``, see [RuntimePlatform](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#runtime-platform) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionRuntimePlatformArgs) ElementType added in v0.3.0 

func (TaskDefinitionRuntimePlatformArgs) ElementType() reflect.Type

func (TaskDefinitionRuntimePlatformArgs) ToTaskDefinitionRuntimePlatformOutput added in v0.3.0 

func (i TaskDefinitionRuntimePlatformArgs) ToTaskDefinitionRuntimePlatformOutput() TaskDefinitionRuntimePlatformOutput

func (TaskDefinitionRuntimePlatformArgs) ToTaskDefinitionRuntimePlatformOutputWithContext added in v0.3.0 

func (i TaskDefinitionRuntimePlatformArgs) ToTaskDefinitionRuntimePlatformOutputWithContext(ctx context.Context) TaskDefinitionRuntimePlatformOutput

func (TaskDefinitionRuntimePlatformArgs) ToTaskDefinitionRuntimePlatformPtrOutput added in v0.3.0 

func (i TaskDefinitionRuntimePlatformArgs) ToTaskDefinitionRuntimePlatformPtrOutput() TaskDefinitionRuntimePlatformPtrOutput

func (TaskDefinitionRuntimePlatformArgs) ToTaskDefinitionRuntimePlatformPtrOutputWithContext added in v0.3.0 

func (i TaskDefinitionRuntimePlatformArgs) ToTaskDefinitionRuntimePlatformPtrOutputWithContext(ctx context.Context) TaskDefinitionRuntimePlatformPtrOutput

type TaskDefinitionRuntimePlatformInput added in v0.3.0 

type TaskDefinitionRuntimePlatformInput interface {
	pulumi.Input

	ToTaskDefinitionRuntimePlatformOutput() TaskDefinitionRuntimePlatformOutput
	ToTaskDefinitionRuntimePlatformOutputWithContext(context.Context) TaskDefinitionRuntimePlatformOutput
}

TaskDefinitionRuntimePlatformInput is an input type that accepts TaskDefinitionRuntimePlatformArgs and TaskDefinitionRuntimePlatformOutput values. You can construct a concrete instance of `TaskDefinitionRuntimePlatformInput` via: 

TaskDefinitionRuntimePlatformArgs{...}

type TaskDefinitionRuntimePlatformOutput added in v0.3.0 

type TaskDefinitionRuntimePlatformOutput struct{ *pulumi.OutputState }

Information about the platform for the Amazon ECS service or task. 

For more information about ``RuntimePlatform``, see [RuntimePlatform](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#runtime-platform) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionRuntimePlatformOutput) CpuArchitecture added in v0.3.0 

func (o TaskDefinitionRuntimePlatformOutput) CpuArchitecture() pulumi.StringPtrOutput

The CPU architecture. 

You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.

func (TaskDefinitionRuntimePlatformOutput) ElementType added in v0.3.0 

func (TaskDefinitionRuntimePlatformOutput) ElementType() reflect.Type

func (TaskDefinitionRuntimePlatformOutput) OperatingSystemFamily added in v0.3.0 

func (o TaskDefinitionRuntimePlatformOutput) OperatingSystemFamily() pulumi.StringPtrOutput

The operating system.

func (TaskDefinitionRuntimePlatformOutput) ToTaskDefinitionRuntimePlatformOutput added in v0.3.0 

func (o TaskDefinitionRuntimePlatformOutput) ToTaskDefinitionRuntimePlatformOutput() TaskDefinitionRuntimePlatformOutput

func (TaskDefinitionRuntimePlatformOutput) ToTaskDefinitionRuntimePlatformOutputWithContext added in v0.3.0 

func (o TaskDefinitionRuntimePlatformOutput) ToTaskDefinitionRuntimePlatformOutputWithContext(ctx context.Context) TaskDefinitionRuntimePlatformOutput

func (TaskDefinitionRuntimePlatformOutput) ToTaskDefinitionRuntimePlatformPtrOutput added in v0.3.0 

func (o TaskDefinitionRuntimePlatformOutput) ToTaskDefinitionRuntimePlatformPtrOutput() TaskDefinitionRuntimePlatformPtrOutput

func (TaskDefinitionRuntimePlatformOutput) ToTaskDefinitionRuntimePlatformPtrOutputWithContext added in v0.3.0 

func (o TaskDefinitionRuntimePlatformOutput) ToTaskDefinitionRuntimePlatformPtrOutputWithContext(ctx context.Context) TaskDefinitionRuntimePlatformPtrOutput

type TaskDefinitionRuntimePlatformPtrInput added in v0.3.0 

type TaskDefinitionRuntimePlatformPtrInput interface {
	pulumi.Input

	ToTaskDefinitionRuntimePlatformPtrOutput() TaskDefinitionRuntimePlatformPtrOutput
	ToTaskDefinitionRuntimePlatformPtrOutputWithContext(context.Context) TaskDefinitionRuntimePlatformPtrOutput
}

TaskDefinitionRuntimePlatformPtrInput is an input type that accepts TaskDefinitionRuntimePlatformArgs, TaskDefinitionRuntimePlatformPtr and TaskDefinitionRuntimePlatformPtrOutput values. You can construct a concrete instance of `TaskDefinitionRuntimePlatformPtrInput` via: 

        TaskDefinitionRuntimePlatformArgs{...}

or:

        nil

func TaskDefinitionRuntimePlatformPtr added in v0.3.0 

func TaskDefinitionRuntimePlatformPtr(v *TaskDefinitionRuntimePlatformArgs) TaskDefinitionRuntimePlatformPtrInput

type TaskDefinitionRuntimePlatformPtrOutput added in v0.3.0 

type TaskDefinitionRuntimePlatformPtrOutput struct{ *pulumi.OutputState }

func (TaskDefinitionRuntimePlatformPtrOutput) CpuArchitecture added in v0.3.0 

func (o TaskDefinitionRuntimePlatformPtrOutput) CpuArchitecture() pulumi.StringPtrOutput

The CPU architecture. 

You can run your Linux tasks on an ARM-based platform by setting the value to ``ARM64``. This option is available for tasks that run on Linux Amazon EC2 instance or Linux containers on Fargate.

func (TaskDefinitionRuntimePlatformPtrOutput) Elem added in v0.3.0 

func (o TaskDefinitionRuntimePlatformPtrOutput) Elem() TaskDefinitionRuntimePlatformOutput

func (TaskDefinitionRuntimePlatformPtrOutput) ElementType added in v0.3.0 

func (TaskDefinitionRuntimePlatformPtrOutput) ElementType() reflect.Type

func (TaskDefinitionRuntimePlatformPtrOutput) OperatingSystemFamily added in v0.3.0 

func (o TaskDefinitionRuntimePlatformPtrOutput) OperatingSystemFamily() pulumi.StringPtrOutput

The operating system.

func (TaskDefinitionRuntimePlatformPtrOutput) ToTaskDefinitionRuntimePlatformPtrOutput added in v0.3.0 

func (o TaskDefinitionRuntimePlatformPtrOutput) ToTaskDefinitionRuntimePlatformPtrOutput() TaskDefinitionRuntimePlatformPtrOutput

func (TaskDefinitionRuntimePlatformPtrOutput) ToTaskDefinitionRuntimePlatformPtrOutputWithContext added in v0.3.0 

func (o TaskDefinitionRuntimePlatformPtrOutput) ToTaskDefinitionRuntimePlatformPtrOutputWithContext(ctx context.Context) TaskDefinitionRuntimePlatformPtrOutput

type TaskDefinitionSecret 

type TaskDefinitionSecret struct {
	// The name of the secret.
	Name string `pulumi:"name"`
	// The secret to expose to the container. The supported values are either the full ARN of the ASMlong secret or the full ARN of the parameter in the SSM Parameter Store.
	//  For information about the require IAMlong permissions, see [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-secrets.html#secrets-iam) (for Secrets Manager) or [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-parameters.html) (for Systems Manager Parameter store) in the *Amazon Elastic Container Service Developer Guide*.
	//   If the SSM Parameter Store parameter exists in the same Region as the task you're launching, then you can use either the full ARN or name of the parameter. If the parameter exists in a different Region, then the full ARN must be specified.
	ValueFrom string `pulumi:"valueFrom"`
}

An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:

  • To inject sensitive data into your containers as environment variables, use the “secrets“ container definition parameter.

  • To reference sensitive information in the log configuration of a container, use the “secretOptions“ container definition parameter.

    For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

type TaskDefinitionSecretArgs 

type TaskDefinitionSecretArgs struct {
	// The name of the secret.
	Name pulumi.StringInput `pulumi:"name"`
	// The secret to expose to the container. The supported values are either the full ARN of the ASMlong secret or the full ARN of the parameter in the SSM Parameter Store.
	//  For information about the require IAMlong permissions, see [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-secrets.html#secrets-iam) (for Secrets Manager) or [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-parameters.html) (for Systems Manager Parameter store) in the *Amazon Elastic Container Service Developer Guide*.
	//   If the SSM Parameter Store parameter exists in the same Region as the task you're launching, then you can use either the full ARN or name of the parameter. If the parameter exists in a different Region, then the full ARN must be specified.
	ValueFrom pulumi.StringInput `pulumi:"valueFrom"`
}

An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:

  • To inject sensitive data into your containers as environment variables, use the “secrets“ container definition parameter.

  • To reference sensitive information in the log configuration of a container, use the “secretOptions“ container definition parameter.

    For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionSecretArgs) ElementType 

func (TaskDefinitionSecretArgs) ElementType() reflect.Type

func (TaskDefinitionSecretArgs) ToTaskDefinitionSecretOutput 

func (i TaskDefinitionSecretArgs) ToTaskDefinitionSecretOutput() TaskDefinitionSecretOutput

func (TaskDefinitionSecretArgs) ToTaskDefinitionSecretOutputWithContext 

func (i TaskDefinitionSecretArgs) ToTaskDefinitionSecretOutputWithContext(ctx context.Context) TaskDefinitionSecretOutput

type TaskDefinitionSecretArray 

type TaskDefinitionSecretArray []TaskDefinitionSecretInput

func (TaskDefinitionSecretArray) ElementType 

func (TaskDefinitionSecretArray) ElementType() reflect.Type

func (TaskDefinitionSecretArray) ToTaskDefinitionSecretArrayOutput 

func (i TaskDefinitionSecretArray) ToTaskDefinitionSecretArrayOutput() TaskDefinitionSecretArrayOutput

func (TaskDefinitionSecretArray) ToTaskDefinitionSecretArrayOutputWithContext 

func (i TaskDefinitionSecretArray) ToTaskDefinitionSecretArrayOutputWithContext(ctx context.Context) TaskDefinitionSecretArrayOutput

type TaskDefinitionSecretArrayInput 

type TaskDefinitionSecretArrayInput interface {
	pulumi.Input

	ToTaskDefinitionSecretArrayOutput() TaskDefinitionSecretArrayOutput
	ToTaskDefinitionSecretArrayOutputWithContext(context.Context) TaskDefinitionSecretArrayOutput
}

TaskDefinitionSecretArrayInput is an input type that accepts TaskDefinitionSecretArray and TaskDefinitionSecretArrayOutput values. You can construct a concrete instance of `TaskDefinitionSecretArrayInput` via: 

TaskDefinitionSecretArray{ TaskDefinitionSecretArgs{...} }

type TaskDefinitionSecretArrayOutput 

type TaskDefinitionSecretArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionSecretArrayOutput) ElementType 

func (TaskDefinitionSecretArrayOutput) ElementType() reflect.Type

func (TaskDefinitionSecretArrayOutput) Index 

func (o TaskDefinitionSecretArrayOutput) Index(i pulumi.IntInput) TaskDefinitionSecretOutput

func (TaskDefinitionSecretArrayOutput) ToTaskDefinitionSecretArrayOutput 

func (o TaskDefinitionSecretArrayOutput) ToTaskDefinitionSecretArrayOutput() TaskDefinitionSecretArrayOutput

func (TaskDefinitionSecretArrayOutput) ToTaskDefinitionSecretArrayOutputWithContext 

func (o TaskDefinitionSecretArrayOutput) ToTaskDefinitionSecretArrayOutputWithContext(ctx context.Context) TaskDefinitionSecretArrayOutput

type TaskDefinitionSecretInput 

type TaskDefinitionSecretInput interface {
	pulumi.Input

	ToTaskDefinitionSecretOutput() TaskDefinitionSecretOutput
	ToTaskDefinitionSecretOutputWithContext(context.Context) TaskDefinitionSecretOutput
}

TaskDefinitionSecretInput is an input type that accepts TaskDefinitionSecretArgs and TaskDefinitionSecretOutput values. You can construct a concrete instance of `TaskDefinitionSecretInput` via: 

TaskDefinitionSecretArgs{...}

type TaskDefinitionSecretOutput 

type TaskDefinitionSecretOutput struct{ *pulumi.OutputState }

An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:

  • To inject sensitive data into your containers as environment variables, use the “secrets“ container definition parameter.

  • To reference sensitive information in the log configuration of a container, use the “secretOptions“ container definition parameter.

    For more information, see [Specifying sensitive data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html) in the *Amazon Elastic Container Service Developer Guide*.

func (TaskDefinitionSecretOutput) ElementType 

func (TaskDefinitionSecretOutput) ElementType() reflect.Type

func (TaskDefinitionSecretOutput) Name 

func (o TaskDefinitionSecretOutput) Name() pulumi.StringOutput

The name of the secret.

func (TaskDefinitionSecretOutput) ToTaskDefinitionSecretOutput 

func (o TaskDefinitionSecretOutput) ToTaskDefinitionSecretOutput() TaskDefinitionSecretOutput

func (TaskDefinitionSecretOutput) ToTaskDefinitionSecretOutputWithContext 

func (o TaskDefinitionSecretOutput) ToTaskDefinitionSecretOutputWithContext(ctx context.Context) TaskDefinitionSecretOutput

func (TaskDefinitionSecretOutput) ValueFrom 

func (o TaskDefinitionSecretOutput) ValueFrom() pulumi.StringOutput

The secret to expose to the container. The supported values are either the full ARN of the ASMlong secret or the full ARN of the parameter in the SSM Parameter Store. 

For information about the require IAMlong permissions, see [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-secrets.html#secrets-iam) (for Secrets Manager) or [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-parameters.html) (for Systems Manager Parameter store) in the *Amazon Elastic Container Service Developer Guide*.
 If the SSM Parameter Store parameter exists in the same Region as the task you're launching, then you can use either the full ARN or name of the parameter. If the parameter exists in a different Region, then the full ARN must be specified.

type TaskDefinitionState 

type TaskDefinitionState struct {
}

func (TaskDefinitionState) ElementType 

func (TaskDefinitionState) ElementType() reflect.Type

type TaskDefinitionSystemControl 

type TaskDefinitionSystemControl struct {
	// The namespaced kernel parameter to set a “value“ for.
	Namespace *string `pulumi:"namespace"`
	// The namespaced kernel parameter to set a “value“ for.
	//  Valid IPC namespace values: “"kernel.msgmax" | "kernel.msgmnb" | "kernel.msgmni" | "kernel.sem" | "kernel.shmall" | "kernel.shmmax" | "kernel.shmmni" | "kernel.shm_rmid_forced"“, and “Sysctls“ that start with “"fs.mqueue.*"“
	//  Valid network namespace values: “Sysctls“ that start with “"net.*"“
	//  All of these values are supported by Fargate.
	Value *string `pulumi:"value"`
}

A list of namespaced kernel parameters to set in the container. This parameter maps to “Sysctls“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--sysctl“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For example, you can configure “net.ipv4.tcp_keepalive_time“ setting to maintain longer lived connections. 

We don't recommend that you specify network-related ``systemControls`` parameters for multiple containers in a single task that also uses either the ``awsvpc`` or ``host`` network mode. Doing this has the following disadvantages:
 +  For tasks that use the ``awsvpc`` network mode including Fargate, if you set ``systemControls`` for any container, it applies to all containers in the task. If you set different ``systemControls`` for multiple containers in a single task, the container that's started last determines which ``systemControls`` take effect.
 +  For tasks that use the ``host`` network mode, the network namespace ``systemControls`` aren't supported.

If you're setting an IPC resource namespace to use for the containers in the task, the following conditions apply to your system controls. For more information, see [IPC mode](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_ipcmode).
 +  For tasks that use the ``host`` IPC mode, IPC namespace ``systemControls`` aren't supported.
 +  For tasks that use the ``task`` IPC mode, IPC namespace ``systemControls`` values apply to all containers within a task.

 This parameter is not supported for Windows containers.
  This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.

type TaskDefinitionSystemControlArgs 

type TaskDefinitionSystemControlArgs struct {
	// The namespaced kernel parameter to set a “value“ for.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
	// The namespaced kernel parameter to set a “value“ for.
	//  Valid IPC namespace values: “"kernel.msgmax" | "kernel.msgmnb" | "kernel.msgmni" | "kernel.sem" | "kernel.shmall" | "kernel.shmmax" | "kernel.shmmni" | "kernel.shm_rmid_forced"“, and “Sysctls“ that start with “"fs.mqueue.*"“
	//  Valid network namespace values: “Sysctls“ that start with “"net.*"“
	//  All of these values are supported by Fargate.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

A list of namespaced kernel parameters to set in the container. This parameter maps to “Sysctls“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--sysctl“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For example, you can configure “net.ipv4.tcp_keepalive_time“ setting to maintain longer lived connections. 

We don't recommend that you specify network-related ``systemControls`` parameters for multiple containers in a single task that also uses either the ``awsvpc`` or ``host`` network mode. Doing this has the following disadvantages:
 +  For tasks that use the ``awsvpc`` network mode including Fargate, if you set ``systemControls`` for any container, it applies to all containers in the task. If you set different ``systemControls`` for multiple containers in a single task, the container that's started last determines which ``systemControls`` take effect.
 +  For tasks that use the ``host`` network mode, the network namespace ``systemControls`` aren't supported.

If you're setting an IPC resource namespace to use for the containers in the task, the following conditions apply to your system controls. For more information, see [IPC mode](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_ipcmode).
 +  For tasks that use the ``host`` IPC mode, IPC namespace ``systemControls`` aren't supported.
 +  For tasks that use the ``task`` IPC mode, IPC namespace ``systemControls`` values apply to all containers within a task.

 This parameter is not supported for Windows containers.
  This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.

func (TaskDefinitionSystemControlArgs) ElementType 

func (TaskDefinitionSystemControlArgs) ElementType() reflect.Type

func (TaskDefinitionSystemControlArgs) ToTaskDefinitionSystemControlOutput 

func (i TaskDefinitionSystemControlArgs) ToTaskDefinitionSystemControlOutput() TaskDefinitionSystemControlOutput

func (TaskDefinitionSystemControlArgs) ToTaskDefinitionSystemControlOutputWithContext 

func (i TaskDefinitionSystemControlArgs) ToTaskDefinitionSystemControlOutputWithContext(ctx context.Context) TaskDefinitionSystemControlOutput

type TaskDefinitionSystemControlArray 

type TaskDefinitionSystemControlArray []TaskDefinitionSystemControlInput

func (TaskDefinitionSystemControlArray) ElementType 

func (TaskDefinitionSystemControlArray) ElementType() reflect.Type

func (TaskDefinitionSystemControlArray) ToTaskDefinitionSystemControlArrayOutput 

func (i TaskDefinitionSystemControlArray) ToTaskDefinitionSystemControlArrayOutput() TaskDefinitionSystemControlArrayOutput

func (TaskDefinitionSystemControlArray) ToTaskDefinitionSystemControlArrayOutputWithContext 

func (i TaskDefinitionSystemControlArray) ToTaskDefinitionSystemControlArrayOutputWithContext(ctx context.Context) TaskDefinitionSystemControlArrayOutput

type TaskDefinitionSystemControlArrayInput 

type TaskDefinitionSystemControlArrayInput interface {
	pulumi.Input

	ToTaskDefinitionSystemControlArrayOutput() TaskDefinitionSystemControlArrayOutput
	ToTaskDefinitionSystemControlArrayOutputWithContext(context.Context) TaskDefinitionSystemControlArrayOutput
}

TaskDefinitionSystemControlArrayInput is an input type that accepts TaskDefinitionSystemControlArray and TaskDefinitionSystemControlArrayOutput values. You can construct a concrete instance of `TaskDefinitionSystemControlArrayInput` via: 

TaskDefinitionSystemControlArray{ TaskDefinitionSystemControlArgs{...} }

type TaskDefinitionSystemControlArrayOutput 

type TaskDefinitionSystemControlArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionSystemControlArrayOutput) ElementType 

func (TaskDefinitionSystemControlArrayOutput) ElementType() reflect.Type

func (TaskDefinitionSystemControlArrayOutput) Index 

func (o TaskDefinitionSystemControlArrayOutput) Index(i pulumi.IntInput) TaskDefinitionSystemControlOutput

func (TaskDefinitionSystemControlArrayOutput) ToTaskDefinitionSystemControlArrayOutput 

func (o TaskDefinitionSystemControlArrayOutput) ToTaskDefinitionSystemControlArrayOutput() TaskDefinitionSystemControlArrayOutput

func (TaskDefinitionSystemControlArrayOutput) ToTaskDefinitionSystemControlArrayOutputWithContext 

func (o TaskDefinitionSystemControlArrayOutput) ToTaskDefinitionSystemControlArrayOutputWithContext(ctx context.Context) TaskDefinitionSystemControlArrayOutput

type TaskDefinitionSystemControlInput 

type TaskDefinitionSystemControlInput interface {
	pulumi.Input

	ToTaskDefinitionSystemControlOutput() TaskDefinitionSystemControlOutput
	ToTaskDefinitionSystemControlOutputWithContext(context.Context) TaskDefinitionSystemControlOutput
}

TaskDefinitionSystemControlInput is an input type that accepts TaskDefinitionSystemControlArgs and TaskDefinitionSystemControlOutput values. You can construct a concrete instance of `TaskDefinitionSystemControlInput` via: 

TaskDefinitionSystemControlArgs{...}

type TaskDefinitionSystemControlOutput 

type TaskDefinitionSystemControlOutput struct{ *pulumi.OutputState }

A list of namespaced kernel parameters to set in the container. This parameter maps to “Sysctls“ in the [Create a container](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of the [Docker Remote API](https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/) and the “--sysctl“ option to [docker run](https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration). For example, you can configure “net.ipv4.tcp_keepalive_time“ setting to maintain longer lived connections. 

We don't recommend that you specify network-related ``systemControls`` parameters for multiple containers in a single task that also uses either the ``awsvpc`` or ``host`` network mode. Doing this has the following disadvantages:
 +  For tasks that use the ``awsvpc`` network mode including Fargate, if you set ``systemControls`` for any container, it applies to all containers in the task. If you set different ``systemControls`` for multiple containers in a single task, the container that's started last determines which ``systemControls`` take effect.
 +  For tasks that use the ``host`` network mode, the network namespace ``systemControls`` aren't supported.

If you're setting an IPC resource namespace to use for the containers in the task, the following conditions apply to your system controls. For more information, see [IPC mode](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_ipcmode).
 +  For tasks that use the ``host`` IPC mode, IPC namespace ``systemControls`` aren't supported.
 +  For tasks that use the ``task`` IPC mode, IPC namespace ``systemControls`` values apply to all containers within a task.

 This parameter is not supported for Windows containers.
  This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.

func (TaskDefinitionSystemControlOutput) ElementType 

func (TaskDefinitionSystemControlOutput) ElementType() reflect.Type

func (TaskDefinitionSystemControlOutput) Namespace 

func (o TaskDefinitionSystemControlOutput) Namespace() pulumi.StringPtrOutput

The namespaced kernel parameter to set a “value“ for.

func (TaskDefinitionSystemControlOutput) ToTaskDefinitionSystemControlOutput 

func (o TaskDefinitionSystemControlOutput) ToTaskDefinitionSystemControlOutput() TaskDefinitionSystemControlOutput

func (TaskDefinitionSystemControlOutput) ToTaskDefinitionSystemControlOutputWithContext 

func (o TaskDefinitionSystemControlOutput) ToTaskDefinitionSystemControlOutputWithContext(ctx context.Context) TaskDefinitionSystemControlOutput

func (TaskDefinitionSystemControlOutput) Value 

func (o TaskDefinitionSystemControlOutput) Value() pulumi.StringPtrOutput

The namespaced kernel parameter to set a “value“ for. 

Valid IPC namespace values: ``"kernel.msgmax" | "kernel.msgmnb" | "kernel.msgmni" | "kernel.sem" | "kernel.shmall" | "kernel.shmmax" | "kernel.shmmni" | "kernel.shm_rmid_forced"``, and ``Sysctls`` that start with ``"fs.mqueue.*"``
Valid network namespace values: ``Sysctls`` that start with ``"net.*"``
All of these values are supported by Fargate.

type TaskDefinitionTag 

type TaskDefinitionTag struct {
	// One part of a key-value pair that make up a tag. A “key“ is a general label that acts like a category for more specific tag values.
	Key *string `pulumi:"key"`
	// The optional part of a key-value pair that make up a tag. A “value“ acts as a descriptor within a tag category (key).
	Value *string `pulumi:"value"`
}

The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value. You define them. 

The following basic restrictions apply to tags:
 +  Maximum number of tags per resource - 50
 +  For each resource, each tag key must be unique, and each tag key can have only one value.
 +  Maximum key length - 128 Unicode characters in UTF-8
 +  Maximum value length - 256 Unicode characters in UTF-8
 +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.
 +  Tag keys and values are case-sensitive.
 +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.

type TaskDefinitionTmpfs 

type TaskDefinitionTmpfs struct {
	// The absolute file path where the tmpfs volume is to be mounted.
	ContainerPath *string `pulumi:"containerPath"`
	// The list of tmpfs volume mount options.
	//  Valid values: “"defaults" | "ro" | "rw" | "suid" | "nosuid" | "dev" | "nodev" | "exec" | "noexec" | "sync" | "async" | "dirsync" | "remount" | "mand" | "nomand" | "atime" | "noatime" | "diratime" | "nodiratime" | "bind" | "rbind" | "unbindable" | "runbindable" | "private" | "rprivate" | "shared" | "rshared" | "slave" | "rslave" | "relatime" | "norelatime" | "strictatime" | "nostrictatime" | "mode" | "uid" | "gid" | "nr_inodes" | "nr_blocks" | "mpol"“
	MountOptions []string `pulumi:"mountOptions"`
	// The maximum size (in MiB) of the tmpfs volume.
	Size int `pulumi:"size"`
}

The container path, mount options, and size of the tmpfs mount.

type TaskDefinitionTmpfsArgs 

type TaskDefinitionTmpfsArgs struct {
	// The absolute file path where the tmpfs volume is to be mounted.
	ContainerPath pulumi.StringPtrInput `pulumi:"containerPath"`
	// The list of tmpfs volume mount options.
	//  Valid values: “"defaults" | "ro" | "rw" | "suid" | "nosuid" | "dev" | "nodev" | "exec" | "noexec" | "sync" | "async" | "dirsync" | "remount" | "mand" | "nomand" | "atime" | "noatime" | "diratime" | "nodiratime" | "bind" | "rbind" | "unbindable" | "runbindable" | "private" | "rprivate" | "shared" | "rshared" | "slave" | "rslave" | "relatime" | "norelatime" | "strictatime" | "nostrictatime" | "mode" | "uid" | "gid" | "nr_inodes" | "nr_blocks" | "mpol"“
	MountOptions pulumi.StringArrayInput `pulumi:"mountOptions"`
	// The maximum size (in MiB) of the tmpfs volume.
	Size pulumi.IntInput `pulumi:"size"`
}

The container path, mount options, and size of the tmpfs mount.

func (TaskDefinitionTmpfsArgs) ElementType 

func (TaskDefinitionTmpfsArgs) ElementType() reflect.Type

func (TaskDefinitionTmpfsArgs) ToTaskDefinitionTmpfsOutput 

func (i TaskDefinitionTmpfsArgs) ToTaskDefinitionTmpfsOutput() TaskDefinitionTmpfsOutput

func (TaskDefinitionTmpfsArgs) ToTaskDefinitionTmpfsOutputWithContext 

func (i TaskDefinitionTmpfsArgs) ToTaskDefinitionTmpfsOutputWithContext(ctx context.Context) TaskDefinitionTmpfsOutput

type TaskDefinitionTmpfsArray 

type TaskDefinitionTmpfsArray []TaskDefinitionTmpfsInput

func (TaskDefinitionTmpfsArray) ElementType 

func (TaskDefinitionTmpfsArray) ElementType() reflect.Type

func (TaskDefinitionTmpfsArray) ToTaskDefinitionTmpfsArrayOutput 

func (i TaskDefinitionTmpfsArray) ToTaskDefinitionTmpfsArrayOutput() TaskDefinitionTmpfsArrayOutput

func (TaskDefinitionTmpfsArray) ToTaskDefinitionTmpfsArrayOutputWithContext 

func (i TaskDefinitionTmpfsArray) ToTaskDefinitionTmpfsArrayOutputWithContext(ctx context.Context) TaskDefinitionTmpfsArrayOutput

type TaskDefinitionTmpfsArrayInput 

type TaskDefinitionTmpfsArrayInput interface {
	pulumi.Input

	ToTaskDefinitionTmpfsArrayOutput() TaskDefinitionTmpfsArrayOutput
	ToTaskDefinitionTmpfsArrayOutputWithContext(context.Context) TaskDefinitionTmpfsArrayOutput
}

TaskDefinitionTmpfsArrayInput is an input type that accepts TaskDefinitionTmpfsArray and TaskDefinitionTmpfsArrayOutput values. You can construct a concrete instance of `TaskDefinitionTmpfsArrayInput` via: 

TaskDefinitionTmpfsArray{ TaskDefinitionTmpfsArgs{...} }

type TaskDefinitionTmpfsArrayOutput 

type TaskDefinitionTmpfsArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionTmpfsArrayOutput) ElementType 

func (TaskDefinitionTmpfsArrayOutput) ElementType() reflect.Type

func (TaskDefinitionTmpfsArrayOutput) Index 

func (o TaskDefinitionTmpfsArrayOutput) Index(i pulumi.IntInput) TaskDefinitionTmpfsOutput

func (TaskDefinitionTmpfsArrayOutput) ToTaskDefinitionTmpfsArrayOutput 

func (o TaskDefinitionTmpfsArrayOutput) ToTaskDefinitionTmpfsArrayOutput() TaskDefinitionTmpfsArrayOutput

func (TaskDefinitionTmpfsArrayOutput) ToTaskDefinitionTmpfsArrayOutputWithContext 

func (o TaskDefinitionTmpfsArrayOutput) ToTaskDefinitionTmpfsArrayOutputWithContext(ctx context.Context) TaskDefinitionTmpfsArrayOutput

type TaskDefinitionTmpfsInput 

type TaskDefinitionTmpfsInput interface {
	pulumi.Input

	ToTaskDefinitionTmpfsOutput() TaskDefinitionTmpfsOutput
	ToTaskDefinitionTmpfsOutputWithContext(context.Context) TaskDefinitionTmpfsOutput
}

TaskDefinitionTmpfsInput is an input type that accepts TaskDefinitionTmpfsArgs and TaskDefinitionTmpfsOutput values. You can construct a concrete instance of `TaskDefinitionTmpfsInput` via: 

TaskDefinitionTmpfsArgs{...}

type TaskDefinitionTmpfsOutput 

type TaskDefinitionTmpfsOutput struct{ *pulumi.OutputState }

The container path, mount options, and size of the tmpfs mount.

func (TaskDefinitionTmpfsOutput) ContainerPath 

func (o TaskDefinitionTmpfsOutput) ContainerPath() pulumi.StringPtrOutput

The absolute file path where the tmpfs volume is to be mounted.

func (TaskDefinitionTmpfsOutput) ElementType 

func (TaskDefinitionTmpfsOutput) ElementType() reflect.Type

func (TaskDefinitionTmpfsOutput) MountOptions 

func (o TaskDefinitionTmpfsOutput) MountOptions() pulumi.StringArrayOutput

The list of tmpfs volume mount options. 

Valid values: ``"defaults" | "ro" | "rw" | "suid" | "nosuid" | "dev" | "nodev" | "exec" | "noexec" | "sync" | "async" | "dirsync" | "remount" | "mand" | "nomand" | "atime" | "noatime" | "diratime" | "nodiratime" | "bind" | "rbind" | "unbindable" | "runbindable" | "private" | "rprivate" | "shared" | "rshared" | "slave" | "rslave" | "relatime" | "norelatime" | "strictatime" | "nostrictatime" | "mode" | "uid" | "gid" | "nr_inodes" | "nr_blocks" | "mpol"``

func (TaskDefinitionTmpfsOutput) Size 

func (o TaskDefinitionTmpfsOutput) Size() pulumi.IntOutput

The maximum size (in MiB) of the tmpfs volume.

func (TaskDefinitionTmpfsOutput) ToTaskDefinitionTmpfsOutput 

func (o TaskDefinitionTmpfsOutput) ToTaskDefinitionTmpfsOutput() TaskDefinitionTmpfsOutput

func (TaskDefinitionTmpfsOutput) ToTaskDefinitionTmpfsOutputWithContext 

func (o TaskDefinitionTmpfsOutput) ToTaskDefinitionTmpfsOutputWithContext(ctx context.Context) TaskDefinitionTmpfsOutput

type TaskDefinitionUlimit 

type TaskDefinitionUlimit struct {
	// The hard limit for the “ulimit“ type.
	HardLimit int `pulumi:"hardLimit"`
	// The “type“ of the “ulimit“.
	Name string `pulumi:"name"`
	// The soft limit for the “ulimit“ type.
	SoftLimit int `pulumi:"softLimit"`
}

The “ulimit“ settings to pass to the container. 

Amazon ECS tasks hosted on FARGATElong use the default resource limit values set by the operating system with the exception of the ``nofile`` resource limit parameter which FARGATElong overrides. The ``nofile`` resource limit sets a restriction on the number of open files that a container can use. The default ``nofile`` soft limit is ``1024`` and the default hard limit is ``65535``.
You can specify the ``ulimit`` settings for a container in a task definition.

type TaskDefinitionUlimitArgs 

type TaskDefinitionUlimitArgs struct {
	// The hard limit for the “ulimit“ type.
	HardLimit pulumi.IntInput `pulumi:"hardLimit"`
	// The “type“ of the “ulimit“.
	Name pulumi.StringInput `pulumi:"name"`
	// The soft limit for the “ulimit“ type.
	SoftLimit pulumi.IntInput `pulumi:"softLimit"`
}

The “ulimit“ settings to pass to the container. 

Amazon ECS tasks hosted on FARGATElong use the default resource limit values set by the operating system with the exception of the ``nofile`` resource limit parameter which FARGATElong overrides. The ``nofile`` resource limit sets a restriction on the number of open files that a container can use. The default ``nofile`` soft limit is ``1024`` and the default hard limit is ``65535``.
You can specify the ``ulimit`` settings for a container in a task definition.

func (TaskDefinitionUlimitArgs) ElementType 

func (TaskDefinitionUlimitArgs) ElementType() reflect.Type

func (TaskDefinitionUlimitArgs) ToTaskDefinitionUlimitOutput 

func (i TaskDefinitionUlimitArgs) ToTaskDefinitionUlimitOutput() TaskDefinitionUlimitOutput

func (TaskDefinitionUlimitArgs) ToTaskDefinitionUlimitOutputWithContext 

func (i TaskDefinitionUlimitArgs) ToTaskDefinitionUlimitOutputWithContext(ctx context.Context) TaskDefinitionUlimitOutput

type TaskDefinitionUlimitArray 

type TaskDefinitionUlimitArray []TaskDefinitionUlimitInput

func (TaskDefinitionUlimitArray) ElementType 

func (TaskDefinitionUlimitArray) ElementType() reflect.Type

func (TaskDefinitionUlimitArray) ToTaskDefinitionUlimitArrayOutput 

func (i TaskDefinitionUlimitArray) ToTaskDefinitionUlimitArrayOutput() TaskDefinitionUlimitArrayOutput

func (TaskDefinitionUlimitArray) ToTaskDefinitionUlimitArrayOutputWithContext 

func (i TaskDefinitionUlimitArray) ToTaskDefinitionUlimitArrayOutputWithContext(ctx context.Context) TaskDefinitionUlimitArrayOutput

type TaskDefinitionUlimitArrayInput 

type TaskDefinitionUlimitArrayInput interface {
	pulumi.Input

	ToTaskDefinitionUlimitArrayOutput() TaskDefinitionUlimitArrayOutput
	ToTaskDefinitionUlimitArrayOutputWithContext(context.Context) TaskDefinitionUlimitArrayOutput
}

TaskDefinitionUlimitArrayInput is an input type that accepts TaskDefinitionUlimitArray and TaskDefinitionUlimitArrayOutput values. You can construct a concrete instance of `TaskDefinitionUlimitArrayInput` via: 

TaskDefinitionUlimitArray{ TaskDefinitionUlimitArgs{...} }

type TaskDefinitionUlimitArrayOutput 

type TaskDefinitionUlimitArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionUlimitArrayOutput) ElementType 

func (TaskDefinitionUlimitArrayOutput) ElementType() reflect.Type

func (TaskDefinitionUlimitArrayOutput) Index 

func (o TaskDefinitionUlimitArrayOutput) Index(i pulumi.IntInput) TaskDefinitionUlimitOutput

func (TaskDefinitionUlimitArrayOutput) ToTaskDefinitionUlimitArrayOutput 

func (o TaskDefinitionUlimitArrayOutput) ToTaskDefinitionUlimitArrayOutput() TaskDefinitionUlimitArrayOutput

func (TaskDefinitionUlimitArrayOutput) ToTaskDefinitionUlimitArrayOutputWithContext 

func (o TaskDefinitionUlimitArrayOutput) ToTaskDefinitionUlimitArrayOutputWithContext(ctx context.Context) TaskDefinitionUlimitArrayOutput

type TaskDefinitionUlimitInput 

type TaskDefinitionUlimitInput interface {
	pulumi.Input

	ToTaskDefinitionUlimitOutput() TaskDefinitionUlimitOutput
	ToTaskDefinitionUlimitOutputWithContext(context.Context) TaskDefinitionUlimitOutput
}

TaskDefinitionUlimitInput is an input type that accepts TaskDefinitionUlimitArgs and TaskDefinitionUlimitOutput values. You can construct a concrete instance of `TaskDefinitionUlimitInput` via: 

TaskDefinitionUlimitArgs{...}

type TaskDefinitionUlimitOutput 

type TaskDefinitionUlimitOutput struct{ *pulumi.OutputState }

The “ulimit“ settings to pass to the container. 

Amazon ECS tasks hosted on FARGATElong use the default resource limit values set by the operating system with the exception of the ``nofile`` resource limit parameter which FARGATElong overrides. The ``nofile`` resource limit sets a restriction on the number of open files that a container can use. The default ``nofile`` soft limit is ``1024`` and the default hard limit is ``65535``.
You can specify the ``ulimit`` settings for a container in a task definition.

func (TaskDefinitionUlimitOutput) ElementType 

func (TaskDefinitionUlimitOutput) ElementType() reflect.Type

func (TaskDefinitionUlimitOutput) HardLimit 

func (o TaskDefinitionUlimitOutput) HardLimit() pulumi.IntOutput

The hard limit for the “ulimit“ type.

func (TaskDefinitionUlimitOutput) Name 

func (o TaskDefinitionUlimitOutput) Name() pulumi.StringOutput

The “type“ of the “ulimit“.

func (TaskDefinitionUlimitOutput) SoftLimit 

func (o TaskDefinitionUlimitOutput) SoftLimit() pulumi.IntOutput

The soft limit for the “ulimit“ type.

func (TaskDefinitionUlimitOutput) ToTaskDefinitionUlimitOutput 

func (o TaskDefinitionUlimitOutput) ToTaskDefinitionUlimitOutput() TaskDefinitionUlimitOutput

func (TaskDefinitionUlimitOutput) ToTaskDefinitionUlimitOutputWithContext 

func (o TaskDefinitionUlimitOutput) ToTaskDefinitionUlimitOutputWithContext(ctx context.Context) TaskDefinitionUlimitOutput

type TaskDefinitionVolume 

type TaskDefinitionVolume struct {
	// Indicates whether the volume should be configured at launch time. This is used to create Amazon EBS volumes for standalone tasks or tasks created as part of a service. Each task definition revision may only have one volume configured at launch in the volume configuration.
	//  To configure a volume at launch time, use this task definition revision and specify a “volumeConfigurations“ object when calling the “CreateService“, “UpdateService“, “RunTask“ or “StartTask“ APIs.
	ConfiguredAtLaunch *bool `pulumi:"configuredAtLaunch"`
	// This parameter is specified when you use Docker volumes.
	//  Windows containers only support the use of the “local“ driver. To use bind mounts, specify the “host“ parameter instead.
	//   Docker volumes aren't supported by tasks run on FARGATElong.
	DockerVolumeConfiguration *TaskDefinitionDockerVolumeConfiguration `pulumi:"dockerVolumeConfiguration"`
	// This parameter is specified when you use an Amazon Elastic File System file system for task storage.
	EfsVolumeConfiguration *TaskDefinitionEfsVolumeConfiguration `pulumi:"efsVolumeConfiguration"`
	// This parameter is specified when you use Amazon FSx for Windows File Server file system for task storage.
	FSxWindowsFileServerVolumeConfiguration *TaskDefinitionFSxWindowsFileServerVolumeConfiguration `pulumi:"fSxWindowsFileServerVolumeConfiguration"`
	// This parameter is specified when you use bind mount host volumes. The contents of the “host“ parameter determine whether your bind mount host volume persists on the host container instance and where it's stored. If the “host“ parameter is empty, then the Docker daemon assigns a host path for your data volume. However, the data isn't guaranteed to persist after the containers that are associated with it stop running.
	//  Windows containers can mount whole directories on the same drive as “$env:ProgramData“. Windows containers can't mount directories on a different drive, and mount point can't be across drives. For example, you can mount “C:\my\path:C:\my\path“ and “D:\:D:\“, but not “D:\my\path:C:\my\path“ or “D:\:C:\my\path“.
	Host *TaskDefinitionHostVolumeProperties `pulumi:"host"`
	// The name of the volume. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed.
	//  When using a volume configured at launch, the “name“ is required and must also be specified as the volume name in the “ServiceVolumeConfiguration“ or “TaskVolumeConfiguration“ parameter when creating your service or standalone task.
	//  For all other types of volumes, this name is referenced in the “sourceVolume“ parameter of the “mountPoints“ object in the container definition.
	//  When a volume is using the “efsVolumeConfiguration“, the name is required.
	Name *string `pulumi:"name"`
}

The data volume configuration for tasks launched using this task definition. Specifying a volume configuration in a task definition is optional. The volume configuration may contain multiple volumes but only one volume configured at launch is supported. Each volume defined in the volume configuration may only specify a “name“ and one of either “configuredAtLaunch“, “dockerVolumeConfiguration“, “efsVolumeConfiguration“, “fsxWindowsFileServerVolumeConfiguration“, or “host“. If an empty volume configuration is specified, by default Amazon ECS uses a host volume. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html).

type TaskDefinitionVolumeArgs 

type TaskDefinitionVolumeArgs struct {
	// Indicates whether the volume should be configured at launch time. This is used to create Amazon EBS volumes for standalone tasks or tasks created as part of a service. Each task definition revision may only have one volume configured at launch in the volume configuration.
	//  To configure a volume at launch time, use this task definition revision and specify a “volumeConfigurations“ object when calling the “CreateService“, “UpdateService“, “RunTask“ or “StartTask“ APIs.
	ConfiguredAtLaunch pulumi.BoolPtrInput `pulumi:"configuredAtLaunch"`
	// This parameter is specified when you use Docker volumes.
	//  Windows containers only support the use of the “local“ driver. To use bind mounts, specify the “host“ parameter instead.
	//   Docker volumes aren't supported by tasks run on FARGATElong.
	DockerVolumeConfiguration TaskDefinitionDockerVolumeConfigurationPtrInput `pulumi:"dockerVolumeConfiguration"`
	// This parameter is specified when you use an Amazon Elastic File System file system for task storage.
	EfsVolumeConfiguration TaskDefinitionEfsVolumeConfigurationPtrInput `pulumi:"efsVolumeConfiguration"`
	// This parameter is specified when you use Amazon FSx for Windows File Server file system for task storage.
	FSxWindowsFileServerVolumeConfiguration TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrInput `pulumi:"fSxWindowsFileServerVolumeConfiguration"`
	// This parameter is specified when you use bind mount host volumes. The contents of the “host“ parameter determine whether your bind mount host volume persists on the host container instance and where it's stored. If the “host“ parameter is empty, then the Docker daemon assigns a host path for your data volume. However, the data isn't guaranteed to persist after the containers that are associated with it stop running.
	//  Windows containers can mount whole directories on the same drive as “$env:ProgramData“. Windows containers can't mount directories on a different drive, and mount point can't be across drives. For example, you can mount “C:\my\path:C:\my\path“ and “D:\:D:\“, but not “D:\my\path:C:\my\path“ or “D:\:C:\my\path“.
	Host TaskDefinitionHostVolumePropertiesPtrInput `pulumi:"host"`
	// The name of the volume. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed.
	//  When using a volume configured at launch, the “name“ is required and must also be specified as the volume name in the “ServiceVolumeConfiguration“ or “TaskVolumeConfiguration“ parameter when creating your service or standalone task.
	//  For all other types of volumes, this name is referenced in the “sourceVolume“ parameter of the “mountPoints“ object in the container definition.
	//  When a volume is using the “efsVolumeConfiguration“, the name is required.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

The data volume configuration for tasks launched using this task definition. Specifying a volume configuration in a task definition is optional. The volume configuration may contain multiple volumes but only one volume configured at launch is supported. Each volume defined in the volume configuration may only specify a “name“ and one of either “configuredAtLaunch“, “dockerVolumeConfiguration“, “efsVolumeConfiguration“, “fsxWindowsFileServerVolumeConfiguration“, or “host“. If an empty volume configuration is specified, by default Amazon ECS uses a host volume. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html).

func (TaskDefinitionVolumeArgs) ElementType 

func (TaskDefinitionVolumeArgs) ElementType() reflect.Type

func (TaskDefinitionVolumeArgs) ToTaskDefinitionVolumeOutput 

func (i TaskDefinitionVolumeArgs) ToTaskDefinitionVolumeOutput() TaskDefinitionVolumeOutput

func (TaskDefinitionVolumeArgs) ToTaskDefinitionVolumeOutputWithContext 

func (i TaskDefinitionVolumeArgs) ToTaskDefinitionVolumeOutputWithContext(ctx context.Context) TaskDefinitionVolumeOutput

type TaskDefinitionVolumeArray 

type TaskDefinitionVolumeArray []TaskDefinitionVolumeInput

func (TaskDefinitionVolumeArray) ElementType 

func (TaskDefinitionVolumeArray) ElementType() reflect.Type

func (TaskDefinitionVolumeArray) ToTaskDefinitionVolumeArrayOutput 

func (i TaskDefinitionVolumeArray) ToTaskDefinitionVolumeArrayOutput() TaskDefinitionVolumeArrayOutput

func (TaskDefinitionVolumeArray) ToTaskDefinitionVolumeArrayOutputWithContext 

func (i TaskDefinitionVolumeArray) ToTaskDefinitionVolumeArrayOutputWithContext(ctx context.Context) TaskDefinitionVolumeArrayOutput

type TaskDefinitionVolumeArrayInput 

type TaskDefinitionVolumeArrayInput interface {
	pulumi.Input

	ToTaskDefinitionVolumeArrayOutput() TaskDefinitionVolumeArrayOutput
	ToTaskDefinitionVolumeArrayOutputWithContext(context.Context) TaskDefinitionVolumeArrayOutput
}

TaskDefinitionVolumeArrayInput is an input type that accepts TaskDefinitionVolumeArray and TaskDefinitionVolumeArrayOutput values. You can construct a concrete instance of `TaskDefinitionVolumeArrayInput` via: 

TaskDefinitionVolumeArray{ TaskDefinitionVolumeArgs{...} }

type TaskDefinitionVolumeArrayOutput 

type TaskDefinitionVolumeArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionVolumeArrayOutput) ElementType 

func (TaskDefinitionVolumeArrayOutput) ElementType() reflect.Type

func (TaskDefinitionVolumeArrayOutput) Index 

func (o TaskDefinitionVolumeArrayOutput) Index(i pulumi.IntInput) TaskDefinitionVolumeOutput

func (TaskDefinitionVolumeArrayOutput) ToTaskDefinitionVolumeArrayOutput 

func (o TaskDefinitionVolumeArrayOutput) ToTaskDefinitionVolumeArrayOutput() TaskDefinitionVolumeArrayOutput

func (TaskDefinitionVolumeArrayOutput) ToTaskDefinitionVolumeArrayOutputWithContext 

func (o TaskDefinitionVolumeArrayOutput) ToTaskDefinitionVolumeArrayOutputWithContext(ctx context.Context) TaskDefinitionVolumeArrayOutput

type TaskDefinitionVolumeFrom 

type TaskDefinitionVolumeFrom struct {
	// If this value is “true“, the container has read-only access to the volume. If this value is “false“, then the container can write to the volume. The default value is “false“.
	ReadOnly *bool `pulumi:"readOnly"`
	// The name of another container within the same task definition to mount volumes from.
	SourceContainer *string `pulumi:"sourceContainer"`
}

Details on a data volume from another container in the same task definition.

type TaskDefinitionVolumeFromArgs 

type TaskDefinitionVolumeFromArgs struct {
	// If this value is “true“, the container has read-only access to the volume. If this value is “false“, then the container can write to the volume. The default value is “false“.
	ReadOnly pulumi.BoolPtrInput `pulumi:"readOnly"`
	// The name of another container within the same task definition to mount volumes from.
	SourceContainer pulumi.StringPtrInput `pulumi:"sourceContainer"`
}

Details on a data volume from another container in the same task definition.

func (TaskDefinitionVolumeFromArgs) ElementType 

func (TaskDefinitionVolumeFromArgs) ElementType() reflect.Type

func (TaskDefinitionVolumeFromArgs) ToTaskDefinitionVolumeFromOutput 

func (i TaskDefinitionVolumeFromArgs) ToTaskDefinitionVolumeFromOutput() TaskDefinitionVolumeFromOutput

func (TaskDefinitionVolumeFromArgs) ToTaskDefinitionVolumeFromOutputWithContext 

func (i TaskDefinitionVolumeFromArgs) ToTaskDefinitionVolumeFromOutputWithContext(ctx context.Context) TaskDefinitionVolumeFromOutput

type TaskDefinitionVolumeFromArray 

type TaskDefinitionVolumeFromArray []TaskDefinitionVolumeFromInput

func (TaskDefinitionVolumeFromArray) ElementType 

func (TaskDefinitionVolumeFromArray) ElementType() reflect.Type

func (TaskDefinitionVolumeFromArray) ToTaskDefinitionVolumeFromArrayOutput 

func (i TaskDefinitionVolumeFromArray) ToTaskDefinitionVolumeFromArrayOutput() TaskDefinitionVolumeFromArrayOutput

func (TaskDefinitionVolumeFromArray) ToTaskDefinitionVolumeFromArrayOutputWithContext 

func (i TaskDefinitionVolumeFromArray) ToTaskDefinitionVolumeFromArrayOutputWithContext(ctx context.Context) TaskDefinitionVolumeFromArrayOutput

type TaskDefinitionVolumeFromArrayInput 

type TaskDefinitionVolumeFromArrayInput interface {
	pulumi.Input

	ToTaskDefinitionVolumeFromArrayOutput() TaskDefinitionVolumeFromArrayOutput
	ToTaskDefinitionVolumeFromArrayOutputWithContext(context.Context) TaskDefinitionVolumeFromArrayOutput
}

TaskDefinitionVolumeFromArrayInput is an input type that accepts TaskDefinitionVolumeFromArray and TaskDefinitionVolumeFromArrayOutput values. You can construct a concrete instance of `TaskDefinitionVolumeFromArrayInput` via: 

TaskDefinitionVolumeFromArray{ TaskDefinitionVolumeFromArgs{...} }

type TaskDefinitionVolumeFromArrayOutput 

type TaskDefinitionVolumeFromArrayOutput struct{ *pulumi.OutputState }

func (TaskDefinitionVolumeFromArrayOutput) ElementType 

func (TaskDefinitionVolumeFromArrayOutput) ElementType() reflect.Type

func (TaskDefinitionVolumeFromArrayOutput) Index 

func (o TaskDefinitionVolumeFromArrayOutput) Index(i pulumi.IntInput) TaskDefinitionVolumeFromOutput

func (TaskDefinitionVolumeFromArrayOutput) ToTaskDefinitionVolumeFromArrayOutput 

func (o TaskDefinitionVolumeFromArrayOutput) ToTaskDefinitionVolumeFromArrayOutput() TaskDefinitionVolumeFromArrayOutput

func (TaskDefinitionVolumeFromArrayOutput) ToTaskDefinitionVolumeFromArrayOutputWithContext 

func (o TaskDefinitionVolumeFromArrayOutput) ToTaskDefinitionVolumeFromArrayOutputWithContext(ctx context.Context) TaskDefinitionVolumeFromArrayOutput

type TaskDefinitionVolumeFromInput 

type TaskDefinitionVolumeFromInput interface {
	pulumi.Input

	ToTaskDefinitionVolumeFromOutput() TaskDefinitionVolumeFromOutput
	ToTaskDefinitionVolumeFromOutputWithContext(context.Context) TaskDefinitionVolumeFromOutput
}

TaskDefinitionVolumeFromInput is an input type that accepts TaskDefinitionVolumeFromArgs and TaskDefinitionVolumeFromOutput values. You can construct a concrete instance of `TaskDefinitionVolumeFromInput` via: 

TaskDefinitionVolumeFromArgs{...}

type TaskDefinitionVolumeFromOutput 

type TaskDefinitionVolumeFromOutput struct{ *pulumi.OutputState }

Details on a data volume from another container in the same task definition.

func (TaskDefinitionVolumeFromOutput) ElementType 

func (TaskDefinitionVolumeFromOutput) ElementType() reflect.Type

func (TaskDefinitionVolumeFromOutput) ReadOnly 

func (o TaskDefinitionVolumeFromOutput) ReadOnly() pulumi.BoolPtrOutput

If this value is “true“, the container has read-only access to the volume. If this value is “false“, then the container can write to the volume. The default value is “false“.

func (TaskDefinitionVolumeFromOutput) SourceContainer 

func (o TaskDefinitionVolumeFromOutput) SourceContainer() pulumi.StringPtrOutput

The name of another container within the same task definition to mount volumes from.

func (TaskDefinitionVolumeFromOutput) ToTaskDefinitionVolumeFromOutput 

func (o TaskDefinitionVolumeFromOutput) ToTaskDefinitionVolumeFromOutput() TaskDefinitionVolumeFromOutput

func (TaskDefinitionVolumeFromOutput) ToTaskDefinitionVolumeFromOutputWithContext 

func (o TaskDefinitionVolumeFromOutput) ToTaskDefinitionVolumeFromOutputWithContext(ctx context.Context) TaskDefinitionVolumeFromOutput

type TaskDefinitionVolumeInput 

type TaskDefinitionVolumeInput interface {
	pulumi.Input

	ToTaskDefinitionVolumeOutput() TaskDefinitionVolumeOutput
	ToTaskDefinitionVolumeOutputWithContext(context.Context) TaskDefinitionVolumeOutput
}

TaskDefinitionVolumeInput is an input type that accepts TaskDefinitionVolumeArgs and TaskDefinitionVolumeOutput values. You can construct a concrete instance of `TaskDefinitionVolumeInput` via: 

TaskDefinitionVolumeArgs{...}

type TaskDefinitionVolumeOutput 

type TaskDefinitionVolumeOutput struct{ *pulumi.OutputState }

The data volume configuration for tasks launched using this task definition. Specifying a volume configuration in a task definition is optional. The volume configuration may contain multiple volumes but only one volume configured at launch is supported. Each volume defined in the volume configuration may only specify a “name“ and one of either “configuredAtLaunch“, “dockerVolumeConfiguration“, “efsVolumeConfiguration“, “fsxWindowsFileServerVolumeConfiguration“, or “host“. If an empty volume configuration is specified, by default Amazon ECS uses a host volume. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html).

func (TaskDefinitionVolumeOutput) ConfiguredAtLaunch added in v0.93.0 

func (o TaskDefinitionVolumeOutput) ConfiguredAtLaunch() pulumi.BoolPtrOutput

Indicates whether the volume should be configured at launch time. This is used to create Amazon EBS volumes for standalone tasks or tasks created as part of a service. Each task definition revision may only have one volume configured at launch in the volume configuration. 

To configure a volume at launch time, use this task definition revision and specify a ``volumeConfigurations`` object when calling the ``CreateService``, ``UpdateService``, ``RunTask`` or ``StartTask`` APIs.

func (TaskDefinitionVolumeOutput) DockerVolumeConfiguration 

func (o TaskDefinitionVolumeOutput) DockerVolumeConfiguration() TaskDefinitionDockerVolumeConfigurationPtrOutput

This parameter is specified when you use Docker volumes. 

Windows containers only support the use of the ``local`` driver. To use bind mounts, specify the ``host`` parameter instead.
 Docker volumes aren't supported by tasks run on FARGATElong.

func (TaskDefinitionVolumeOutput) EfsVolumeConfiguration added in v0.72.0 

func (o TaskDefinitionVolumeOutput) EfsVolumeConfiguration() TaskDefinitionEfsVolumeConfigurationPtrOutput

This parameter is specified when you use an Amazon Elastic File System file system for task storage.

func (TaskDefinitionVolumeOutput) ElementType 

func (TaskDefinitionVolumeOutput) ElementType() reflect.Type

func (TaskDefinitionVolumeOutput) FSxWindowsFileServerVolumeConfiguration added in v0.101.0 

func (o TaskDefinitionVolumeOutput) FSxWindowsFileServerVolumeConfiguration() TaskDefinitionFSxWindowsFileServerVolumeConfigurationPtrOutput

This parameter is specified when you use Amazon FSx for Windows File Server file system for task storage.

func (TaskDefinitionVolumeOutput) Host 

func (o TaskDefinitionVolumeOutput) Host() TaskDefinitionHostVolumePropertiesPtrOutput

This parameter is specified when you use bind mount host volumes. The contents of the “host“ parameter determine whether your bind mount host volume persists on the host container instance and where it's stored. If the “host“ parameter is empty, then the Docker daemon assigns a host path for your data volume. However, the data isn't guaranteed to persist after the containers that are associated with it stop running. 

Windows containers can mount whole directories on the same drive as ``$env:ProgramData``. Windows containers can't mount directories on a different drive, and mount point can't be across drives. For example, you can mount ``C:\my\path:C:\my\path`` and ``D:\:D:\``, but not ``D:\my\path:C:\my\path`` or ``D:\:C:\my\path``.

func (TaskDefinitionVolumeOutput) Name 

func (o TaskDefinitionVolumeOutput) Name() pulumi.StringPtrOutput

The name of the volume. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. 

When using a volume configured at launch, the ``name`` is required and must also be specified as the volume name in the ``ServiceVolumeConfiguration`` or ``TaskVolumeConfiguration`` parameter when creating your service or standalone task.
For all other types of volumes, this name is referenced in the ``sourceVolume`` parameter of the ``mountPoints`` object in the container definition.
When a volume is using the ``efsVolumeConfiguration``, the name is required.

func (TaskDefinitionVolumeOutput) ToTaskDefinitionVolumeOutput 

func (o TaskDefinitionVolumeOutput) ToTaskDefinitionVolumeOutput() TaskDefinitionVolumeOutput

func (TaskDefinitionVolumeOutput) ToTaskDefinitionVolumeOutputWithContext 

func (o TaskDefinitionVolumeOutput) ToTaskDefinitionVolumeOutputWithContext(ctx context.Context) TaskDefinitionVolumeOutput

type TaskSet 

type TaskSet struct {
	pulumi.CustomResourceState

	// The ID of the task set.
	AwsId pulumi.StringOutput `pulumi:"awsId"`
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
	Cluster pulumi.StringOutput `pulumi:"cluster"`
	// An optional non-unique tag that identifies this task set in external systems. If the task set is associated with a service discovery registry, the tasks in this task set will have the ECS_TASK_SET_EXTERNAL_ID AWS Cloud Map attribute set to the provided value.
	ExternalId pulumi.StringPtrOutput `pulumi:"externalId"`
	// The launch type that new tasks in the task set will use. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html in the Amazon Elastic Container Service Developer Guide.
	LaunchType           TaskSetLaunchTypePtrOutput           `pulumi:"launchType"`
	LoadBalancers        TaskSetLoadBalancerArrayOutput       `pulumi:"loadBalancers"`
	NetworkConfiguration TaskSetNetworkConfigurationPtrOutput `pulumi:"networkConfiguration"`
	// The platform version that the tasks in the task set should use. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the LATEST platform version is used by default.
	PlatformVersion pulumi.StringPtrOutput `pulumi:"platformVersion"`
	// A floating-point percentage of the desired number of tasks to place and keep running in the task set.
	Scale TaskSetScalePtrOutput `pulumi:"scale"`
	// The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
	Service pulumi.StringOutput `pulumi:"service"`
	// The details of the service discovery registries to assign to this task set. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html.
	ServiceRegistries TaskSetServiceRegistryArrayOutput `pulumi:"serviceRegistries"`
	Tags              aws.TagArrayOutput                `pulumi:"tags"`
	// The short name or full Amazon Resource Name (ARN) of the task definition for the tasks in the task set to use.
	TaskDefinition pulumi.StringOutput `pulumi:"taskDefinition"`
}

Create a task set in the specified cluster and service. This is used when a service uses the EXTERNAL deployment controller type. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.htmlin the Amazon Elastic Container Service Developer Guide.

func GetTaskSet 

func GetTaskSet(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TaskSetState, opts ...pulumi.ResourceOption) (*TaskSet, error)

GetTaskSet gets an existing TaskSet 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 NewTaskSet 

func NewTaskSet(ctx *pulumi.Context,
	name string, args *TaskSetArgs, opts ...pulumi.ResourceOption) (*TaskSet, error)

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

func (*TaskSet) ElementType 

func (*TaskSet) ElementType() reflect.Type

func (*TaskSet) ToTaskSetOutput 

func (i *TaskSet) ToTaskSetOutput() TaskSetOutput

func (*TaskSet) ToTaskSetOutputWithContext 

func (i *TaskSet) ToTaskSetOutputWithContext(ctx context.Context) TaskSetOutput

type TaskSetArgs 

type TaskSetArgs struct {
	// The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.
	Cluster pulumi.StringInput
	// An optional non-unique tag that identifies this task set in external systems. If the task set is associated with a service discovery registry, the tasks in this task set will have the ECS_TASK_SET_EXTERNAL_ID AWS Cloud Map attribute set to the provided value.
	ExternalId pulumi.StringPtrInput
	// The launch type that new tasks in the task set will use. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html in the Amazon Elastic Container Service Developer Guide.
	LaunchType           TaskSetLaunchTypePtrInput
	LoadBalancers        TaskSetLoadBalancerArrayInput
	NetworkConfiguration TaskSetNetworkConfigurationPtrInput
	// The platform version that the tasks in the task set should use. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the LATEST platform version is used by default.
	PlatformVersion pulumi.StringPtrInput
	// A floating-point percentage of the desired number of tasks to place and keep running in the task set.
	Scale TaskSetScalePtrInput
	// The short name or full Amazon Resource Name (ARN) of the service to create the task set in.
	Service pulumi.StringInput
	// The details of the service discovery registries to assign to this task set. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html.
	ServiceRegistries TaskSetServiceRegistryArrayInput
	Tags              aws.TagArrayInput
	// The short name or full Amazon Resource Name (ARN) of the task definition for the tasks in the task set to use.
	TaskDefinition pulumi.StringInput
}

The set of arguments for constructing a TaskSet resource.

func (TaskSetArgs) ElementType 

func (TaskSetArgs) ElementType() reflect.Type

type TaskSetAwsVpcConfiguration 

type TaskSetAwsVpcConfiguration struct {
	// Whether the task's elastic network interface receives a public IP address. The default value is DISABLED.
	AssignPublicIp *TaskSetAwsVpcConfigurationAssignPublicIp `pulumi:"assignPublicIp"`
	// The security groups associated with the task or service. If you do not specify a security group, the default security group for the VPC is used. There is a limit of 5 security groups that can be specified per AwsVpcConfiguration.
	SecurityGroups []string `pulumi:"securityGroups"`
	// The subnets associated with the task or service. There is a limit of 16 subnets that can be specified per AwsVpcConfiguration.
	Subnets []string `pulumi:"subnets"`
}

The VPC subnets and security groups associated with a task. All specified subnets and security groups must be from the same VPC.

type TaskSetAwsVpcConfigurationArgs 

type TaskSetAwsVpcConfigurationArgs struct {
	// Whether the task's elastic network interface receives a public IP address. The default value is DISABLED.
	AssignPublicIp TaskSetAwsVpcConfigurationAssignPublicIpPtrInput `pulumi:"assignPublicIp"`
	// The security groups associated with the task or service. If you do not specify a security group, the default security group for the VPC is used. There is a limit of 5 security groups that can be specified per AwsVpcConfiguration.
	SecurityGroups pulumi.StringArrayInput `pulumi:"securityGroups"`
	// The subnets associated with the task or service. There is a limit of 16 subnets that can be specified per AwsVpcConfiguration.
	Subnets pulumi.StringArrayInput `pulumi:"subnets"`
}

The VPC subnets and security groups associated with a task. All specified subnets and security groups must be from the same VPC.

func (TaskSetAwsVpcConfigurationArgs) ElementType 

func (TaskSetAwsVpcConfigurationArgs) ElementType() reflect.Type

func (TaskSetAwsVpcConfigurationArgs) ToTaskSetAwsVpcConfigurationOutput 

func (i TaskSetAwsVpcConfigurationArgs) ToTaskSetAwsVpcConfigurationOutput() TaskSetAwsVpcConfigurationOutput

func (TaskSetAwsVpcConfigurationArgs) ToTaskSetAwsVpcConfigurationOutputWithContext 

func (i TaskSetAwsVpcConfigurationArgs) ToTaskSetAwsVpcConfigurationOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationOutput

func (TaskSetAwsVpcConfigurationArgs) ToTaskSetAwsVpcConfigurationPtrOutput 

func (i TaskSetAwsVpcConfigurationArgs) ToTaskSetAwsVpcConfigurationPtrOutput() TaskSetAwsVpcConfigurationPtrOutput

func (TaskSetAwsVpcConfigurationArgs) ToTaskSetAwsVpcConfigurationPtrOutputWithContext 

func (i TaskSetAwsVpcConfigurationArgs) ToTaskSetAwsVpcConfigurationPtrOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationPtrOutput

type TaskSetAwsVpcConfigurationAssignPublicIp 

type TaskSetAwsVpcConfigurationAssignPublicIp string

Whether the task's elastic network interface receives a public IP address. The default value is DISABLED.

func (TaskSetAwsVpcConfigurationAssignPublicIp) ElementType 

func (TaskSetAwsVpcConfigurationAssignPublicIp) ElementType() reflect.Type

func (TaskSetAwsVpcConfigurationAssignPublicIp) ToStringOutput 

func (e TaskSetAwsVpcConfigurationAssignPublicIp) ToStringOutput() pulumi.StringOutput

func (TaskSetAwsVpcConfigurationAssignPublicIp) ToStringOutputWithContext 

func (e TaskSetAwsVpcConfigurationAssignPublicIp) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskSetAwsVpcConfigurationAssignPublicIp) ToStringPtrOutput 

func (e TaskSetAwsVpcConfigurationAssignPublicIp) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIp) ToStringPtrOutputWithContext 

func (e TaskSetAwsVpcConfigurationAssignPublicIp) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIp) ToTaskSetAwsVpcConfigurationAssignPublicIpOutput 

func (e TaskSetAwsVpcConfigurationAssignPublicIp) ToTaskSetAwsVpcConfigurationAssignPublicIpOutput() TaskSetAwsVpcConfigurationAssignPublicIpOutput

func (TaskSetAwsVpcConfigurationAssignPublicIp) ToTaskSetAwsVpcConfigurationAssignPublicIpOutputWithContext 

func (e TaskSetAwsVpcConfigurationAssignPublicIp) ToTaskSetAwsVpcConfigurationAssignPublicIpOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationAssignPublicIpOutput

func (TaskSetAwsVpcConfigurationAssignPublicIp) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutput 

func (e TaskSetAwsVpcConfigurationAssignPublicIp) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutput() TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIp) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutputWithContext 

func (e TaskSetAwsVpcConfigurationAssignPublicIp) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput

type TaskSetAwsVpcConfigurationAssignPublicIpInput 

type TaskSetAwsVpcConfigurationAssignPublicIpInput interface {
	pulumi.Input

	ToTaskSetAwsVpcConfigurationAssignPublicIpOutput() TaskSetAwsVpcConfigurationAssignPublicIpOutput
	ToTaskSetAwsVpcConfigurationAssignPublicIpOutputWithContext(context.Context) TaskSetAwsVpcConfigurationAssignPublicIpOutput
}

TaskSetAwsVpcConfigurationAssignPublicIpInput is an input type that accepts values of the TaskSetAwsVpcConfigurationAssignPublicIp enum A concrete instance of `TaskSetAwsVpcConfigurationAssignPublicIpInput` can be one of the following: 

TaskSetAwsVpcConfigurationAssignPublicIpDisabled
TaskSetAwsVpcConfigurationAssignPublicIpEnabled

type TaskSetAwsVpcConfigurationAssignPublicIpOutput 

type TaskSetAwsVpcConfigurationAssignPublicIpOutput struct{ *pulumi.OutputState }

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ElementType 

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ElementType() reflect.Type

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToStringOutput 

func (o TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToStringOutput() pulumi.StringOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToStringOutputWithContext 

func (o TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToStringPtrOutput 

func (o TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToStringPtrOutputWithContext 

func (o TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpOutput 

func (o TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpOutput() TaskSetAwsVpcConfigurationAssignPublicIpOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpOutputWithContext 

func (o TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationAssignPublicIpOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutput 

func (o TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutput() TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutputWithContext 

func (o TaskSetAwsVpcConfigurationAssignPublicIpOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput

type TaskSetAwsVpcConfigurationAssignPublicIpPtrInput 

type TaskSetAwsVpcConfigurationAssignPublicIpPtrInput interface {
	pulumi.Input

	ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutput() TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput
	ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutputWithContext(context.Context) TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput
}

func TaskSetAwsVpcConfigurationAssignPublicIpPtr 

func TaskSetAwsVpcConfigurationAssignPublicIpPtr(v string) TaskSetAwsVpcConfigurationAssignPublicIpPtrInput

type TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput 

type TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput struct{ *pulumi.OutputState }

func (TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) Elem 

func (o TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) Elem() TaskSetAwsVpcConfigurationAssignPublicIpOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ElementType 

func (TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ElementType() reflect.Type

func (TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ToStringPtrOutput 

func (o TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ToStringPtrOutputWithContext 

func (o TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutput 

func (o TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutput() TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput

func (TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutputWithContext 

func (o TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput) ToTaskSetAwsVpcConfigurationAssignPublicIpPtrOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput

type TaskSetAwsVpcConfigurationInput 

type TaskSetAwsVpcConfigurationInput interface {
	pulumi.Input

	ToTaskSetAwsVpcConfigurationOutput() TaskSetAwsVpcConfigurationOutput
	ToTaskSetAwsVpcConfigurationOutputWithContext(context.Context) TaskSetAwsVpcConfigurationOutput
}

TaskSetAwsVpcConfigurationInput is an input type that accepts TaskSetAwsVpcConfigurationArgs and TaskSetAwsVpcConfigurationOutput values. You can construct a concrete instance of `TaskSetAwsVpcConfigurationInput` via: 

TaskSetAwsVpcConfigurationArgs{...}

type TaskSetAwsVpcConfigurationOutput 

type TaskSetAwsVpcConfigurationOutput struct{ *pulumi.OutputState }

The VPC subnets and security groups associated with a task. All specified subnets and security groups must be from the same VPC.

func (TaskSetAwsVpcConfigurationOutput) AssignPublicIp 

func (o TaskSetAwsVpcConfigurationOutput) AssignPublicIp() TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput

Whether the task's elastic network interface receives a public IP address. The default value is DISABLED.

func (TaskSetAwsVpcConfigurationOutput) ElementType 

func (TaskSetAwsVpcConfigurationOutput) ElementType() reflect.Type

func (TaskSetAwsVpcConfigurationOutput) SecurityGroups 

func (o TaskSetAwsVpcConfigurationOutput) SecurityGroups() pulumi.StringArrayOutput

The security groups associated with the task or service. If you do not specify a security group, the default security group for the VPC is used. There is a limit of 5 security groups that can be specified per AwsVpcConfiguration.

func (TaskSetAwsVpcConfigurationOutput) Subnets 

func (o TaskSetAwsVpcConfigurationOutput) Subnets() pulumi.StringArrayOutput

The subnets associated with the task or service. There is a limit of 16 subnets that can be specified per AwsVpcConfiguration.

func (TaskSetAwsVpcConfigurationOutput) ToTaskSetAwsVpcConfigurationOutput 

func (o TaskSetAwsVpcConfigurationOutput) ToTaskSetAwsVpcConfigurationOutput() TaskSetAwsVpcConfigurationOutput

func (TaskSetAwsVpcConfigurationOutput) ToTaskSetAwsVpcConfigurationOutputWithContext 

func (o TaskSetAwsVpcConfigurationOutput) ToTaskSetAwsVpcConfigurationOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationOutput

func (TaskSetAwsVpcConfigurationOutput) ToTaskSetAwsVpcConfigurationPtrOutput 

func (o TaskSetAwsVpcConfigurationOutput) ToTaskSetAwsVpcConfigurationPtrOutput() TaskSetAwsVpcConfigurationPtrOutput

func (TaskSetAwsVpcConfigurationOutput) ToTaskSetAwsVpcConfigurationPtrOutputWithContext 

func (o TaskSetAwsVpcConfigurationOutput) ToTaskSetAwsVpcConfigurationPtrOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationPtrOutput

type TaskSetAwsVpcConfigurationPtrInput 

type TaskSetAwsVpcConfigurationPtrInput interface {
	pulumi.Input

	ToTaskSetAwsVpcConfigurationPtrOutput() TaskSetAwsVpcConfigurationPtrOutput
	ToTaskSetAwsVpcConfigurationPtrOutputWithContext(context.Context) TaskSetAwsVpcConfigurationPtrOutput
}

TaskSetAwsVpcConfigurationPtrInput is an input type that accepts TaskSetAwsVpcConfigurationArgs, TaskSetAwsVpcConfigurationPtr and TaskSetAwsVpcConfigurationPtrOutput values. You can construct a concrete instance of `TaskSetAwsVpcConfigurationPtrInput` via: 

        TaskSetAwsVpcConfigurationArgs{...}

or:

        nil

func TaskSetAwsVpcConfigurationPtr 

func TaskSetAwsVpcConfigurationPtr(v *TaskSetAwsVpcConfigurationArgs) TaskSetAwsVpcConfigurationPtrInput

type TaskSetAwsVpcConfigurationPtrOutput 

type TaskSetAwsVpcConfigurationPtrOutput struct{ *pulumi.OutputState }

func (TaskSetAwsVpcConfigurationPtrOutput) AssignPublicIp 

func (o TaskSetAwsVpcConfigurationPtrOutput) AssignPublicIp() TaskSetAwsVpcConfigurationAssignPublicIpPtrOutput

Whether the task's elastic network interface receives a public IP address. The default value is DISABLED.

func (TaskSetAwsVpcConfigurationPtrOutput) Elem 

func (o TaskSetAwsVpcConfigurationPtrOutput) Elem() TaskSetAwsVpcConfigurationOutput

func (TaskSetAwsVpcConfigurationPtrOutput) ElementType 

func (TaskSetAwsVpcConfigurationPtrOutput) ElementType() reflect.Type

func (TaskSetAwsVpcConfigurationPtrOutput) SecurityGroups 

func (o TaskSetAwsVpcConfigurationPtrOutput) SecurityGroups() pulumi.StringArrayOutput

The security groups associated with the task or service. If you do not specify a security group, the default security group for the VPC is used. There is a limit of 5 security groups that can be specified per AwsVpcConfiguration.

func (TaskSetAwsVpcConfigurationPtrOutput) Subnets 

func (o TaskSetAwsVpcConfigurationPtrOutput) Subnets() pulumi.StringArrayOutput

The subnets associated with the task or service. There is a limit of 16 subnets that can be specified per AwsVpcConfiguration.

func (TaskSetAwsVpcConfigurationPtrOutput) ToTaskSetAwsVpcConfigurationPtrOutput 

func (o TaskSetAwsVpcConfigurationPtrOutput) ToTaskSetAwsVpcConfigurationPtrOutput() TaskSetAwsVpcConfigurationPtrOutput

func (TaskSetAwsVpcConfigurationPtrOutput) ToTaskSetAwsVpcConfigurationPtrOutputWithContext 

func (o TaskSetAwsVpcConfigurationPtrOutput) ToTaskSetAwsVpcConfigurationPtrOutputWithContext(ctx context.Context) TaskSetAwsVpcConfigurationPtrOutput

type TaskSetInput 

type TaskSetInput interface {
	pulumi.Input

	ToTaskSetOutput() TaskSetOutput
	ToTaskSetOutputWithContext(ctx context.Context) TaskSetOutput
}

type TaskSetLaunchType 

type TaskSetLaunchType string

The launch type that new tasks in the task set will use. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html in the Amazon Elastic Container Service Developer Guide.

func (TaskSetLaunchType) ElementType 

func (TaskSetLaunchType) ElementType() reflect.Type

func (TaskSetLaunchType) ToStringOutput 

func (e TaskSetLaunchType) ToStringOutput() pulumi.StringOutput

func (TaskSetLaunchType) ToStringOutputWithContext 

func (e TaskSetLaunchType) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskSetLaunchType) ToStringPtrOutput 

func (e TaskSetLaunchType) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetLaunchType) ToStringPtrOutputWithContext 

func (e TaskSetLaunchType) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetLaunchType) ToTaskSetLaunchTypeOutput 

func (e TaskSetLaunchType) ToTaskSetLaunchTypeOutput() TaskSetLaunchTypeOutput

func (TaskSetLaunchType) ToTaskSetLaunchTypeOutputWithContext 

func (e TaskSetLaunchType) ToTaskSetLaunchTypeOutputWithContext(ctx context.Context) TaskSetLaunchTypeOutput

func (TaskSetLaunchType) ToTaskSetLaunchTypePtrOutput 

func (e TaskSetLaunchType) ToTaskSetLaunchTypePtrOutput() TaskSetLaunchTypePtrOutput

func (TaskSetLaunchType) ToTaskSetLaunchTypePtrOutputWithContext 

func (e TaskSetLaunchType) ToTaskSetLaunchTypePtrOutputWithContext(ctx context.Context) TaskSetLaunchTypePtrOutput

type TaskSetLaunchTypeInput 

type TaskSetLaunchTypeInput interface {
	pulumi.Input

	ToTaskSetLaunchTypeOutput() TaskSetLaunchTypeOutput
	ToTaskSetLaunchTypeOutputWithContext(context.Context) TaskSetLaunchTypeOutput
}

TaskSetLaunchTypeInput is an input type that accepts values of the TaskSetLaunchType enum A concrete instance of `TaskSetLaunchTypeInput` can be one of the following: 

TaskSetLaunchTypeEc2
TaskSetLaunchTypeFargate

type TaskSetLaunchTypeOutput 

type TaskSetLaunchTypeOutput struct{ *pulumi.OutputState }

func (TaskSetLaunchTypeOutput) ElementType 

func (TaskSetLaunchTypeOutput) ElementType() reflect.Type

func (TaskSetLaunchTypeOutput) ToStringOutput 

func (o TaskSetLaunchTypeOutput) ToStringOutput() pulumi.StringOutput

func (TaskSetLaunchTypeOutput) ToStringOutputWithContext 

func (o TaskSetLaunchTypeOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskSetLaunchTypeOutput) ToStringPtrOutput 

func (o TaskSetLaunchTypeOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetLaunchTypeOutput) ToStringPtrOutputWithContext 

func (o TaskSetLaunchTypeOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetLaunchTypeOutput) ToTaskSetLaunchTypeOutput 

func (o TaskSetLaunchTypeOutput) ToTaskSetLaunchTypeOutput() TaskSetLaunchTypeOutput

func (TaskSetLaunchTypeOutput) ToTaskSetLaunchTypeOutputWithContext 

func (o TaskSetLaunchTypeOutput) ToTaskSetLaunchTypeOutputWithContext(ctx context.Context) TaskSetLaunchTypeOutput

func (TaskSetLaunchTypeOutput) ToTaskSetLaunchTypePtrOutput 

func (o TaskSetLaunchTypeOutput) ToTaskSetLaunchTypePtrOutput() TaskSetLaunchTypePtrOutput

func (TaskSetLaunchTypeOutput) ToTaskSetLaunchTypePtrOutputWithContext 

func (o TaskSetLaunchTypeOutput) ToTaskSetLaunchTypePtrOutputWithContext(ctx context.Context) TaskSetLaunchTypePtrOutput

type TaskSetLaunchTypePtrInput 

type TaskSetLaunchTypePtrInput interface {
	pulumi.Input

	ToTaskSetLaunchTypePtrOutput() TaskSetLaunchTypePtrOutput
	ToTaskSetLaunchTypePtrOutputWithContext(context.Context) TaskSetLaunchTypePtrOutput
}

func TaskSetLaunchTypePtr 

func TaskSetLaunchTypePtr(v string) TaskSetLaunchTypePtrInput

type TaskSetLaunchTypePtrOutput 

type TaskSetLaunchTypePtrOutput struct{ *pulumi.OutputState }

func (TaskSetLaunchTypePtrOutput) Elem 

func (o TaskSetLaunchTypePtrOutput) Elem() TaskSetLaunchTypeOutput

func (TaskSetLaunchTypePtrOutput) ElementType 

func (TaskSetLaunchTypePtrOutput) ElementType() reflect.Type

func (TaskSetLaunchTypePtrOutput) ToStringPtrOutput 

func (o TaskSetLaunchTypePtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetLaunchTypePtrOutput) ToStringPtrOutputWithContext 

func (o TaskSetLaunchTypePtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetLaunchTypePtrOutput) ToTaskSetLaunchTypePtrOutput 

func (o TaskSetLaunchTypePtrOutput) ToTaskSetLaunchTypePtrOutput() TaskSetLaunchTypePtrOutput

func (TaskSetLaunchTypePtrOutput) ToTaskSetLaunchTypePtrOutputWithContext 

func (o TaskSetLaunchTypePtrOutput) ToTaskSetLaunchTypePtrOutputWithContext(ctx context.Context) TaskSetLaunchTypePtrOutput

type TaskSetLoadBalancer 

type TaskSetLoadBalancer struct {
	// The name of the container (as it appears in a container definition) to associate with the load balancer.
	ContainerName *string `pulumi:"containerName"`
	// The port on the container to associate with the load balancer. This port must correspond to a containerPort in the task definition the tasks in the service are using. For tasks that use the EC2 launch type, the container instance they are launched on must allow ingress traffic on the hostPort of the port mapping.
	ContainerPort *int `pulumi:"containerPort"`
	// The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group or groups associated with a service or task set. A target group ARN is only specified when using an Application Load Balancer or Network Load Balancer. If you are using a Classic Load Balancer this should be omitted. For services using the ECS deployment controller, you can specify one or multiple target groups. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html in the Amazon Elastic Container Service Developer Guide. For services using the CODE_DEPLOY deployment controller, you are required to define two target groups for the load balancer. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html in the Amazon Elastic Container Service Developer Guide. If your service's task definition uses the awsvpc network mode (which is required for the Fargate launch type), you must choose ip as the target type, not instance, when creating your target groups because tasks that use the awsvpc network mode are associated with an elastic network interface, not an Amazon EC2 instance.
	TargetGroupArn *string `pulumi:"targetGroupArn"`
}

A load balancer object representing the load balancer to use with the task set. The supported load balancer types are either an Application Load Balancer or a Network Load Balancer.

type TaskSetLoadBalancerArgs 

type TaskSetLoadBalancerArgs struct {
	// The name of the container (as it appears in a container definition) to associate with the load balancer.
	ContainerName pulumi.StringPtrInput `pulumi:"containerName"`
	// The port on the container to associate with the load balancer. This port must correspond to a containerPort in the task definition the tasks in the service are using. For tasks that use the EC2 launch type, the container instance they are launched on must allow ingress traffic on the hostPort of the port mapping.
	ContainerPort pulumi.IntPtrInput `pulumi:"containerPort"`
	// The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group or groups associated with a service or task set. A target group ARN is only specified when using an Application Load Balancer or Network Load Balancer. If you are using a Classic Load Balancer this should be omitted. For services using the ECS deployment controller, you can specify one or multiple target groups. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html in the Amazon Elastic Container Service Developer Guide. For services using the CODE_DEPLOY deployment controller, you are required to define two target groups for the load balancer. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html in the Amazon Elastic Container Service Developer Guide. If your service's task definition uses the awsvpc network mode (which is required for the Fargate launch type), you must choose ip as the target type, not instance, when creating your target groups because tasks that use the awsvpc network mode are associated with an elastic network interface, not an Amazon EC2 instance.
	TargetGroupArn pulumi.StringPtrInput `pulumi:"targetGroupArn"`
}

A load balancer object representing the load balancer to use with the task set. The supported load balancer types are either an Application Load Balancer or a Network Load Balancer.

func (TaskSetLoadBalancerArgs) ElementType 

func (TaskSetLoadBalancerArgs) ElementType() reflect.Type

func (TaskSetLoadBalancerArgs) ToTaskSetLoadBalancerOutput 

func (i TaskSetLoadBalancerArgs) ToTaskSetLoadBalancerOutput() TaskSetLoadBalancerOutput

func (TaskSetLoadBalancerArgs) ToTaskSetLoadBalancerOutputWithContext 

func (i TaskSetLoadBalancerArgs) ToTaskSetLoadBalancerOutputWithContext(ctx context.Context) TaskSetLoadBalancerOutput

type TaskSetLoadBalancerArray 

type TaskSetLoadBalancerArray []TaskSetLoadBalancerInput

func (TaskSetLoadBalancerArray) ElementType 

func (TaskSetLoadBalancerArray) ElementType() reflect.Type

func (TaskSetLoadBalancerArray) ToTaskSetLoadBalancerArrayOutput 

func (i TaskSetLoadBalancerArray) ToTaskSetLoadBalancerArrayOutput() TaskSetLoadBalancerArrayOutput

func (TaskSetLoadBalancerArray) ToTaskSetLoadBalancerArrayOutputWithContext 

func (i TaskSetLoadBalancerArray) ToTaskSetLoadBalancerArrayOutputWithContext(ctx context.Context) TaskSetLoadBalancerArrayOutput

type TaskSetLoadBalancerArrayInput 

type TaskSetLoadBalancerArrayInput interface {
	pulumi.Input

	ToTaskSetLoadBalancerArrayOutput() TaskSetLoadBalancerArrayOutput
	ToTaskSetLoadBalancerArrayOutputWithContext(context.Context) TaskSetLoadBalancerArrayOutput
}

TaskSetLoadBalancerArrayInput is an input type that accepts TaskSetLoadBalancerArray and TaskSetLoadBalancerArrayOutput values. You can construct a concrete instance of `TaskSetLoadBalancerArrayInput` via: 

TaskSetLoadBalancerArray{ TaskSetLoadBalancerArgs{...} }

type TaskSetLoadBalancerArrayOutput 

type TaskSetLoadBalancerArrayOutput struct{ *pulumi.OutputState }

func (TaskSetLoadBalancerArrayOutput) ElementType 

func (TaskSetLoadBalancerArrayOutput) ElementType() reflect.Type

func (TaskSetLoadBalancerArrayOutput) Index 

func (o TaskSetLoadBalancerArrayOutput) Index(i pulumi.IntInput) TaskSetLoadBalancerOutput

func (TaskSetLoadBalancerArrayOutput) ToTaskSetLoadBalancerArrayOutput 

func (o TaskSetLoadBalancerArrayOutput) ToTaskSetLoadBalancerArrayOutput() TaskSetLoadBalancerArrayOutput

func (TaskSetLoadBalancerArrayOutput) ToTaskSetLoadBalancerArrayOutputWithContext 

func (o TaskSetLoadBalancerArrayOutput) ToTaskSetLoadBalancerArrayOutputWithContext(ctx context.Context) TaskSetLoadBalancerArrayOutput

type TaskSetLoadBalancerInput 

type TaskSetLoadBalancerInput interface {
	pulumi.Input

	ToTaskSetLoadBalancerOutput() TaskSetLoadBalancerOutput
	ToTaskSetLoadBalancerOutputWithContext(context.Context) TaskSetLoadBalancerOutput
}

TaskSetLoadBalancerInput is an input type that accepts TaskSetLoadBalancerArgs and TaskSetLoadBalancerOutput values. You can construct a concrete instance of `TaskSetLoadBalancerInput` via: 

TaskSetLoadBalancerArgs{...}

type TaskSetLoadBalancerOutput 

type TaskSetLoadBalancerOutput struct{ *pulumi.OutputState }

A load balancer object representing the load balancer to use with the task set. The supported load balancer types are either an Application Load Balancer or a Network Load Balancer.

func (TaskSetLoadBalancerOutput) ContainerName 

func (o TaskSetLoadBalancerOutput) ContainerName() pulumi.StringPtrOutput

The name of the container (as it appears in a container definition) to associate with the load balancer.

func (TaskSetLoadBalancerOutput) ContainerPort 

func (o TaskSetLoadBalancerOutput) ContainerPort() pulumi.IntPtrOutput

The port on the container to associate with the load balancer. This port must correspond to a containerPort in the task definition the tasks in the service are using. For tasks that use the EC2 launch type, the container instance they are launched on must allow ingress traffic on the hostPort of the port mapping.

func (TaskSetLoadBalancerOutput) ElementType 

func (TaskSetLoadBalancerOutput) ElementType() reflect.Type

func (TaskSetLoadBalancerOutput) TargetGroupArn 

func (o TaskSetLoadBalancerOutput) TargetGroupArn() pulumi.StringPtrOutput

The full Amazon Resource Name (ARN) of the Elastic Load Balancing target group or groups associated with a service or task set. A target group ARN is only specified when using an Application Load Balancer or Network Load Balancer. If you are using a Classic Load Balancer this should be omitted. For services using the ECS deployment controller, you can specify one or multiple target groups. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/register-multiple-targetgroups.html in the Amazon Elastic Container Service Developer Guide. For services using the CODE_DEPLOY deployment controller, you are required to define two target groups for the load balancer. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-bluegreen.html in the Amazon Elastic Container Service Developer Guide. If your service's task definition uses the awsvpc network mode (which is required for the Fargate launch type), you must choose ip as the target type, not instance, when creating your target groups because tasks that use the awsvpc network mode are associated with an elastic network interface, not an Amazon EC2 instance.

func (TaskSetLoadBalancerOutput) ToTaskSetLoadBalancerOutput 

func (o TaskSetLoadBalancerOutput) ToTaskSetLoadBalancerOutput() TaskSetLoadBalancerOutput

func (TaskSetLoadBalancerOutput) ToTaskSetLoadBalancerOutputWithContext 

func (o TaskSetLoadBalancerOutput) ToTaskSetLoadBalancerOutputWithContext(ctx context.Context) TaskSetLoadBalancerOutput

type TaskSetNetworkConfiguration 

type TaskSetNetworkConfiguration struct {
	AwsVpcConfiguration *TaskSetAwsVpcConfiguration `pulumi:"awsVpcConfiguration"`
}

An object representing the network configuration for a task or service.

type TaskSetNetworkConfigurationArgs 

type TaskSetNetworkConfigurationArgs struct {
	AwsVpcConfiguration TaskSetAwsVpcConfigurationPtrInput `pulumi:"awsVpcConfiguration"`
}

An object representing the network configuration for a task or service.

func (TaskSetNetworkConfigurationArgs) ElementType 

func (TaskSetNetworkConfigurationArgs) ElementType() reflect.Type

func (TaskSetNetworkConfigurationArgs) ToTaskSetNetworkConfigurationOutput 

func (i TaskSetNetworkConfigurationArgs) ToTaskSetNetworkConfigurationOutput() TaskSetNetworkConfigurationOutput

func (TaskSetNetworkConfigurationArgs) ToTaskSetNetworkConfigurationOutputWithContext 

func (i TaskSetNetworkConfigurationArgs) ToTaskSetNetworkConfigurationOutputWithContext(ctx context.Context) TaskSetNetworkConfigurationOutput

func (TaskSetNetworkConfigurationArgs) ToTaskSetNetworkConfigurationPtrOutput 

func (i TaskSetNetworkConfigurationArgs) ToTaskSetNetworkConfigurationPtrOutput() TaskSetNetworkConfigurationPtrOutput

func (TaskSetNetworkConfigurationArgs) ToTaskSetNetworkConfigurationPtrOutputWithContext 

func (i TaskSetNetworkConfigurationArgs) ToTaskSetNetworkConfigurationPtrOutputWithContext(ctx context.Context) TaskSetNetworkConfigurationPtrOutput

type TaskSetNetworkConfigurationInput 

type TaskSetNetworkConfigurationInput interface {
	pulumi.Input

	ToTaskSetNetworkConfigurationOutput() TaskSetNetworkConfigurationOutput
	ToTaskSetNetworkConfigurationOutputWithContext(context.Context) TaskSetNetworkConfigurationOutput
}

TaskSetNetworkConfigurationInput is an input type that accepts TaskSetNetworkConfigurationArgs and TaskSetNetworkConfigurationOutput values. You can construct a concrete instance of `TaskSetNetworkConfigurationInput` via: 

TaskSetNetworkConfigurationArgs{...}

type TaskSetNetworkConfigurationOutput 

type TaskSetNetworkConfigurationOutput struct{ *pulumi.OutputState }

An object representing the network configuration for a task or service.

func (TaskSetNetworkConfigurationOutput) AwsVpcConfiguration 

func (o TaskSetNetworkConfigurationOutput) AwsVpcConfiguration() TaskSetAwsVpcConfigurationPtrOutput

func (TaskSetNetworkConfigurationOutput) ElementType 

func (TaskSetNetworkConfigurationOutput) ElementType() reflect.Type

func (TaskSetNetworkConfigurationOutput) ToTaskSetNetworkConfigurationOutput 

func (o TaskSetNetworkConfigurationOutput) ToTaskSetNetworkConfigurationOutput() TaskSetNetworkConfigurationOutput

func (TaskSetNetworkConfigurationOutput) ToTaskSetNetworkConfigurationOutputWithContext 

func (o TaskSetNetworkConfigurationOutput) ToTaskSetNetworkConfigurationOutputWithContext(ctx context.Context) TaskSetNetworkConfigurationOutput

func (TaskSetNetworkConfigurationOutput) ToTaskSetNetworkConfigurationPtrOutput 

func (o TaskSetNetworkConfigurationOutput) ToTaskSetNetworkConfigurationPtrOutput() TaskSetNetworkConfigurationPtrOutput

func (TaskSetNetworkConfigurationOutput) ToTaskSetNetworkConfigurationPtrOutputWithContext 

func (o TaskSetNetworkConfigurationOutput) ToTaskSetNetworkConfigurationPtrOutputWithContext(ctx context.Context) TaskSetNetworkConfigurationPtrOutput

type TaskSetNetworkConfigurationPtrInput 

type TaskSetNetworkConfigurationPtrInput interface {
	pulumi.Input

	ToTaskSetNetworkConfigurationPtrOutput() TaskSetNetworkConfigurationPtrOutput
	ToTaskSetNetworkConfigurationPtrOutputWithContext(context.Context) TaskSetNetworkConfigurationPtrOutput
}

TaskSetNetworkConfigurationPtrInput is an input type that accepts TaskSetNetworkConfigurationArgs, TaskSetNetworkConfigurationPtr and TaskSetNetworkConfigurationPtrOutput values. You can construct a concrete instance of `TaskSetNetworkConfigurationPtrInput` via: 

        TaskSetNetworkConfigurationArgs{...}

or:

        nil

func TaskSetNetworkConfigurationPtr 

func TaskSetNetworkConfigurationPtr(v *TaskSetNetworkConfigurationArgs) TaskSetNetworkConfigurationPtrInput

type TaskSetNetworkConfigurationPtrOutput 

type TaskSetNetworkConfigurationPtrOutput struct{ *pulumi.OutputState }

func (TaskSetNetworkConfigurationPtrOutput) AwsVpcConfiguration 

func (o TaskSetNetworkConfigurationPtrOutput) AwsVpcConfiguration() TaskSetAwsVpcConfigurationPtrOutput

func (TaskSetNetworkConfigurationPtrOutput) Elem 

func (o TaskSetNetworkConfigurationPtrOutput) Elem() TaskSetNetworkConfigurationOutput

func (TaskSetNetworkConfigurationPtrOutput) ElementType 

func (TaskSetNetworkConfigurationPtrOutput) ElementType() reflect.Type

func (TaskSetNetworkConfigurationPtrOutput) ToTaskSetNetworkConfigurationPtrOutput 

func (o TaskSetNetworkConfigurationPtrOutput) ToTaskSetNetworkConfigurationPtrOutput() TaskSetNetworkConfigurationPtrOutput

func (TaskSetNetworkConfigurationPtrOutput) ToTaskSetNetworkConfigurationPtrOutputWithContext 

func (o TaskSetNetworkConfigurationPtrOutput) ToTaskSetNetworkConfigurationPtrOutputWithContext(ctx context.Context) TaskSetNetworkConfigurationPtrOutput

type TaskSetOutput 

type TaskSetOutput struct{ *pulumi.OutputState }

func (TaskSetOutput) AwsId added in v0.99.0 

func (o TaskSetOutput) AwsId() pulumi.StringOutput

The ID of the task set.

func (TaskSetOutput) Cluster added in v0.17.0 

func (o TaskSetOutput) Cluster() pulumi.StringOutput

The short name or full Amazon Resource Name (ARN) of the cluster that hosts the service to create the task set in.

func (TaskSetOutput) ElementType 

func (TaskSetOutput) ElementType() reflect.Type

func (TaskSetOutput) ExternalId added in v0.17.0 

func (o TaskSetOutput) ExternalId() pulumi.StringPtrOutput

An optional non-unique tag that identifies this task set in external systems. If the task set is associated with a service discovery registry, the tasks in this task set will have the ECS_TASK_SET_EXTERNAL_ID AWS Cloud Map attribute set to the provided value.

func (TaskSetOutput) LaunchType added in v0.17.0 

func (o TaskSetOutput) LaunchType() TaskSetLaunchTypePtrOutput

The launch type that new tasks in the task set will use. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html in the Amazon Elastic Container Service Developer Guide.

func (TaskSetOutput) LoadBalancers added in v0.17.0 

func (o TaskSetOutput) LoadBalancers() TaskSetLoadBalancerArrayOutput

func (TaskSetOutput) NetworkConfiguration added in v0.17.0 

func (o TaskSetOutput) NetworkConfiguration() TaskSetNetworkConfigurationPtrOutput

func (TaskSetOutput) PlatformVersion added in v0.17.0 

func (o TaskSetOutput) PlatformVersion() pulumi.StringPtrOutput

The platform version that the tasks in the task set should use. A platform version is specified only for tasks using the Fargate launch type. If one isn't specified, the LATEST platform version is used by default.

func (TaskSetOutput) Scale added in v0.17.0 

func (o TaskSetOutput) Scale() TaskSetScalePtrOutput

A floating-point percentage of the desired number of tasks to place and keep running in the task set.

func (TaskSetOutput) Service added in v0.17.0 

func (o TaskSetOutput) Service() pulumi.StringOutput

The short name or full Amazon Resource Name (ARN) of the service to create the task set in.

func (TaskSetOutput) ServiceRegistries added in v0.17.0 

func (o TaskSetOutput) ServiceRegistries() TaskSetServiceRegistryArrayOutput

The details of the service discovery registries to assign to this task set. For more information, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html.

func (TaskSetOutput) Tags added in v0.98.0 

func (o TaskSetOutput) Tags() aws.TagArrayOutput

func (TaskSetOutput) TaskDefinition added in v0.17.0 

func (o TaskSetOutput) TaskDefinition() pulumi.StringOutput

The short name or full Amazon Resource Name (ARN) of the task definition for the tasks in the task set to use.

func (TaskSetOutput) ToTaskSetOutput 

func (o TaskSetOutput) ToTaskSetOutput() TaskSetOutput

func (TaskSetOutput) ToTaskSetOutputWithContext 

func (o TaskSetOutput) ToTaskSetOutputWithContext(ctx context.Context) TaskSetOutput

type TaskSetScale 

type TaskSetScale struct {
	// The unit of measure for the scale value.
	Unit *TaskSetScaleUnit `pulumi:"unit"`
	// The value, specified as a percent total of a service's desiredCount, to scale the task set. Accepted values are numbers between 0 and 100.
	Value *float64 `pulumi:"value"`
}

type TaskSetScaleArgs 

type TaskSetScaleArgs struct {
	// The unit of measure for the scale value.
	Unit TaskSetScaleUnitPtrInput `pulumi:"unit"`
	// The value, specified as a percent total of a service's desiredCount, to scale the task set. Accepted values are numbers between 0 and 100.
	Value pulumi.Float64PtrInput `pulumi:"value"`
}

func (TaskSetScaleArgs) ElementType 

func (TaskSetScaleArgs) ElementType() reflect.Type

func (TaskSetScaleArgs) ToTaskSetScaleOutput 

func (i TaskSetScaleArgs) ToTaskSetScaleOutput() TaskSetScaleOutput

func (TaskSetScaleArgs) ToTaskSetScaleOutputWithContext 

func (i TaskSetScaleArgs) ToTaskSetScaleOutputWithContext(ctx context.Context) TaskSetScaleOutput

func (TaskSetScaleArgs) ToTaskSetScalePtrOutput 

func (i TaskSetScaleArgs) ToTaskSetScalePtrOutput() TaskSetScalePtrOutput

func (TaskSetScaleArgs) ToTaskSetScalePtrOutputWithContext 

func (i TaskSetScaleArgs) ToTaskSetScalePtrOutputWithContext(ctx context.Context) TaskSetScalePtrOutput

type TaskSetScaleInput 

type TaskSetScaleInput interface {
	pulumi.Input

	ToTaskSetScaleOutput() TaskSetScaleOutput
	ToTaskSetScaleOutputWithContext(context.Context) TaskSetScaleOutput
}

TaskSetScaleInput is an input type that accepts TaskSetScaleArgs and TaskSetScaleOutput values. You can construct a concrete instance of `TaskSetScaleInput` via: 

TaskSetScaleArgs{...}

type TaskSetScaleOutput 

type TaskSetScaleOutput struct{ *pulumi.OutputState }

func (TaskSetScaleOutput) ElementType 

func (TaskSetScaleOutput) ElementType() reflect.Type

func (TaskSetScaleOutput) ToTaskSetScaleOutput 

func (o TaskSetScaleOutput) ToTaskSetScaleOutput() TaskSetScaleOutput

func (TaskSetScaleOutput) ToTaskSetScaleOutputWithContext 

func (o TaskSetScaleOutput) ToTaskSetScaleOutputWithContext(ctx context.Context) TaskSetScaleOutput

func (TaskSetScaleOutput) ToTaskSetScalePtrOutput 

func (o TaskSetScaleOutput) ToTaskSetScalePtrOutput() TaskSetScalePtrOutput

func (TaskSetScaleOutput) ToTaskSetScalePtrOutputWithContext 

func (o TaskSetScaleOutput) ToTaskSetScalePtrOutputWithContext(ctx context.Context) TaskSetScalePtrOutput

func (TaskSetScaleOutput) Unit 

func (o TaskSetScaleOutput) Unit() TaskSetScaleUnitPtrOutput

The unit of measure for the scale value.

func (TaskSetScaleOutput) Value 

func (o TaskSetScaleOutput) Value() pulumi.Float64PtrOutput

The value, specified as a percent total of a service's desiredCount, to scale the task set. Accepted values are numbers between 0 and 100.

type TaskSetScalePtrInput 

type TaskSetScalePtrInput interface {
	pulumi.Input

	ToTaskSetScalePtrOutput() TaskSetScalePtrOutput
	ToTaskSetScalePtrOutputWithContext(context.Context) TaskSetScalePtrOutput
}

TaskSetScalePtrInput is an input type that accepts TaskSetScaleArgs, TaskSetScalePtr and TaskSetScalePtrOutput values. You can construct a concrete instance of `TaskSetScalePtrInput` via: 

        TaskSetScaleArgs{...}

or:

        nil

func TaskSetScalePtr 

func TaskSetScalePtr(v *TaskSetScaleArgs) TaskSetScalePtrInput

type TaskSetScalePtrOutput 

type TaskSetScalePtrOutput struct{ *pulumi.OutputState }

func (TaskSetScalePtrOutput) Elem 

func (o TaskSetScalePtrOutput) Elem() TaskSetScaleOutput

func (TaskSetScalePtrOutput) ElementType 

func (TaskSetScalePtrOutput) ElementType() reflect.Type

func (TaskSetScalePtrOutput) ToTaskSetScalePtrOutput 

func (o TaskSetScalePtrOutput) ToTaskSetScalePtrOutput() TaskSetScalePtrOutput

func (TaskSetScalePtrOutput) ToTaskSetScalePtrOutputWithContext 

func (o TaskSetScalePtrOutput) ToTaskSetScalePtrOutputWithContext(ctx context.Context) TaskSetScalePtrOutput

func (TaskSetScalePtrOutput) Unit 

func (o TaskSetScalePtrOutput) Unit() TaskSetScaleUnitPtrOutput

The unit of measure for the scale value.

func (TaskSetScalePtrOutput) Value 

func (o TaskSetScalePtrOutput) Value() pulumi.Float64PtrOutput

The value, specified as a percent total of a service's desiredCount, to scale the task set. Accepted values are numbers between 0 and 100.

type TaskSetScaleUnit 

type TaskSetScaleUnit string

The unit of measure for the scale value.

func (TaskSetScaleUnit) ElementType 

func (TaskSetScaleUnit) ElementType() reflect.Type

func (TaskSetScaleUnit) ToStringOutput 

func (e TaskSetScaleUnit) ToStringOutput() pulumi.StringOutput

func (TaskSetScaleUnit) ToStringOutputWithContext 

func (e TaskSetScaleUnit) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskSetScaleUnit) ToStringPtrOutput 

func (e TaskSetScaleUnit) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetScaleUnit) ToStringPtrOutputWithContext 

func (e TaskSetScaleUnit) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetScaleUnit) ToTaskSetScaleUnitOutput 

func (e TaskSetScaleUnit) ToTaskSetScaleUnitOutput() TaskSetScaleUnitOutput

func (TaskSetScaleUnit) ToTaskSetScaleUnitOutputWithContext 

func (e TaskSetScaleUnit) ToTaskSetScaleUnitOutputWithContext(ctx context.Context) TaskSetScaleUnitOutput

func (TaskSetScaleUnit) ToTaskSetScaleUnitPtrOutput 

func (e TaskSetScaleUnit) ToTaskSetScaleUnitPtrOutput() TaskSetScaleUnitPtrOutput

func (TaskSetScaleUnit) ToTaskSetScaleUnitPtrOutputWithContext 

func (e TaskSetScaleUnit) ToTaskSetScaleUnitPtrOutputWithContext(ctx context.Context) TaskSetScaleUnitPtrOutput

type TaskSetScaleUnitInput 

type TaskSetScaleUnitInput interface {
	pulumi.Input

	ToTaskSetScaleUnitOutput() TaskSetScaleUnitOutput
	ToTaskSetScaleUnitOutputWithContext(context.Context) TaskSetScaleUnitOutput
}

TaskSetScaleUnitInput is an input type that accepts values of the TaskSetScaleUnit enum A concrete instance of `TaskSetScaleUnitInput` can be one of the following: 

TaskSetScaleUnitPercent

type TaskSetScaleUnitOutput 

type TaskSetScaleUnitOutput struct{ *pulumi.OutputState }

func (TaskSetScaleUnitOutput) ElementType 

func (TaskSetScaleUnitOutput) ElementType() reflect.Type

func (TaskSetScaleUnitOutput) ToStringOutput 

func (o TaskSetScaleUnitOutput) ToStringOutput() pulumi.StringOutput

func (TaskSetScaleUnitOutput) ToStringOutputWithContext 

func (o TaskSetScaleUnitOutput) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

func (TaskSetScaleUnitOutput) ToStringPtrOutput 

func (o TaskSetScaleUnitOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetScaleUnitOutput) ToStringPtrOutputWithContext 

func (o TaskSetScaleUnitOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetScaleUnitOutput) ToTaskSetScaleUnitOutput 

func (o TaskSetScaleUnitOutput) ToTaskSetScaleUnitOutput() TaskSetScaleUnitOutput

func (TaskSetScaleUnitOutput) ToTaskSetScaleUnitOutputWithContext 

func (o TaskSetScaleUnitOutput) ToTaskSetScaleUnitOutputWithContext(ctx context.Context) TaskSetScaleUnitOutput

func (TaskSetScaleUnitOutput) ToTaskSetScaleUnitPtrOutput 

func (o TaskSetScaleUnitOutput) ToTaskSetScaleUnitPtrOutput() TaskSetScaleUnitPtrOutput

func (TaskSetScaleUnitOutput) ToTaskSetScaleUnitPtrOutputWithContext 

func (o TaskSetScaleUnitOutput) ToTaskSetScaleUnitPtrOutputWithContext(ctx context.Context) TaskSetScaleUnitPtrOutput

type TaskSetScaleUnitPtrInput 

type TaskSetScaleUnitPtrInput interface {
	pulumi.Input

	ToTaskSetScaleUnitPtrOutput() TaskSetScaleUnitPtrOutput
	ToTaskSetScaleUnitPtrOutputWithContext(context.Context) TaskSetScaleUnitPtrOutput
}

func TaskSetScaleUnitPtr 

func TaskSetScaleUnitPtr(v string) TaskSetScaleUnitPtrInput

type TaskSetScaleUnitPtrOutput 

type TaskSetScaleUnitPtrOutput struct{ *pulumi.OutputState }

func (TaskSetScaleUnitPtrOutput) Elem 

func (o TaskSetScaleUnitPtrOutput) Elem() TaskSetScaleUnitOutput

func (TaskSetScaleUnitPtrOutput) ElementType 

func (TaskSetScaleUnitPtrOutput) ElementType() reflect.Type

func (TaskSetScaleUnitPtrOutput) ToStringPtrOutput 

func (o TaskSetScaleUnitPtrOutput) ToStringPtrOutput() pulumi.StringPtrOutput

func (TaskSetScaleUnitPtrOutput) ToStringPtrOutputWithContext 

func (o TaskSetScaleUnitPtrOutput) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

func (TaskSetScaleUnitPtrOutput) ToTaskSetScaleUnitPtrOutput 

func (o TaskSetScaleUnitPtrOutput) ToTaskSetScaleUnitPtrOutput() TaskSetScaleUnitPtrOutput

func (TaskSetScaleUnitPtrOutput) ToTaskSetScaleUnitPtrOutputWithContext 

func (o TaskSetScaleUnitPtrOutput) ToTaskSetScaleUnitPtrOutputWithContext(ctx context.Context) TaskSetScaleUnitPtrOutput

type TaskSetServiceRegistry 

type TaskSetServiceRegistry struct {
	// The container name value, already specified in the task definition, to be used for your service discovery service. If the task definition that your service task specifies uses the bridge or host network mode, you must specify a containerName and containerPort combination from the task definition. If the task definition that your service task specifies uses the awsvpc network mode and a type SRV DNS record is used, you must specify either a containerName and containerPort combination or a port value, but not both.
	ContainerName *string `pulumi:"containerName"`
	// The port value, already specified in the task definition, to be used for your service discovery service. If the task definition your service task specifies uses the bridge or host network mode, you must specify a containerName and containerPort combination from the task definition. If the task definition your service task specifies uses the awsvpc network mode and a type SRV DNS record is used, you must specify either a containerName and containerPort combination or a port value, but not both.
	ContainerPort *int `pulumi:"containerPort"`
	// The port value used if your service discovery service specified an SRV record. This field may be used if both the awsvpc network mode and SRV records are used.
	Port *int `pulumi:"port"`
	// The Amazon Resource Name (ARN) of the service registry. The currently supported service registry is AWS Cloud Map. For more information, see https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html
	RegistryArn *string `pulumi:"registryArn"`
}

type TaskSetServiceRegistryArgs 

type TaskSetServiceRegistryArgs struct {
	// The container name value, already specified in the task definition, to be used for your service discovery service. If the task definition that your service task specifies uses the bridge or host network mode, you must specify a containerName and containerPort combination from the task definition. If the task definition that your service task specifies uses the awsvpc network mode and a type SRV DNS record is used, you must specify either a containerName and containerPort combination or a port value, but not both.
	ContainerName pulumi.StringPtrInput `pulumi:"containerName"`
	// The port value, already specified in the task definition, to be used for your service discovery service. If the task definition your service task specifies uses the bridge or host network mode, you must specify a containerName and containerPort combination from the task definition. If the task definition your service task specifies uses the awsvpc network mode and a type SRV DNS record is used, you must specify either a containerName and containerPort combination or a port value, but not both.
	ContainerPort pulumi.IntPtrInput `pulumi:"containerPort"`
	// The port value used if your service discovery service specified an SRV record. This field may be used if both the awsvpc network mode and SRV records are used.
	Port pulumi.IntPtrInput `pulumi:"port"`
	// The Amazon Resource Name (ARN) of the service registry. The currently supported service registry is AWS Cloud Map. For more information, see https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html
	RegistryArn pulumi.StringPtrInput `pulumi:"registryArn"`
}

func (TaskSetServiceRegistryArgs) ElementType 

func (TaskSetServiceRegistryArgs) ElementType() reflect.Type

func (TaskSetServiceRegistryArgs) ToTaskSetServiceRegistryOutput 

func (i TaskSetServiceRegistryArgs) ToTaskSetServiceRegistryOutput() TaskSetServiceRegistryOutput

func (TaskSetServiceRegistryArgs) ToTaskSetServiceRegistryOutputWithContext 

func (i TaskSetServiceRegistryArgs) ToTaskSetServiceRegistryOutputWithContext(ctx context.Context) TaskSetServiceRegistryOutput

type TaskSetServiceRegistryArray 

type TaskSetServiceRegistryArray []TaskSetServiceRegistryInput

func (TaskSetServiceRegistryArray) ElementType 

func (TaskSetServiceRegistryArray) ElementType() reflect.Type

func (TaskSetServiceRegistryArray) ToTaskSetServiceRegistryArrayOutput 

func (i TaskSetServiceRegistryArray) ToTaskSetServiceRegistryArrayOutput() TaskSetServiceRegistryArrayOutput

func (TaskSetServiceRegistryArray) ToTaskSetServiceRegistryArrayOutputWithContext 

func (i TaskSetServiceRegistryArray) ToTaskSetServiceRegistryArrayOutputWithContext(ctx context.Context) TaskSetServiceRegistryArrayOutput

type TaskSetServiceRegistryArrayInput 

type TaskSetServiceRegistryArrayInput interface {
	pulumi.Input

	ToTaskSetServiceRegistryArrayOutput() TaskSetServiceRegistryArrayOutput
	ToTaskSetServiceRegistryArrayOutputWithContext(context.Context) TaskSetServiceRegistryArrayOutput
}

TaskSetServiceRegistryArrayInput is an input type that accepts TaskSetServiceRegistryArray and TaskSetServiceRegistryArrayOutput values. You can construct a concrete instance of `TaskSetServiceRegistryArrayInput` via: 

TaskSetServiceRegistryArray{ TaskSetServiceRegistryArgs{...} }

type TaskSetServiceRegistryArrayOutput 

type TaskSetServiceRegistryArrayOutput struct{ *pulumi.OutputState }

func (TaskSetServiceRegistryArrayOutput) ElementType 

func (TaskSetServiceRegistryArrayOutput) ElementType() reflect.Type

func (TaskSetServiceRegistryArrayOutput) Index 

func (o TaskSetServiceRegistryArrayOutput) Index(i pulumi.IntInput) TaskSetServiceRegistryOutput

func (TaskSetServiceRegistryArrayOutput) ToTaskSetServiceRegistryArrayOutput 

func (o TaskSetServiceRegistryArrayOutput) ToTaskSetServiceRegistryArrayOutput() TaskSetServiceRegistryArrayOutput

func (TaskSetServiceRegistryArrayOutput) ToTaskSetServiceRegistryArrayOutputWithContext 

func (o TaskSetServiceRegistryArrayOutput) ToTaskSetServiceRegistryArrayOutputWithContext(ctx context.Context) TaskSetServiceRegistryArrayOutput

type TaskSetServiceRegistryInput 

type TaskSetServiceRegistryInput interface {
	pulumi.Input

	ToTaskSetServiceRegistryOutput() TaskSetServiceRegistryOutput
	ToTaskSetServiceRegistryOutputWithContext(context.Context) TaskSetServiceRegistryOutput
}

TaskSetServiceRegistryInput is an input type that accepts TaskSetServiceRegistryArgs and TaskSetServiceRegistryOutput values. You can construct a concrete instance of `TaskSetServiceRegistryInput` via: 

TaskSetServiceRegistryArgs{...}

type TaskSetServiceRegistryOutput 

type TaskSetServiceRegistryOutput struct{ *pulumi.OutputState }

func (TaskSetServiceRegistryOutput) ContainerName 

func (o TaskSetServiceRegistryOutput) ContainerName() pulumi.StringPtrOutput

The container name value, already specified in the task definition, to be used for your service discovery service. If the task definition that your service task specifies uses the bridge or host network mode, you must specify a containerName and containerPort combination from the task definition. If the task definition that your service task specifies uses the awsvpc network mode and a type SRV DNS record is used, you must specify either a containerName and containerPort combination or a port value, but not both.

func (TaskSetServiceRegistryOutput) ContainerPort 

func (o TaskSetServiceRegistryOutput) ContainerPort() pulumi.IntPtrOutput

The port value, already specified in the task definition, to be used for your service discovery service. If the task definition your service task specifies uses the bridge or host network mode, you must specify a containerName and containerPort combination from the task definition. If the task definition your service task specifies uses the awsvpc network mode and a type SRV DNS record is used, you must specify either a containerName and containerPort combination or a port value, but not both.

func (TaskSetServiceRegistryOutput) ElementType 

func (TaskSetServiceRegistryOutput) ElementType() reflect.Type

func (TaskSetServiceRegistryOutput) Port 

func (o TaskSetServiceRegistryOutput) Port() pulumi.IntPtrOutput

The port value used if your service discovery service specified an SRV record. This field may be used if both the awsvpc network mode and SRV records are used.

func (TaskSetServiceRegistryOutput) RegistryArn 

func (o TaskSetServiceRegistryOutput) RegistryArn() pulumi.StringPtrOutput

The Amazon Resource Name (ARN) of the service registry. The currently supported service registry is AWS Cloud Map. For more information, see https://docs.aws.amazon.com/cloud-map/latest/api/API_CreateService.html

func (TaskSetServiceRegistryOutput) ToTaskSetServiceRegistryOutput 

func (o TaskSetServiceRegistryOutput) ToTaskSetServiceRegistryOutput() TaskSetServiceRegistryOutput

func (TaskSetServiceRegistryOutput) ToTaskSetServiceRegistryOutputWithContext 

func (o TaskSetServiceRegistryOutput) ToTaskSetServiceRegistryOutputWithContext(ctx context.Context) TaskSetServiceRegistryOutput

type TaskSetState 

type TaskSetState struct {
}

func (TaskSetState) ElementType 

func (TaskSetState) ElementType() reflect.Type

type TaskSetTag added in v0.98.0 

type TaskSetTag struct {
	Key   *string `pulumi:"key"`
	Value *string `pulumi:"value"`
}

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.