1. Packages
  2. AWS Classic
  3. API Docs
  4. ecs
  5. TaskDefinition

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

aws.ecs.TaskDefinition

Explore with Pulumi AI

aws logo

Try AWS Native preview for resources not in the classic version.

AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi

    Manages a revision of an ECS task definition to be used in aws.ecs.Service.

    Example Usage

    Basic Example

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const service = new aws.ecs.TaskDefinition("service", {
        family: "service",
        containerDefinitions: JSON.stringify([
            {
                name: "first",
                image: "service-first",
                cpu: 10,
                memory: 512,
                essential: true,
                portMappings: [{
                    containerPort: 80,
                    hostPort: 80,
                }],
            },
            {
                name: "second",
                image: "service-second",
                cpu: 10,
                memory: 256,
                essential: true,
                portMappings: [{
                    containerPort: 443,
                    hostPort: 443,
                }],
            },
        ]),
        volumes: [{
            name: "service-storage",
            hostPath: "/ecs/service-storage",
        }],
        placementConstraints: [{
            type: "memberOf",
            expression: "attribute:ecs.availability-zone in [us-west-2a, us-west-2b]",
        }],
    });
    
    import pulumi
    import json
    import pulumi_aws as aws
    
    service = aws.ecs.TaskDefinition("service",
        family="service",
        container_definitions=json.dumps([
            {
                "name": "first",
                "image": "service-first",
                "cpu": 10,
                "memory": 512,
                "essential": True,
                "portMappings": [{
                    "containerPort": 80,
                    "hostPort": 80,
                }],
            },
            {
                "name": "second",
                "image": "service-second",
                "cpu": 10,
                "memory": 256,
                "essential": True,
                "portMappings": [{
                    "containerPort": 443,
                    "hostPort": 443,
                }],
            },
        ]),
        volumes=[aws.ecs.TaskDefinitionVolumeArgs(
            name="service-storage",
            host_path="/ecs/service-storage",
        )],
        placement_constraints=[aws.ecs.TaskDefinitionPlacementConstraintArgs(
            type="memberOf",
            expression="attribute:ecs.availability-zone in [us-west-2a, us-west-2b]",
        )])
    
    package main
    
    import (
    	"encoding/json"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ecs"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		tmpJSON0, err := json.Marshal([]interface{}{
    			map[string]interface{}{
    				"name":      "first",
    				"image":     "service-first",
    				"cpu":       10,
    				"memory":    512,
    				"essential": true,
    				"portMappings": []map[string]interface{}{
    					map[string]interface{}{
    						"containerPort": 80,
    						"hostPort":      80,
    					},
    				},
    			},
    			map[string]interface{}{
    				"name":      "second",
    				"image":     "service-second",
    				"cpu":       10,
    				"memory":    256,
    				"essential": true,
    				"portMappings": []map[string]interface{}{
    					map[string]interface{}{
    						"containerPort": 443,
    						"hostPort":      443,
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		json0 := string(tmpJSON0)
    		_, err = ecs.NewTaskDefinition(ctx, "service", &ecs.TaskDefinitionArgs{
    			Family:               pulumi.String("service"),
    			ContainerDefinitions: pulumi.String(json0),
    			Volumes: ecs.TaskDefinitionVolumeArray{
    				&ecs.TaskDefinitionVolumeArgs{
    					Name:     pulumi.String("service-storage"),
    					HostPath: pulumi.String("/ecs/service-storage"),
    				},
    			},
    			PlacementConstraints: ecs.TaskDefinitionPlacementConstraintArray{
    				&ecs.TaskDefinitionPlacementConstraintArgs{
    					Type:       pulumi.String("memberOf"),
    					Expression: pulumi.String("attribute:ecs.availability-zone in [us-west-2a, us-west-2b]"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using System.Text.Json;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var service = new Aws.Ecs.TaskDefinition("service", new()
        {
            Family = "service",
            ContainerDefinitions = JsonSerializer.Serialize(new[]
            {
                new Dictionary<string, object?>
                {
                    ["name"] = "first",
                    ["image"] = "service-first",
                    ["cpu"] = 10,
                    ["memory"] = 512,
                    ["essential"] = true,
                    ["portMappings"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["containerPort"] = 80,
                            ["hostPort"] = 80,
                        },
                    },
                },
                new Dictionary<string, object?>
                {
                    ["name"] = "second",
                    ["image"] = "service-second",
                    ["cpu"] = 10,
                    ["memory"] = 256,
                    ["essential"] = true,
                    ["portMappings"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["containerPort"] = 443,
                            ["hostPort"] = 443,
                        },
                    },
                },
            }),
            Volumes = new[]
            {
                new Aws.Ecs.Inputs.TaskDefinitionVolumeArgs
                {
                    Name = "service-storage",
                    HostPath = "/ecs/service-storage",
                },
            },
            PlacementConstraints = new[]
            {
                new Aws.Ecs.Inputs.TaskDefinitionPlacementConstraintArgs
                {
                    Type = "memberOf",
                    Expression = "attribute:ecs.availability-zone in [us-west-2a, us-west-2b]",
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.ecs.TaskDefinition;
    import com.pulumi.aws.ecs.TaskDefinitionArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionPlacementConstraintArgs;
    import static com.pulumi.codegen.internal.Serialization.*;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var service = new TaskDefinition("service", TaskDefinitionArgs.builder()
                .family("service")
                .containerDefinitions(serializeJson(
                    jsonArray(
                        jsonObject(
                            jsonProperty("name", "first"),
                            jsonProperty("image", "service-first"),
                            jsonProperty("cpu", 10),
                            jsonProperty("memory", 512),
                            jsonProperty("essential", true),
                            jsonProperty("portMappings", jsonArray(jsonObject(
                                jsonProperty("containerPort", 80),
                                jsonProperty("hostPort", 80)
                            )))
                        ), 
                        jsonObject(
                            jsonProperty("name", "second"),
                            jsonProperty("image", "service-second"),
                            jsonProperty("cpu", 10),
                            jsonProperty("memory", 256),
                            jsonProperty("essential", true),
                            jsonProperty("portMappings", jsonArray(jsonObject(
                                jsonProperty("containerPort", 443),
                                jsonProperty("hostPort", 443)
                            )))
                        )
                    )))
                .volumes(TaskDefinitionVolumeArgs.builder()
                    .name("service-storage")
                    .hostPath("/ecs/service-storage")
                    .build())
                .placementConstraints(TaskDefinitionPlacementConstraintArgs.builder()
                    .type("memberOf")
                    .expression("attribute:ecs.availability-zone in [us-west-2a, us-west-2b]")
                    .build())
                .build());
    
        }
    }
    
    resources:
      service:
        type: aws:ecs:TaskDefinition
        properties:
          family: service
          containerDefinitions:
            fn::toJSON:
              - name: first
                image: service-first
                cpu: 10
                memory: 512
                essential: true
                portMappings:
                  - containerPort: 80
                    hostPort: 80
              - name: second
                image: service-second
                cpu: 10
                memory: 256
                essential: true
                portMappings:
                  - containerPort: 443
                    hostPort: 443
          volumes:
            - name: service-storage
              hostPath: /ecs/service-storage
          placementConstraints:
            - type: memberOf
              expression: attribute:ecs.availability-zone in [us-west-2a, us-west-2b]
    

    With AppMesh Proxy

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    import * as std from "@pulumi/std";
    
    const service = new aws.ecs.TaskDefinition("service", {
        family: "service",
        containerDefinitions: std.file({
            input: "task-definitions/service.json",
        }).then(invoke => invoke.result),
        proxyConfiguration: {
            type: "APPMESH",
            containerName: "applicationContainerName",
            properties: {
                AppPorts: "8080",
                EgressIgnoredIPs: "169.254.170.2,169.254.169.254",
                IgnoredUID: "1337",
                ProxyEgressPort: "15001",
                ProxyIngressPort: "15000",
            },
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    import pulumi_std as std
    
    service = aws.ecs.TaskDefinition("service",
        family="service",
        container_definitions=std.file(input="task-definitions/service.json").result,
        proxy_configuration=aws.ecs.TaskDefinitionProxyConfigurationArgs(
            type="APPMESH",
            container_name="applicationContainerName",
            properties={
                "AppPorts": "8080",
                "EgressIgnoredIPs": "169.254.170.2,169.254.169.254",
                "IgnoredUID": "1337",
                "ProxyEgressPort": "15001",
                "ProxyIngressPort": "15000",
            },
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ecs"
    	"github.com/pulumi/pulumi-std/sdk/go/std"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		invokeFile, err := std.File(ctx, &std.FileArgs{
    			Input: "task-definitions/service.json",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = ecs.NewTaskDefinition(ctx, "service", &ecs.TaskDefinitionArgs{
    			Family:               pulumi.String("service"),
    			ContainerDefinitions: invokeFile.Result,
    			ProxyConfiguration: &ecs.TaskDefinitionProxyConfigurationArgs{
    				Type:          pulumi.String("APPMESH"),
    				ContainerName: pulumi.String("applicationContainerName"),
    				Properties: pulumi.StringMap{
    					"AppPorts":         pulumi.String("8080"),
    					"EgressIgnoredIPs": pulumi.String("169.254.170.2,169.254.169.254"),
    					"IgnoredUID":       pulumi.String("1337"),
    					"ProxyEgressPort":  pulumi.String("15001"),
    					"ProxyIngressPort": pulumi.String("15000"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    using Std = Pulumi.Std;
    
    return await Deployment.RunAsync(() => 
    {
        var service = new Aws.Ecs.TaskDefinition("service", new()
        {
            Family = "service",
            ContainerDefinitions = Std.File.Invoke(new()
            {
                Input = "task-definitions/service.json",
            }).Apply(invoke => invoke.Result),
            ProxyConfiguration = new Aws.Ecs.Inputs.TaskDefinitionProxyConfigurationArgs
            {
                Type = "APPMESH",
                ContainerName = "applicationContainerName",
                Properties = 
                {
                    { "AppPorts", "8080" },
                    { "EgressIgnoredIPs", "169.254.170.2,169.254.169.254" },
                    { "IgnoredUID", "1337" },
                    { "ProxyEgressPort", "15001" },
                    { "ProxyIngressPort", "15000" },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.ecs.TaskDefinition;
    import com.pulumi.aws.ecs.TaskDefinitionArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionProxyConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var service = new TaskDefinition("service", TaskDefinitionArgs.builder()
                .family("service")
                .containerDefinitions(StdFunctions.file(FileArgs.builder()
                    .input("task-definitions/service.json")
                    .build()).result())
                .proxyConfiguration(TaskDefinitionProxyConfigurationArgs.builder()
                    .type("APPMESH")
                    .containerName("applicationContainerName")
                    .properties(Map.ofEntries(
                        Map.entry("AppPorts", "8080"),
                        Map.entry("EgressIgnoredIPs", "169.254.170.2,169.254.169.254"),
                        Map.entry("IgnoredUID", "1337"),
                        Map.entry("ProxyEgressPort", 15001),
                        Map.entry("ProxyIngressPort", 15000)
                    ))
                    .build())
                .build());
    
        }
    }
    
    resources:
      service:
        type: aws:ecs:TaskDefinition
        properties:
          family: service
          containerDefinitions:
            fn::invoke:
              Function: std:file
              Arguments:
                input: task-definitions/service.json
              Return: result
          proxyConfiguration:
            type: APPMESH
            containerName: applicationContainerName
            properties:
              AppPorts: '8080'
              EgressIgnoredIPs: 169.254.170.2,169.254.169.254
              IgnoredUID: '1337'
              ProxyEgressPort: 15001
              ProxyIngressPort: 15000
    

    Example Using docker_volume_configuration

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    import * as std from "@pulumi/std";
    
    const service = new aws.ecs.TaskDefinition("service", {
        family: "service",
        containerDefinitions: std.file({
            input: "task-definitions/service.json",
        }).then(invoke => invoke.result),
        volumes: [{
            name: "service-storage",
            dockerVolumeConfiguration: {
                scope: "shared",
                autoprovision: true,
                driver: "local",
                driverOpts: {
                    type: "nfs",
                    device: `${fs.dnsName}:/`,
                    o: `addr=${fs.dnsName},rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport`,
                },
            },
        }],
    });
    
    import pulumi
    import pulumi_aws as aws
    import pulumi_std as std
    
    service = aws.ecs.TaskDefinition("service",
        family="service",
        container_definitions=std.file(input="task-definitions/service.json").result,
        volumes=[aws.ecs.TaskDefinitionVolumeArgs(
            name="service-storage",
            docker_volume_configuration=aws.ecs.TaskDefinitionVolumeDockerVolumeConfigurationArgs(
                scope="shared",
                autoprovision=True,
                driver="local",
                driver_opts={
                    "type": "nfs",
                    "device": f"{fs['dnsName']}:/",
                    "o": f"addr={fs['dnsName']},rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport",
                },
            ),
        )])
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ecs"
    	"github.com/pulumi/pulumi-std/sdk/go/std"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		invokeFile, err := std.File(ctx, &std.FileArgs{
    			Input: "task-definitions/service.json",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = ecs.NewTaskDefinition(ctx, "service", &ecs.TaskDefinitionArgs{
    			Family:               pulumi.String("service"),
    			ContainerDefinitions: invokeFile.Result,
    			Volumes: ecs.TaskDefinitionVolumeArray{
    				&ecs.TaskDefinitionVolumeArgs{
    					Name: pulumi.String("service-storage"),
    					DockerVolumeConfiguration: &ecs.TaskDefinitionVolumeDockerVolumeConfigurationArgs{
    						Scope:         pulumi.String("shared"),
    						Autoprovision: pulumi.Bool(true),
    						Driver:        pulumi.String("local"),
    						DriverOpts: pulumi.StringMap{
    							"type":   pulumi.String("nfs"),
    							"device": pulumi.String(fmt.Sprintf("%v:/", fs.DnsName)),
    							"o":      pulumi.String(fmt.Sprintf("addr=%v,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport", fs.DnsName)),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    using Std = Pulumi.Std;
    
    return await Deployment.RunAsync(() => 
    {
        var service = new Aws.Ecs.TaskDefinition("service", new()
        {
            Family = "service",
            ContainerDefinitions = Std.File.Invoke(new()
            {
                Input = "task-definitions/service.json",
            }).Apply(invoke => invoke.Result),
            Volumes = new[]
            {
                new Aws.Ecs.Inputs.TaskDefinitionVolumeArgs
                {
                    Name = "service-storage",
                    DockerVolumeConfiguration = new Aws.Ecs.Inputs.TaskDefinitionVolumeDockerVolumeConfigurationArgs
                    {
                        Scope = "shared",
                        Autoprovision = true,
                        Driver = "local",
                        DriverOpts = 
                        {
                            { "type", "nfs" },
                            { "device", $"{fs.DnsName}:/" },
                            { "o", $"addr={fs.DnsName},rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport" },
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.ecs.TaskDefinition;
    import com.pulumi.aws.ecs.TaskDefinitionArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeDockerVolumeConfigurationArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var service = new TaskDefinition("service", TaskDefinitionArgs.builder()
                .family("service")
                .containerDefinitions(StdFunctions.file(FileArgs.builder()
                    .input("task-definitions/service.json")
                    .build()).result())
                .volumes(TaskDefinitionVolumeArgs.builder()
                    .name("service-storage")
                    .dockerVolumeConfiguration(TaskDefinitionVolumeDockerVolumeConfigurationArgs.builder()
                        .scope("shared")
                        .autoprovision(true)
                        .driver("local")
                        .driverOpts(Map.ofEntries(
                            Map.entry("type", "nfs"),
                            Map.entry("device", String.format("%s:/", fs.dnsName())),
                            Map.entry("o", String.format("addr=%s,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport", fs.dnsName()))
                        ))
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      service:
        type: aws:ecs:TaskDefinition
        properties:
          family: service
          containerDefinitions:
            fn::invoke:
              Function: std:file
              Arguments:
                input: task-definitions/service.json
              Return: result
          volumes:
            - name: service-storage
              dockerVolumeConfiguration:
                scope: shared
                autoprovision: true
                driver: local
                driverOpts:
                  type: nfs
                  device: ${fs.dnsName}:/
                  o: addr=${fs.dnsName},rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2,noresvport
    

    Example Using efs_volume_configuration

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    import * as std from "@pulumi/std";
    
    const service = new aws.ecs.TaskDefinition("service", {
        family: "service",
        containerDefinitions: std.file({
            input: "task-definitions/service.json",
        }).then(invoke => invoke.result),
        volumes: [{
            name: "service-storage",
            efsVolumeConfiguration: {
                fileSystemId: fs.id,
                rootDirectory: "/opt/data",
                transitEncryption: "ENABLED",
                transitEncryptionPort: 2999,
                authorizationConfig: {
                    accessPointId: test.id,
                    iam: "ENABLED",
                },
            },
        }],
    });
    
    import pulumi
    import pulumi_aws as aws
    import pulumi_std as std
    
    service = aws.ecs.TaskDefinition("service",
        family="service",
        container_definitions=std.file(input="task-definitions/service.json").result,
        volumes=[aws.ecs.TaskDefinitionVolumeArgs(
            name="service-storage",
            efs_volume_configuration=aws.ecs.TaskDefinitionVolumeEfsVolumeConfigurationArgs(
                file_system_id=fs["id"],
                root_directory="/opt/data",
                transit_encryption="ENABLED",
                transit_encryption_port=2999,
                authorization_config=aws.ecs.TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs(
                    access_point_id=test["id"],
                    iam="ENABLED",
                ),
            ),
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ecs"
    	"github.com/pulumi/pulumi-std/sdk/go/std"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		invokeFile, err := std.File(ctx, &std.FileArgs{
    			Input: "task-definitions/service.json",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = ecs.NewTaskDefinition(ctx, "service", &ecs.TaskDefinitionArgs{
    			Family:               pulumi.String("service"),
    			ContainerDefinitions: invokeFile.Result,
    			Volumes: ecs.TaskDefinitionVolumeArray{
    				&ecs.TaskDefinitionVolumeArgs{
    					Name: pulumi.String("service-storage"),
    					EfsVolumeConfiguration: &ecs.TaskDefinitionVolumeEfsVolumeConfigurationArgs{
    						FileSystemId:          pulumi.Any(fs.Id),
    						RootDirectory:         pulumi.String("/opt/data"),
    						TransitEncryption:     pulumi.String("ENABLED"),
    						TransitEncryptionPort: pulumi.Int(2999),
    						AuthorizationConfig: &ecs.TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs{
    							AccessPointId: pulumi.Any(test.Id),
    							Iam:           pulumi.String("ENABLED"),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    using Std = Pulumi.Std;
    
    return await Deployment.RunAsync(() => 
    {
        var service = new Aws.Ecs.TaskDefinition("service", new()
        {
            Family = "service",
            ContainerDefinitions = Std.File.Invoke(new()
            {
                Input = "task-definitions/service.json",
            }).Apply(invoke => invoke.Result),
            Volumes = new[]
            {
                new Aws.Ecs.Inputs.TaskDefinitionVolumeArgs
                {
                    Name = "service-storage",
                    EfsVolumeConfiguration = new Aws.Ecs.Inputs.TaskDefinitionVolumeEfsVolumeConfigurationArgs
                    {
                        FileSystemId = fs.Id,
                        RootDirectory = "/opt/data",
                        TransitEncryption = "ENABLED",
                        TransitEncryptionPort = 2999,
                        AuthorizationConfig = new Aws.Ecs.Inputs.TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs
                        {
                            AccessPointId = test.Id,
                            Iam = "ENABLED",
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.ecs.TaskDefinition;
    import com.pulumi.aws.ecs.TaskDefinitionArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeEfsVolumeConfigurationArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var service = new TaskDefinition("service", TaskDefinitionArgs.builder()
                .family("service")
                .containerDefinitions(StdFunctions.file(FileArgs.builder()
                    .input("task-definitions/service.json")
                    .build()).result())
                .volumes(TaskDefinitionVolumeArgs.builder()
                    .name("service-storage")
                    .efsVolumeConfiguration(TaskDefinitionVolumeEfsVolumeConfigurationArgs.builder()
                        .fileSystemId(fs.id())
                        .rootDirectory("/opt/data")
                        .transitEncryption("ENABLED")
                        .transitEncryptionPort(2999)
                        .authorizationConfig(TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs.builder()
                            .accessPointId(test.id())
                            .iam("ENABLED")
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      service:
        type: aws:ecs:TaskDefinition
        properties:
          family: service
          containerDefinitions:
            fn::invoke:
              Function: std:file
              Arguments:
                input: task-definitions/service.json
              Return: result
          volumes:
            - name: service-storage
              efsVolumeConfiguration:
                fileSystemId: ${fs.id}
                rootDirectory: /opt/data
                transitEncryption: ENABLED
                transitEncryptionPort: 2999
                authorizationConfig:
                  accessPointId: ${test.id}
                  iam: ENABLED
    

    Example Using fsx_windows_file_server_volume_configuration

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    import * as std from "@pulumi/std";
    
    const test = new aws.secretsmanager.SecretVersion("test", {
        secretId: testAwsSecretsmanagerSecret.id,
        secretString: JSON.stringify({
            username: "admin",
            password: testAwsDirectoryServiceDirectory.password,
        }),
    });
    const service = new aws.ecs.TaskDefinition("service", {
        family: "service",
        containerDefinitions: std.file({
            input: "task-definitions/service.json",
        }).then(invoke => invoke.result),
        volumes: [{
            name: "service-storage",
            fsxWindowsFileServerVolumeConfiguration: {
                fileSystemId: testAwsFsxWindowsFileSystem.id,
                rootDirectory: "\\data",
                authorizationConfig: {
                    credentialsParameter: test.arn,
                    domain: testAwsDirectoryServiceDirectory.name,
                },
            },
        }],
    });
    
    import pulumi
    import json
    import pulumi_aws as aws
    import pulumi_std as std
    
    test = aws.secretsmanager.SecretVersion("test",
        secret_id=test_aws_secretsmanager_secret["id"],
        secret_string=json.dumps({
            "username": "admin",
            "password": test_aws_directory_service_directory["password"],
        }))
    service = aws.ecs.TaskDefinition("service",
        family="service",
        container_definitions=std.file(input="task-definitions/service.json").result,
        volumes=[aws.ecs.TaskDefinitionVolumeArgs(
            name="service-storage",
            fsx_windows_file_server_volume_configuration=aws.ecs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs(
                file_system_id=test_aws_fsx_windows_file_system["id"],
                root_directory="\\data",
                authorization_config=aws.ecs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs(
                    credentials_parameter=test.arn,
                    domain=test_aws_directory_service_directory["name"],
                ),
            ),
        )])
    
    package main
    
    import (
    	"encoding/json"
    
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ecs"
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/secretsmanager"
    	"github.com/pulumi/pulumi-std/sdk/go/std"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		tmpJSON0, err := json.Marshal(map[string]interface{}{
    			"username": "admin",
    			"password": testAwsDirectoryServiceDirectory.Password,
    		})
    		if err != nil {
    			return err
    		}
    		json0 := string(tmpJSON0)
    		test, err := secretsmanager.NewSecretVersion(ctx, "test", &secretsmanager.SecretVersionArgs{
    			SecretId:     pulumi.Any(testAwsSecretsmanagerSecret.Id),
    			SecretString: pulumi.String(json0),
    		})
    		if err != nil {
    			return err
    		}
    		invokeFile, err := std.File(ctx, &std.FileArgs{
    			Input: "task-definitions/service.json",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = ecs.NewTaskDefinition(ctx, "service", &ecs.TaskDefinitionArgs{
    			Family:               pulumi.String("service"),
    			ContainerDefinitions: invokeFile.Result,
    			Volumes: ecs.TaskDefinitionVolumeArray{
    				&ecs.TaskDefinitionVolumeArgs{
    					Name: pulumi.String("service-storage"),
    					FsxWindowsFileServerVolumeConfiguration: &ecs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs{
    						FileSystemId:  pulumi.Any(testAwsFsxWindowsFileSystem.Id),
    						RootDirectory: pulumi.String("\\data"),
    						AuthorizationConfig: &ecs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs{
    							CredentialsParameter: test.Arn,
    							Domain:               pulumi.Any(testAwsDirectoryServiceDirectory.Name),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using System.Text.Json;
    using Pulumi;
    using Aws = Pulumi.Aws;
    using Std = Pulumi.Std;
    
    return await Deployment.RunAsync(() => 
    {
        var test = new Aws.SecretsManager.SecretVersion("test", new()
        {
            SecretId = testAwsSecretsmanagerSecret.Id,
            SecretString = JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["username"] = "admin",
                ["password"] = testAwsDirectoryServiceDirectory.Password,
            }),
        });
    
        var service = new Aws.Ecs.TaskDefinition("service", new()
        {
            Family = "service",
            ContainerDefinitions = Std.File.Invoke(new()
            {
                Input = "task-definitions/service.json",
            }).Apply(invoke => invoke.Result),
            Volumes = new[]
            {
                new Aws.Ecs.Inputs.TaskDefinitionVolumeArgs
                {
                    Name = "service-storage",
                    FsxWindowsFileServerVolumeConfiguration = new Aws.Ecs.Inputs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs
                    {
                        FileSystemId = testAwsFsxWindowsFileSystem.Id,
                        RootDirectory = "\\data",
                        AuthorizationConfig = new Aws.Ecs.Inputs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs
                        {
                            CredentialsParameter = test.Arn,
                            Domain = testAwsDirectoryServiceDirectory.Name,
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.secretsmanager.SecretVersion;
    import com.pulumi.aws.secretsmanager.SecretVersionArgs;
    import com.pulumi.aws.ecs.TaskDefinition;
    import com.pulumi.aws.ecs.TaskDefinitionArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs;
    import static com.pulumi.codegen.internal.Serialization.*;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var test = new SecretVersion("test", SecretVersionArgs.builder()
                .secretId(testAwsSecretsmanagerSecret.id())
                .secretString(serializeJson(
                    jsonObject(
                        jsonProperty("username", "admin"),
                        jsonProperty("password", testAwsDirectoryServiceDirectory.password())
                    )))
                .build());
    
            var service = new TaskDefinition("service", TaskDefinitionArgs.builder()
                .family("service")
                .containerDefinitions(StdFunctions.file(FileArgs.builder()
                    .input("task-definitions/service.json")
                    .build()).result())
                .volumes(TaskDefinitionVolumeArgs.builder()
                    .name("service-storage")
                    .fsxWindowsFileServerVolumeConfiguration(TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs.builder()
                        .fileSystemId(testAwsFsxWindowsFileSystem.id())
                        .rootDirectory("\\data")
                        .authorizationConfig(TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs.builder()
                            .credentialsParameter(test.arn())
                            .domain(testAwsDirectoryServiceDirectory.name())
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      service:
        type: aws:ecs:TaskDefinition
        properties:
          family: service
          containerDefinitions:
            fn::invoke:
              Function: std:file
              Arguments:
                input: task-definitions/service.json
              Return: result
          volumes:
            - name: service-storage
              fsxWindowsFileServerVolumeConfiguration:
                fileSystemId: ${testAwsFsxWindowsFileSystem.id}
                rootDirectory: \data
                authorizationConfig:
                  credentialsParameter: ${test.arn}
                  domain: ${testAwsDirectoryServiceDirectory.name}
      test:
        type: aws:secretsmanager:SecretVersion
        properties:
          secretId: ${testAwsSecretsmanagerSecret.id}
          secretString:
            fn::toJSON:
              username: admin
              password: ${testAwsDirectoryServiceDirectory.password}
    

    Example Using container_definitions and inference_accelerator

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const test = new aws.ecs.TaskDefinition("test", {
        family: "test",
        containerDefinitions: `[
      {
        "cpu": 10,
        "command": ["sleep", "10"],
        "entryPoint": ["/"],
        "environment": [
          {"name": "VARNAME", "value": "VARVAL"}
        ],
        "essential": true,
        "image": "jenkins",
        "memory": 128,
        "name": "jenkins",
        "portMappings": [
          {
            "containerPort": 80,
            "hostPort": 8080
          }
        ],
            "resourceRequirements":[
                {
                    "type":"InferenceAccelerator",
                    "value":"device_1"
                }
            ]
      }
    ]
    `,
        inferenceAccelerators: [{
            deviceName: "device_1",
            deviceType: "eia1.medium",
        }],
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test = aws.ecs.TaskDefinition("test",
        family="test",
        container_definitions="""[
      {
        "cpu": 10,
        "command": ["sleep", "10"],
        "entryPoint": ["/"],
        "environment": [
          {"name": "VARNAME", "value": "VARVAL"}
        ],
        "essential": true,
        "image": "jenkins",
        "memory": 128,
        "name": "jenkins",
        "portMappings": [
          {
            "containerPort": 80,
            "hostPort": 8080
          }
        ],
            "resourceRequirements":[
                {
                    "type":"InferenceAccelerator",
                    "value":"device_1"
                }
            ]
      }
    ]
    """,
        inference_accelerators=[aws.ecs.TaskDefinitionInferenceAcceleratorArgs(
            device_name="device_1",
            device_type="eia1.medium",
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ecs"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := ecs.NewTaskDefinition(ctx, "test", &ecs.TaskDefinitionArgs{
    			Family: pulumi.String("test"),
    			ContainerDefinitions: pulumi.String(`[
      {
        "cpu": 10,
        "command": ["sleep", "10"],
        "entryPoint": ["/"],
        "environment": [
          {"name": "VARNAME", "value": "VARVAL"}
        ],
        "essential": true,
        "image": "jenkins",
        "memory": 128,
        "name": "jenkins",
        "portMappings": [
          {
            "containerPort": 80,
            "hostPort": 8080
          }
        ],
            "resourceRequirements":[
                {
                    "type":"InferenceAccelerator",
                    "value":"device_1"
                }
            ]
      }
    ]
    `),
    			InferenceAccelerators: ecs.TaskDefinitionInferenceAcceleratorArray{
    				&ecs.TaskDefinitionInferenceAcceleratorArgs{
    					DeviceName: pulumi.String("device_1"),
    					DeviceType: pulumi.String("eia1.medium"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var test = new Aws.Ecs.TaskDefinition("test", new()
        {
            Family = "test",
            ContainerDefinitions = @"[
      {
        ""cpu"": 10,
        ""command"": [""sleep"", ""10""],
        ""entryPoint"": [""/""],
        ""environment"": [
          {""name"": ""VARNAME"", ""value"": ""VARVAL""}
        ],
        ""essential"": true,
        ""image"": ""jenkins"",
        ""memory"": 128,
        ""name"": ""jenkins"",
        ""portMappings"": [
          {
            ""containerPort"": 80,
            ""hostPort"": 8080
          }
        ],
            ""resourceRequirements"":[
                {
                    ""type"":""InferenceAccelerator"",
                    ""value"":""device_1""
                }
            ]
      }
    ]
    ",
            InferenceAccelerators = new[]
            {
                new Aws.Ecs.Inputs.TaskDefinitionInferenceAcceleratorArgs
                {
                    DeviceName = "device_1",
                    DeviceType = "eia1.medium",
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.ecs.TaskDefinition;
    import com.pulumi.aws.ecs.TaskDefinitionArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionInferenceAcceleratorArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var test = new TaskDefinition("test", TaskDefinitionArgs.builder()
                .family("test")
                .containerDefinitions("""
    [
      {
        "cpu": 10,
        "command": ["sleep", "10"],
        "entryPoint": ["/"],
        "environment": [
          {"name": "VARNAME", "value": "VARVAL"}
        ],
        "essential": true,
        "image": "jenkins",
        "memory": 128,
        "name": "jenkins",
        "portMappings": [
          {
            "containerPort": 80,
            "hostPort": 8080
          }
        ],
            "resourceRequirements":[
                {
                    "type":"InferenceAccelerator",
                    "value":"device_1"
                }
            ]
      }
    ]
                """)
                .inferenceAccelerators(TaskDefinitionInferenceAcceleratorArgs.builder()
                    .deviceName("device_1")
                    .deviceType("eia1.medium")
                    .build())
                .build());
    
        }
    }
    
    resources:
      test:
        type: aws:ecs:TaskDefinition
        properties:
          family: test
          containerDefinitions: |
            [
              {
                "cpu": 10,
                "command": ["sleep", "10"],
                "entryPoint": ["/"],
                "environment": [
                  {"name": "VARNAME", "value": "VARVAL"}
                ],
                "essential": true,
                "image": "jenkins",
                "memory": 128,
                "name": "jenkins",
                "portMappings": [
                  {
                    "containerPort": 80,
                    "hostPort": 8080
                  }
                ],
                    "resourceRequirements":[
                        {
                            "type":"InferenceAccelerator",
                            "value":"device_1"
                        }
                    ]
              }
            ]        
          inferenceAccelerators:
            - deviceName: device_1
              deviceType: eia1.medium
    

    Example Using runtime_platform and fargate

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const test = new aws.ecs.TaskDefinition("test", {
        family: "test",
        requiresCompatibilities: ["FARGATE"],
        networkMode: "awsvpc",
        cpu: "1024",
        memory: "2048",
        containerDefinitions: `[
      {
        "name": "iis",
        "image": "mcr.microsoft.com/windows/servercore/iis",
        "cpu": 1024,
        "memory": 2048,
        "essential": true
      }
    ]
    `,
        runtimePlatform: {
            operatingSystemFamily: "WINDOWS_SERVER_2019_CORE",
            cpuArchitecture: "X86_64",
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    test = aws.ecs.TaskDefinition("test",
        family="test",
        requires_compatibilities=["FARGATE"],
        network_mode="awsvpc",
        cpu="1024",
        memory="2048",
        container_definitions="""[
      {
        "name": "iis",
        "image": "mcr.microsoft.com/windows/servercore/iis",
        "cpu": 1024,
        "memory": 2048,
        "essential": true
      }
    ]
    """,
        runtime_platform=aws.ecs.TaskDefinitionRuntimePlatformArgs(
            operating_system_family="WINDOWS_SERVER_2019_CORE",
            cpu_architecture="X86_64",
        ))
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ecs"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := ecs.NewTaskDefinition(ctx, "test", &ecs.TaskDefinitionArgs{
    			Family: pulumi.String("test"),
    			RequiresCompatibilities: pulumi.StringArray{
    				pulumi.String("FARGATE"),
    			},
    			NetworkMode: pulumi.String("awsvpc"),
    			Cpu:         pulumi.String("1024"),
    			Memory:      pulumi.String("2048"),
    			ContainerDefinitions: pulumi.String(`[
      {
        "name": "iis",
        "image": "mcr.microsoft.com/windows/servercore/iis",
        "cpu": 1024,
        "memory": 2048,
        "essential": true
      }
    ]
    `),
    			RuntimePlatform: &ecs.TaskDefinitionRuntimePlatformArgs{
    				OperatingSystemFamily: pulumi.String("WINDOWS_SERVER_2019_CORE"),
    				CpuArchitecture:       pulumi.String("X86_64"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var test = new Aws.Ecs.TaskDefinition("test", new()
        {
            Family = "test",
            RequiresCompatibilities = new[]
            {
                "FARGATE",
            },
            NetworkMode = "awsvpc",
            Cpu = "1024",
            Memory = "2048",
            ContainerDefinitions = @"[
      {
        ""name"": ""iis"",
        ""image"": ""mcr.microsoft.com/windows/servercore/iis"",
        ""cpu"": 1024,
        ""memory"": 2048,
        ""essential"": true
      }
    ]
    ",
            RuntimePlatform = new Aws.Ecs.Inputs.TaskDefinitionRuntimePlatformArgs
            {
                OperatingSystemFamily = "WINDOWS_SERVER_2019_CORE",
                CpuArchitecture = "X86_64",
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.ecs.TaskDefinition;
    import com.pulumi.aws.ecs.TaskDefinitionArgs;
    import com.pulumi.aws.ecs.inputs.TaskDefinitionRuntimePlatformArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            var test = new TaskDefinition("test", TaskDefinitionArgs.builder()
                .family("test")
                .requiresCompatibilities("FARGATE")
                .networkMode("awsvpc")
                .cpu(1024)
                .memory(2048)
                .containerDefinitions("""
    [
      {
        "name": "iis",
        "image": "mcr.microsoft.com/windows/servercore/iis",
        "cpu": 1024,
        "memory": 2048,
        "essential": true
      }
    ]
                """)
                .runtimePlatform(TaskDefinitionRuntimePlatformArgs.builder()
                    .operatingSystemFamily("WINDOWS_SERVER_2019_CORE")
                    .cpuArchitecture("X86_64")
                    .build())
                .build());
    
        }
    }
    
    resources:
      test:
        type: aws:ecs:TaskDefinition
        properties:
          family: test
          requiresCompatibilities:
            - FARGATE
          networkMode: awsvpc
          cpu: 1024
          memory: 2048
          containerDefinitions: |
            [
              {
                "name": "iis",
                "image": "mcr.microsoft.com/windows/servercore/iis",
                "cpu": 1024,
                "memory": 2048,
                "essential": true
              }
            ]        
          runtimePlatform:
            operatingSystemFamily: WINDOWS_SERVER_2019_CORE
            cpuArchitecture: X86_64
    

    Create TaskDefinition Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new TaskDefinition(name: string, args: TaskDefinitionArgs, opts?: CustomResourceOptions);
    @overload
    def TaskDefinition(resource_name: str,
                       args: TaskDefinitionArgs,
                       opts: Optional[ResourceOptions] = None)
    
    @overload
    def TaskDefinition(resource_name: str,
                       opts: Optional[ResourceOptions] = None,
                       family: Optional[str] = None,
                       container_definitions: Optional[str] = None,
                       network_mode: Optional[str] = None,
                       proxy_configuration: Optional[TaskDefinitionProxyConfigurationArgs] = None,
                       ephemeral_storage: Optional[TaskDefinitionEphemeralStorageArgs] = None,
                       inference_accelerators: Optional[Sequence[TaskDefinitionInferenceAcceleratorArgs]] = None,
                       ipc_mode: Optional[str] = None,
                       memory: Optional[str] = None,
                       cpu: Optional[str] = None,
                       pid_mode: Optional[str] = None,
                       placement_constraints: Optional[Sequence[TaskDefinitionPlacementConstraintArgs]] = None,
                       execution_role_arn: Optional[str] = None,
                       requires_compatibilities: Optional[Sequence[str]] = None,
                       runtime_platform: Optional[TaskDefinitionRuntimePlatformArgs] = None,
                       skip_destroy: Optional[bool] = None,
                       tags: Optional[Mapping[str, str]] = None,
                       task_role_arn: Optional[str] = None,
                       track_latest: Optional[bool] = None,
                       volumes: Optional[Sequence[TaskDefinitionVolumeArgs]] = None)
    func NewTaskDefinition(ctx *Context, name string, args TaskDefinitionArgs, opts ...ResourceOption) (*TaskDefinition, error)
    public TaskDefinition(string name, TaskDefinitionArgs args, CustomResourceOptions? opts = null)
    public TaskDefinition(String name, TaskDefinitionArgs args)
    public TaskDefinition(String name, TaskDefinitionArgs args, CustomResourceOptions options)
    
    type: aws:ecs:TaskDefinition
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args TaskDefinitionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args TaskDefinitionArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args TaskDefinitionArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args TaskDefinitionArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args TaskDefinitionArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var taskDefinitionResource = new Aws.Ecs.TaskDefinition("taskDefinitionResource", new()
    {
        Family = "string",
        ContainerDefinitions = "string",
        NetworkMode = "string",
        ProxyConfiguration = new Aws.Ecs.Inputs.TaskDefinitionProxyConfigurationArgs
        {
            ContainerName = "string",
            Properties = 
            {
                { "string", "string" },
            },
            Type = "string",
        },
        EphemeralStorage = new Aws.Ecs.Inputs.TaskDefinitionEphemeralStorageArgs
        {
            SizeInGib = 0,
        },
        InferenceAccelerators = new[]
        {
            new Aws.Ecs.Inputs.TaskDefinitionInferenceAcceleratorArgs
            {
                DeviceName = "string",
                DeviceType = "string",
            },
        },
        IpcMode = "string",
        Memory = "string",
        Cpu = "string",
        PidMode = "string",
        PlacementConstraints = new[]
        {
            new Aws.Ecs.Inputs.TaskDefinitionPlacementConstraintArgs
            {
                Type = "string",
                Expression = "string",
            },
        },
        ExecutionRoleArn = "string",
        RequiresCompatibilities = new[]
        {
            "string",
        },
        RuntimePlatform = new Aws.Ecs.Inputs.TaskDefinitionRuntimePlatformArgs
        {
            CpuArchitecture = "string",
            OperatingSystemFamily = "string",
        },
        SkipDestroy = false,
        Tags = 
        {
            { "string", "string" },
        },
        TaskRoleArn = "string",
        TrackLatest = false,
        Volumes = new[]
        {
            new Aws.Ecs.Inputs.TaskDefinitionVolumeArgs
            {
                Name = "string",
                ConfigureAtLaunch = false,
                DockerVolumeConfiguration = new Aws.Ecs.Inputs.TaskDefinitionVolumeDockerVolumeConfigurationArgs
                {
                    Autoprovision = false,
                    Driver = "string",
                    DriverOpts = 
                    {
                        { "string", "string" },
                    },
                    Labels = 
                    {
                        { "string", "string" },
                    },
                    Scope = "string",
                },
                EfsVolumeConfiguration = new Aws.Ecs.Inputs.TaskDefinitionVolumeEfsVolumeConfigurationArgs
                {
                    FileSystemId = "string",
                    AuthorizationConfig = new Aws.Ecs.Inputs.TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs
                    {
                        AccessPointId = "string",
                        Iam = "string",
                    },
                    RootDirectory = "string",
                    TransitEncryption = "string",
                    TransitEncryptionPort = 0,
                },
                FsxWindowsFileServerVolumeConfiguration = new Aws.Ecs.Inputs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs
                {
                    AuthorizationConfig = new Aws.Ecs.Inputs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs
                    {
                        CredentialsParameter = "string",
                        Domain = "string",
                    },
                    FileSystemId = "string",
                    RootDirectory = "string",
                },
                HostPath = "string",
            },
        },
    });
    
    example, err := ecs.NewTaskDefinition(ctx, "taskDefinitionResource", &ecs.TaskDefinitionArgs{
    	Family:               pulumi.String("string"),
    	ContainerDefinitions: pulumi.String("string"),
    	NetworkMode:          pulumi.String("string"),
    	ProxyConfiguration: &ecs.TaskDefinitionProxyConfigurationArgs{
    		ContainerName: pulumi.String("string"),
    		Properties: pulumi.StringMap{
    			"string": pulumi.String("string"),
    		},
    		Type: pulumi.String("string"),
    	},
    	EphemeralStorage: &ecs.TaskDefinitionEphemeralStorageArgs{
    		SizeInGib: pulumi.Int(0),
    	},
    	InferenceAccelerators: ecs.TaskDefinitionInferenceAcceleratorArray{
    		&ecs.TaskDefinitionInferenceAcceleratorArgs{
    			DeviceName: pulumi.String("string"),
    			DeviceType: pulumi.String("string"),
    		},
    	},
    	IpcMode: pulumi.String("string"),
    	Memory:  pulumi.String("string"),
    	Cpu:     pulumi.String("string"),
    	PidMode: pulumi.String("string"),
    	PlacementConstraints: ecs.TaskDefinitionPlacementConstraintArray{
    		&ecs.TaskDefinitionPlacementConstraintArgs{
    			Type:       pulumi.String("string"),
    			Expression: pulumi.String("string"),
    		},
    	},
    	ExecutionRoleArn: pulumi.String("string"),
    	RequiresCompatibilities: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	RuntimePlatform: &ecs.TaskDefinitionRuntimePlatformArgs{
    		CpuArchitecture:       pulumi.String("string"),
    		OperatingSystemFamily: pulumi.String("string"),
    	},
    	SkipDestroy: pulumi.Bool(false),
    	Tags: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	TaskRoleArn: pulumi.String("string"),
    	TrackLatest: pulumi.Bool(false),
    	Volumes: ecs.TaskDefinitionVolumeArray{
    		&ecs.TaskDefinitionVolumeArgs{
    			Name:              pulumi.String("string"),
    			ConfigureAtLaunch: pulumi.Bool(false),
    			DockerVolumeConfiguration: &ecs.TaskDefinitionVolumeDockerVolumeConfigurationArgs{
    				Autoprovision: pulumi.Bool(false),
    				Driver:        pulumi.String("string"),
    				DriverOpts: pulumi.StringMap{
    					"string": pulumi.String("string"),
    				},
    				Labels: pulumi.StringMap{
    					"string": pulumi.String("string"),
    				},
    				Scope: pulumi.String("string"),
    			},
    			EfsVolumeConfiguration: &ecs.TaskDefinitionVolumeEfsVolumeConfigurationArgs{
    				FileSystemId: pulumi.String("string"),
    				AuthorizationConfig: &ecs.TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs{
    					AccessPointId: pulumi.String("string"),
    					Iam:           pulumi.String("string"),
    				},
    				RootDirectory:         pulumi.String("string"),
    				TransitEncryption:     pulumi.String("string"),
    				TransitEncryptionPort: pulumi.Int(0),
    			},
    			FsxWindowsFileServerVolumeConfiguration: &ecs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs{
    				AuthorizationConfig: &ecs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs{
    					CredentialsParameter: pulumi.String("string"),
    					Domain:               pulumi.String("string"),
    				},
    				FileSystemId:  pulumi.String("string"),
    				RootDirectory: pulumi.String("string"),
    			},
    			HostPath: pulumi.String("string"),
    		},
    	},
    })
    
    var taskDefinitionResource = new TaskDefinition("taskDefinitionResource", TaskDefinitionArgs.builder()
        .family("string")
        .containerDefinitions("string")
        .networkMode("string")
        .proxyConfiguration(TaskDefinitionProxyConfigurationArgs.builder()
            .containerName("string")
            .properties(Map.of("string", "string"))
            .type("string")
            .build())
        .ephemeralStorage(TaskDefinitionEphemeralStorageArgs.builder()
            .sizeInGib(0)
            .build())
        .inferenceAccelerators(TaskDefinitionInferenceAcceleratorArgs.builder()
            .deviceName("string")
            .deviceType("string")
            .build())
        .ipcMode("string")
        .memory("string")
        .cpu("string")
        .pidMode("string")
        .placementConstraints(TaskDefinitionPlacementConstraintArgs.builder()
            .type("string")
            .expression("string")
            .build())
        .executionRoleArn("string")
        .requiresCompatibilities("string")
        .runtimePlatform(TaskDefinitionRuntimePlatformArgs.builder()
            .cpuArchitecture("string")
            .operatingSystemFamily("string")
            .build())
        .skipDestroy(false)
        .tags(Map.of("string", "string"))
        .taskRoleArn("string")
        .trackLatest(false)
        .volumes(TaskDefinitionVolumeArgs.builder()
            .name("string")
            .configureAtLaunch(false)
            .dockerVolumeConfiguration(TaskDefinitionVolumeDockerVolumeConfigurationArgs.builder()
                .autoprovision(false)
                .driver("string")
                .driverOpts(Map.of("string", "string"))
                .labels(Map.of("string", "string"))
                .scope("string")
                .build())
            .efsVolumeConfiguration(TaskDefinitionVolumeEfsVolumeConfigurationArgs.builder()
                .fileSystemId("string")
                .authorizationConfig(TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs.builder()
                    .accessPointId("string")
                    .iam("string")
                    .build())
                .rootDirectory("string")
                .transitEncryption("string")
                .transitEncryptionPort(0)
                .build())
            .fsxWindowsFileServerVolumeConfiguration(TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs.builder()
                .authorizationConfig(TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs.builder()
                    .credentialsParameter("string")
                    .domain("string")
                    .build())
                .fileSystemId("string")
                .rootDirectory("string")
                .build())
            .hostPath("string")
            .build())
        .build());
    
    task_definition_resource = aws.ecs.TaskDefinition("taskDefinitionResource",
        family="string",
        container_definitions="string",
        network_mode="string",
        proxy_configuration=aws.ecs.TaskDefinitionProxyConfigurationArgs(
            container_name="string",
            properties={
                "string": "string",
            },
            type="string",
        ),
        ephemeral_storage=aws.ecs.TaskDefinitionEphemeralStorageArgs(
            size_in_gib=0,
        ),
        inference_accelerators=[aws.ecs.TaskDefinitionInferenceAcceleratorArgs(
            device_name="string",
            device_type="string",
        )],
        ipc_mode="string",
        memory="string",
        cpu="string",
        pid_mode="string",
        placement_constraints=[aws.ecs.TaskDefinitionPlacementConstraintArgs(
            type="string",
            expression="string",
        )],
        execution_role_arn="string",
        requires_compatibilities=["string"],
        runtime_platform=aws.ecs.TaskDefinitionRuntimePlatformArgs(
            cpu_architecture="string",
            operating_system_family="string",
        ),
        skip_destroy=False,
        tags={
            "string": "string",
        },
        task_role_arn="string",
        track_latest=False,
        volumes=[aws.ecs.TaskDefinitionVolumeArgs(
            name="string",
            configure_at_launch=False,
            docker_volume_configuration=aws.ecs.TaskDefinitionVolumeDockerVolumeConfigurationArgs(
                autoprovision=False,
                driver="string",
                driver_opts={
                    "string": "string",
                },
                labels={
                    "string": "string",
                },
                scope="string",
            ),
            efs_volume_configuration=aws.ecs.TaskDefinitionVolumeEfsVolumeConfigurationArgs(
                file_system_id="string",
                authorization_config=aws.ecs.TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs(
                    access_point_id="string",
                    iam="string",
                ),
                root_directory="string",
                transit_encryption="string",
                transit_encryption_port=0,
            ),
            fsx_windows_file_server_volume_configuration=aws.ecs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs(
                authorization_config=aws.ecs.TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs(
                    credentials_parameter="string",
                    domain="string",
                ),
                file_system_id="string",
                root_directory="string",
            ),
            host_path="string",
        )])
    
    const taskDefinitionResource = new aws.ecs.TaskDefinition("taskDefinitionResource", {
        family: "string",
        containerDefinitions: "string",
        networkMode: "string",
        proxyConfiguration: {
            containerName: "string",
            properties: {
                string: "string",
            },
            type: "string",
        },
        ephemeralStorage: {
            sizeInGib: 0,
        },
        inferenceAccelerators: [{
            deviceName: "string",
            deviceType: "string",
        }],
        ipcMode: "string",
        memory: "string",
        cpu: "string",
        pidMode: "string",
        placementConstraints: [{
            type: "string",
            expression: "string",
        }],
        executionRoleArn: "string",
        requiresCompatibilities: ["string"],
        runtimePlatform: {
            cpuArchitecture: "string",
            operatingSystemFamily: "string",
        },
        skipDestroy: false,
        tags: {
            string: "string",
        },
        taskRoleArn: "string",
        trackLatest: false,
        volumes: [{
            name: "string",
            configureAtLaunch: false,
            dockerVolumeConfiguration: {
                autoprovision: false,
                driver: "string",
                driverOpts: {
                    string: "string",
                },
                labels: {
                    string: "string",
                },
                scope: "string",
            },
            efsVolumeConfiguration: {
                fileSystemId: "string",
                authorizationConfig: {
                    accessPointId: "string",
                    iam: "string",
                },
                rootDirectory: "string",
                transitEncryption: "string",
                transitEncryptionPort: 0,
            },
            fsxWindowsFileServerVolumeConfiguration: {
                authorizationConfig: {
                    credentialsParameter: "string",
                    domain: "string",
                },
                fileSystemId: "string",
                rootDirectory: "string",
            },
            hostPath: "string",
        }],
    });
    
    type: aws:ecs:TaskDefinition
    properties:
        containerDefinitions: string
        cpu: string
        ephemeralStorage:
            sizeInGib: 0
        executionRoleArn: string
        family: string
        inferenceAccelerators:
            - deviceName: string
              deviceType: string
        ipcMode: string
        memory: string
        networkMode: string
        pidMode: string
        placementConstraints:
            - expression: string
              type: string
        proxyConfiguration:
            containerName: string
            properties:
                string: string
            type: string
        requiresCompatibilities:
            - string
        runtimePlatform:
            cpuArchitecture: string
            operatingSystemFamily: string
        skipDestroy: false
        tags:
            string: string
        taskRoleArn: string
        trackLatest: false
        volumes:
            - configureAtLaunch: false
              dockerVolumeConfiguration:
                autoprovision: false
                driver: string
                driverOpts:
                    string: string
                labels:
                    string: string
                scope: string
              efsVolumeConfiguration:
                authorizationConfig:
                    accessPointId: string
                    iam: string
                fileSystemId: string
                rootDirectory: string
                transitEncryption: string
                transitEncryptionPort: 0
              fsxWindowsFileServerVolumeConfiguration:
                authorizationConfig:
                    credentialsParameter: string
                    domain: string
                fileSystemId: string
                rootDirectory: string
              hostPath: string
              name: string
    

    TaskDefinition Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The TaskDefinition resource accepts the following input properties:

    ContainerDefinitions string
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    Family string

    A unique name for your task definition.

    The following arguments are optional:

    Cpu string
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    EphemeralStorage TaskDefinitionEphemeralStorage
    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 AWS Fargate. See Ephemeral Storage.
    ExecutionRoleArn string
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    InferenceAccelerators List<TaskDefinitionInferenceAccelerator>
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    IpcMode string
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    Memory string
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    NetworkMode string
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    PidMode string
    Process namespace to use for the containers in the task. The valid values are host and task.
    PlacementConstraints List<TaskDefinitionPlacementConstraint>
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    ProxyConfiguration TaskDefinitionProxyConfiguration
    Configuration block for the App Mesh proxy. Detailed below.
    RequiresCompatibilities List<string>
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    RuntimePlatform TaskDefinitionRuntimePlatform
    Configuration block for runtime_platform that containers in your task may use.
    SkipDestroy bool
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    Tags Dictionary<string, string>
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    TaskRoleArn string
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    TrackLatest bool
    Whether should track latest task definition or the one created with the resource. Default is false.
    Volumes List<TaskDefinitionVolume>
    Configuration block for volumes that containers in your task may use. Detailed below.
    ContainerDefinitions string
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    Family string

    A unique name for your task definition.

    The following arguments are optional:

    Cpu string
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    EphemeralStorage TaskDefinitionEphemeralStorageArgs
    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 AWS Fargate. See Ephemeral Storage.
    ExecutionRoleArn string
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    InferenceAccelerators []TaskDefinitionInferenceAcceleratorArgs
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    IpcMode string
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    Memory string
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    NetworkMode string
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    PidMode string
    Process namespace to use for the containers in the task. The valid values are host and task.
    PlacementConstraints []TaskDefinitionPlacementConstraintArgs
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    ProxyConfiguration TaskDefinitionProxyConfigurationArgs
    Configuration block for the App Mesh proxy. Detailed below.
    RequiresCompatibilities []string
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    RuntimePlatform TaskDefinitionRuntimePlatformArgs
    Configuration block for runtime_platform that containers in your task may use.
    SkipDestroy bool
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    Tags map[string]string
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    TaskRoleArn string
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    TrackLatest bool
    Whether should track latest task definition or the one created with the resource. Default is false.
    Volumes []TaskDefinitionVolumeArgs
    Configuration block for volumes that containers in your task may use. Detailed below.
    containerDefinitions String
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    family String

    A unique name for your task definition.

    The following arguments are optional:

    cpu String
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    ephemeralStorage TaskDefinitionEphemeralStorage
    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 AWS Fargate. See Ephemeral Storage.
    executionRoleArn String
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    inferenceAccelerators List<TaskDefinitionInferenceAccelerator>
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    ipcMode String
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    memory String
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    networkMode String
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    pidMode String
    Process namespace to use for the containers in the task. The valid values are host and task.
    placementConstraints List<TaskDefinitionPlacementConstraint>
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    proxyConfiguration TaskDefinitionProxyConfiguration
    Configuration block for the App Mesh proxy. Detailed below.
    requiresCompatibilities List<String>
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    runtimePlatform TaskDefinitionRuntimePlatform
    Configuration block for runtime_platform that containers in your task may use.
    skipDestroy Boolean
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    tags Map<String,String>
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    taskRoleArn String
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    trackLatest Boolean
    Whether should track latest task definition or the one created with the resource. Default is false.
    volumes List<TaskDefinitionVolume>
    Configuration block for volumes that containers in your task may use. Detailed below.
    containerDefinitions string
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    family string

    A unique name for your task definition.

    The following arguments are optional:

    cpu string
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    ephemeralStorage TaskDefinitionEphemeralStorage
    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 AWS Fargate. See Ephemeral Storage.
    executionRoleArn string
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    inferenceAccelerators TaskDefinitionInferenceAccelerator[]
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    ipcMode string
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    memory string
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    networkMode string
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    pidMode string
    Process namespace to use for the containers in the task. The valid values are host and task.
    placementConstraints TaskDefinitionPlacementConstraint[]
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    proxyConfiguration TaskDefinitionProxyConfiguration
    Configuration block for the App Mesh proxy. Detailed below.
    requiresCompatibilities string[]
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    runtimePlatform TaskDefinitionRuntimePlatform
    Configuration block for runtime_platform that containers in your task may use.
    skipDestroy boolean
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    tags {[key: string]: string}
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    taskRoleArn string
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    trackLatest boolean
    Whether should track latest task definition or the one created with the resource. Default is false.
    volumes TaskDefinitionVolume[]
    Configuration block for volumes that containers in your task may use. Detailed below.
    container_definitions str
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    family str

    A unique name for your task definition.

    The following arguments are optional:

    cpu str
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    ephemeral_storage TaskDefinitionEphemeralStorageArgs
    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 AWS Fargate. See Ephemeral Storage.
    execution_role_arn str
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    inference_accelerators Sequence[TaskDefinitionInferenceAcceleratorArgs]
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    ipc_mode str
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    memory str
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    network_mode str
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    pid_mode str
    Process namespace to use for the containers in the task. The valid values are host and task.
    placement_constraints Sequence[TaskDefinitionPlacementConstraintArgs]
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    proxy_configuration TaskDefinitionProxyConfigurationArgs
    Configuration block for the App Mesh proxy. Detailed below.
    requires_compatibilities Sequence[str]
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    runtime_platform TaskDefinitionRuntimePlatformArgs
    Configuration block for runtime_platform that containers in your task may use.
    skip_destroy bool
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    tags Mapping[str, str]
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    task_role_arn str
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    track_latest bool
    Whether should track latest task definition or the one created with the resource. Default is false.
    volumes Sequence[TaskDefinitionVolumeArgs]
    Configuration block for volumes that containers in your task may use. Detailed below.
    containerDefinitions String
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    family String

    A unique name for your task definition.

    The following arguments are optional:

    cpu String
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    ephemeralStorage Property Map
    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 AWS Fargate. See Ephemeral Storage.
    executionRoleArn String
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    inferenceAccelerators List<Property Map>
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    ipcMode String
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    memory String
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    networkMode String
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    pidMode String
    Process namespace to use for the containers in the task. The valid values are host and task.
    placementConstraints List<Property Map>
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    proxyConfiguration Property Map
    Configuration block for the App Mesh proxy. Detailed below.
    requiresCompatibilities List<String>
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    runtimePlatform Property Map
    Configuration block for runtime_platform that containers in your task may use.
    skipDestroy Boolean
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    tags Map<String>
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    taskRoleArn String
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    trackLatest Boolean
    Whether should track latest task definition or the one created with the resource. Default is false.
    volumes List<Property Map>
    Configuration block for volumes that containers in your task may use. Detailed below.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the TaskDefinition resource produces the following output properties:

    Arn string
    Full ARN of the Task Definition (including both family and revision).
    ArnWithoutRevision string
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    Id string
    The provider-assigned unique ID for this managed resource.
    Revision int
    Revision of the task in a particular family.
    TagsAll Dictionary<string, string>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Arn string
    Full ARN of the Task Definition (including both family and revision).
    ArnWithoutRevision string
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    Id string
    The provider-assigned unique ID for this managed resource.
    Revision int
    Revision of the task in a particular family.
    TagsAll map[string]string
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn String
    Full ARN of the Task Definition (including both family and revision).
    arnWithoutRevision String
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    id String
    The provider-assigned unique ID for this managed resource.
    revision Integer
    Revision of the task in a particular family.
    tagsAll Map<String,String>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn string
    Full ARN of the Task Definition (including both family and revision).
    arnWithoutRevision string
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    id string
    The provider-assigned unique ID for this managed resource.
    revision number
    Revision of the task in a particular family.
    tagsAll {[key: string]: string}
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn str
    Full ARN of the Task Definition (including both family and revision).
    arn_without_revision str
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    id str
    The provider-assigned unique ID for this managed resource.
    revision int
    Revision of the task in a particular family.
    tags_all Mapping[str, str]
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    arn String
    Full ARN of the Task Definition (including both family and revision).
    arnWithoutRevision String
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    id String
    The provider-assigned unique ID for this managed resource.
    revision Number
    Revision of the task in a particular family.
    tagsAll Map<String>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    Look up Existing TaskDefinition Resource

    Get an existing TaskDefinition resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: TaskDefinitionState, opts?: CustomResourceOptions): TaskDefinition
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            arn: Optional[str] = None,
            arn_without_revision: Optional[str] = None,
            container_definitions: Optional[str] = None,
            cpu: Optional[str] = None,
            ephemeral_storage: Optional[TaskDefinitionEphemeralStorageArgs] = None,
            execution_role_arn: Optional[str] = None,
            family: Optional[str] = None,
            inference_accelerators: Optional[Sequence[TaskDefinitionInferenceAcceleratorArgs]] = None,
            ipc_mode: Optional[str] = None,
            memory: Optional[str] = None,
            network_mode: Optional[str] = None,
            pid_mode: Optional[str] = None,
            placement_constraints: Optional[Sequence[TaskDefinitionPlacementConstraintArgs]] = None,
            proxy_configuration: Optional[TaskDefinitionProxyConfigurationArgs] = None,
            requires_compatibilities: Optional[Sequence[str]] = None,
            revision: Optional[int] = None,
            runtime_platform: Optional[TaskDefinitionRuntimePlatformArgs] = None,
            skip_destroy: Optional[bool] = None,
            tags: Optional[Mapping[str, str]] = None,
            tags_all: Optional[Mapping[str, str]] = None,
            task_role_arn: Optional[str] = None,
            track_latest: Optional[bool] = None,
            volumes: Optional[Sequence[TaskDefinitionVolumeArgs]] = None) -> TaskDefinition
    func GetTaskDefinition(ctx *Context, name string, id IDInput, state *TaskDefinitionState, opts ...ResourceOption) (*TaskDefinition, error)
    public static TaskDefinition Get(string name, Input<string> id, TaskDefinitionState? state, CustomResourceOptions? opts = null)
    public static TaskDefinition get(String name, Output<String> id, TaskDefinitionState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Arn string
    Full ARN of the Task Definition (including both family and revision).
    ArnWithoutRevision string
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    ContainerDefinitions string
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    Cpu string
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    EphemeralStorage TaskDefinitionEphemeralStorage
    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 AWS Fargate. See Ephemeral Storage.
    ExecutionRoleArn string
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    Family string

    A unique name for your task definition.

    The following arguments are optional:

    InferenceAccelerators List<TaskDefinitionInferenceAccelerator>
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    IpcMode string
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    Memory string
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    NetworkMode string
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    PidMode string
    Process namespace to use for the containers in the task. The valid values are host and task.
    PlacementConstraints List<TaskDefinitionPlacementConstraint>
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    ProxyConfiguration TaskDefinitionProxyConfiguration
    Configuration block for the App Mesh proxy. Detailed below.
    RequiresCompatibilities List<string>
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    Revision int
    Revision of the task in a particular family.
    RuntimePlatform TaskDefinitionRuntimePlatform
    Configuration block for runtime_platform that containers in your task may use.
    SkipDestroy bool
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    Tags Dictionary<string, string>
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    TagsAll Dictionary<string, string>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    TaskRoleArn string
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    TrackLatest bool
    Whether should track latest task definition or the one created with the resource. Default is false.
    Volumes List<TaskDefinitionVolume>
    Configuration block for volumes that containers in your task may use. Detailed below.
    Arn string
    Full ARN of the Task Definition (including both family and revision).
    ArnWithoutRevision string
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    ContainerDefinitions string
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    Cpu string
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    EphemeralStorage TaskDefinitionEphemeralStorageArgs
    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 AWS Fargate. See Ephemeral Storage.
    ExecutionRoleArn string
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    Family string

    A unique name for your task definition.

    The following arguments are optional:

    InferenceAccelerators []TaskDefinitionInferenceAcceleratorArgs
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    IpcMode string
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    Memory string
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    NetworkMode string
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    PidMode string
    Process namespace to use for the containers in the task. The valid values are host and task.
    PlacementConstraints []TaskDefinitionPlacementConstraintArgs
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    ProxyConfiguration TaskDefinitionProxyConfigurationArgs
    Configuration block for the App Mesh proxy. Detailed below.
    RequiresCompatibilities []string
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    Revision int
    Revision of the task in a particular family.
    RuntimePlatform TaskDefinitionRuntimePlatformArgs
    Configuration block for runtime_platform that containers in your task may use.
    SkipDestroy bool
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    Tags map[string]string
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    TagsAll map[string]string
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    TaskRoleArn string
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    TrackLatest bool
    Whether should track latest task definition or the one created with the resource. Default is false.
    Volumes []TaskDefinitionVolumeArgs
    Configuration block for volumes that containers in your task may use. Detailed below.
    arn String
    Full ARN of the Task Definition (including both family and revision).
    arnWithoutRevision String
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    containerDefinitions String
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    cpu String
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    ephemeralStorage TaskDefinitionEphemeralStorage
    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 AWS Fargate. See Ephemeral Storage.
    executionRoleArn String
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    family String

    A unique name for your task definition.

    The following arguments are optional:

    inferenceAccelerators List<TaskDefinitionInferenceAccelerator>
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    ipcMode String
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    memory String
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    networkMode String
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    pidMode String
    Process namespace to use for the containers in the task. The valid values are host and task.
    placementConstraints List<TaskDefinitionPlacementConstraint>
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    proxyConfiguration TaskDefinitionProxyConfiguration
    Configuration block for the App Mesh proxy. Detailed below.
    requiresCompatibilities List<String>
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    revision Integer
    Revision of the task in a particular family.
    runtimePlatform TaskDefinitionRuntimePlatform
    Configuration block for runtime_platform that containers in your task may use.
    skipDestroy Boolean
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    tags Map<String,String>
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    tagsAll Map<String,String>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    taskRoleArn String
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    trackLatest Boolean
    Whether should track latest task definition or the one created with the resource. Default is false.
    volumes List<TaskDefinitionVolume>
    Configuration block for volumes that containers in your task may use. Detailed below.
    arn string
    Full ARN of the Task Definition (including both family and revision).
    arnWithoutRevision string
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    containerDefinitions string
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    cpu string
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    ephemeralStorage TaskDefinitionEphemeralStorage
    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 AWS Fargate. See Ephemeral Storage.
    executionRoleArn string
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    family string

    A unique name for your task definition.

    The following arguments are optional:

    inferenceAccelerators TaskDefinitionInferenceAccelerator[]
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    ipcMode string
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    memory string
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    networkMode string
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    pidMode string
    Process namespace to use for the containers in the task. The valid values are host and task.
    placementConstraints TaskDefinitionPlacementConstraint[]
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    proxyConfiguration TaskDefinitionProxyConfiguration
    Configuration block for the App Mesh proxy. Detailed below.
    requiresCompatibilities string[]
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    revision number
    Revision of the task in a particular family.
    runtimePlatform TaskDefinitionRuntimePlatform
    Configuration block for runtime_platform that containers in your task may use.
    skipDestroy boolean
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    tags {[key: string]: string}
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    tagsAll {[key: string]: string}
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    taskRoleArn string
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    trackLatest boolean
    Whether should track latest task definition or the one created with the resource. Default is false.
    volumes TaskDefinitionVolume[]
    Configuration block for volumes that containers in your task may use. Detailed below.
    arn str
    Full ARN of the Task Definition (including both family and revision).
    arn_without_revision str
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    container_definitions str
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    cpu str
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    ephemeral_storage TaskDefinitionEphemeralStorageArgs
    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 AWS Fargate. See Ephemeral Storage.
    execution_role_arn str
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    family str

    A unique name for your task definition.

    The following arguments are optional:

    inference_accelerators Sequence[TaskDefinitionInferenceAcceleratorArgs]
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    ipc_mode str
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    memory str
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    network_mode str
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    pid_mode str
    Process namespace to use for the containers in the task. The valid values are host and task.
    placement_constraints Sequence[TaskDefinitionPlacementConstraintArgs]
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    proxy_configuration TaskDefinitionProxyConfigurationArgs
    Configuration block for the App Mesh proxy. Detailed below.
    requires_compatibilities Sequence[str]
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    revision int
    Revision of the task in a particular family.
    runtime_platform TaskDefinitionRuntimePlatformArgs
    Configuration block for runtime_platform that containers in your task may use.
    skip_destroy bool
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    tags Mapping[str, str]
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    tags_all Mapping[str, str]
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    task_role_arn str
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    track_latest bool
    Whether should track latest task definition or the one created with the resource. Default is false.
    volumes Sequence[TaskDefinitionVolumeArgs]
    Configuration block for volumes that containers in your task may use. Detailed below.
    arn String
    Full ARN of the Task Definition (including both family and revision).
    arnWithoutRevision String
    ARN of the Task Definition with the trailing revision removed. This may be useful for situations where the latest task definition is always desired. If a revision isn't specified, the latest ACTIVE revision is used. See the AWS documentation for details.
    containerDefinitions String
    A list of valid container definitions provided as a single valid JSON document. Please note that you should only provide values that are part of the container definition document. For a detailed description of what parameters are available, see the Task Definition Parameters section from the official Developer Guide.
    cpu String
    Number of cpu units used by the task. If the requires_compatibilities is FARGATE this field is required.
    ephemeralStorage Property Map
    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 AWS Fargate. See Ephemeral Storage.
    executionRoleArn String
    ARN of the task execution role that the Amazon ECS container agent and the Docker daemon can assume.
    family String

    A unique name for your task definition.

    The following arguments are optional:

    inferenceAccelerators List<Property Map>
    Configuration block(s) with Inference Accelerators settings. Detailed below.
    ipcMode String
    IPC resource namespace to be used for the containers in the task The valid values are host, task, and none.
    memory String
    Amount (in MiB) of memory used by the task. If the requires_compatibilities is FARGATE this field is required.
    networkMode String
    Docker networking mode to use for the containers in the task. Valid values are none, bridge, awsvpc, and host.
    pidMode String
    Process namespace to use for the containers in the task. The valid values are host and task.
    placementConstraints List<Property Map>
    Configuration block for rules that are taken into consideration during task placement. Maximum number of placement_constraints is 10. Detailed below.
    proxyConfiguration Property Map
    Configuration block for the App Mesh proxy. Detailed below.
    requiresCompatibilities List<String>
    Set of launch types required by the task. The valid values are EC2 and FARGATE.
    revision Number
    Revision of the task in a particular family.
    runtimePlatform Property Map
    Configuration block for runtime_platform that containers in your task may use.
    skipDestroy Boolean
    Whether to retain the old revision when the resource is destroyed or replacement is necessary. Default is false.
    tags Map<String>
    Key-value map of resource tags. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
    tagsAll Map<String>
    Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

    Deprecated: Please use tags instead.

    taskRoleArn String
    ARN of IAM role that allows your Amazon ECS container task to make calls to other AWS services.
    trackLatest Boolean
    Whether should track latest task definition or the one created with the resource. Default is false.
    volumes List<Property Map>
    Configuration block for volumes that containers in your task may use. Detailed below.

    Supporting Types

    TaskDefinitionEphemeralStorage, TaskDefinitionEphemeralStorageArgs

    SizeInGib int
    The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is 21 GiB and the maximum supported value is 200 GiB.
    SizeInGib int
    The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is 21 GiB and the maximum supported value is 200 GiB.
    sizeInGib Integer
    The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is 21 GiB and the maximum supported value is 200 GiB.
    sizeInGib number
    The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is 21 GiB and the maximum supported value is 200 GiB.
    size_in_gib int
    The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is 21 GiB and the maximum supported value is 200 GiB.
    sizeInGib Number
    The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is 21 GiB and the maximum supported value is 200 GiB.

    TaskDefinitionInferenceAccelerator, TaskDefinitionInferenceAcceleratorArgs

    DeviceName string
    Elastic Inference accelerator device name. The deviceName must also be referenced in a container definition as a ResourceRequirement.
    DeviceType string
    Elastic Inference accelerator type to use.
    DeviceName string
    Elastic Inference accelerator device name. The deviceName must also be referenced in a container definition as a ResourceRequirement.
    DeviceType string
    Elastic Inference accelerator type to use.
    deviceName String
    Elastic Inference accelerator device name. The deviceName must also be referenced in a container definition as a ResourceRequirement.
    deviceType String
    Elastic Inference accelerator type to use.
    deviceName string
    Elastic Inference accelerator device name. The deviceName must also be referenced in a container definition as a ResourceRequirement.
    deviceType string
    Elastic Inference accelerator type to use.
    device_name str
    Elastic Inference accelerator device name. The deviceName must also be referenced in a container definition as a ResourceRequirement.
    device_type str
    Elastic Inference accelerator type to use.
    deviceName String
    Elastic Inference accelerator device name. The deviceName must also be referenced in a container definition as a ResourceRequirement.
    deviceType String
    Elastic Inference accelerator type to use.

    TaskDefinitionPlacementConstraint, TaskDefinitionPlacementConstraintArgs

    Type string
    Type of constraint. Use memberOf to restrict selection to a group of valid candidates. Note that distinctInstance is not supported in task definitions.
    Expression string
    Cluster Query Language expression to apply to the constraint. For more information, see Cluster Query Language in the Amazon EC2 Container Service Developer Guide.
    Type string
    Type of constraint. Use memberOf to restrict selection to a group of valid candidates. Note that distinctInstance is not supported in task definitions.
    Expression string
    Cluster Query Language expression to apply to the constraint. For more information, see Cluster Query Language in the Amazon EC2 Container Service Developer Guide.
    type String
    Type of constraint. Use memberOf to restrict selection to a group of valid candidates. Note that distinctInstance is not supported in task definitions.
    expression String
    Cluster Query Language expression to apply to the constraint. For more information, see Cluster Query Language in the Amazon EC2 Container Service Developer Guide.
    type string
    Type of constraint. Use memberOf to restrict selection to a group of valid candidates. Note that distinctInstance is not supported in task definitions.
    expression string
    Cluster Query Language expression to apply to the constraint. For more information, see Cluster Query Language in the Amazon EC2 Container Service Developer Guide.
    type str
    Type of constraint. Use memberOf to restrict selection to a group of valid candidates. Note that distinctInstance is not supported in task definitions.
    expression str
    Cluster Query Language expression to apply to the constraint. For more information, see Cluster Query Language in the Amazon EC2 Container Service Developer Guide.
    type String
    Type of constraint. Use memberOf to restrict selection to a group of valid candidates. Note that distinctInstance is not supported in task definitions.
    expression String
    Cluster Query Language expression to apply to the constraint. For more information, see Cluster Query Language in the Amazon EC2 Container Service Developer Guide.

    TaskDefinitionProxyConfiguration, TaskDefinitionProxyConfigurationArgs

    ContainerName string
    Name of the container that will serve as the App Mesh proxy.
    Properties Dictionary<string, string>
    Set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified a key-value mapping.
    Type string
    Proxy type. The default value is APPMESH. The only supported value is APPMESH.
    ContainerName string
    Name of the container that will serve as the App Mesh proxy.
    Properties map[string]string
    Set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified a key-value mapping.
    Type string
    Proxy type. The default value is APPMESH. The only supported value is APPMESH.
    containerName String
    Name of the container that will serve as the App Mesh proxy.
    properties Map<String,String>
    Set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified a key-value mapping.
    type String
    Proxy type. The default value is APPMESH. The only supported value is APPMESH.
    containerName string
    Name of the container that will serve as the App Mesh proxy.
    properties {[key: string]: string}
    Set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified a key-value mapping.
    type string
    Proxy type. The default value is APPMESH. The only supported value is APPMESH.
    container_name str
    Name of the container that will serve as the App Mesh proxy.
    properties Mapping[str, str]
    Set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified a key-value mapping.
    type str
    Proxy type. The default value is APPMESH. The only supported value is APPMESH.
    containerName String
    Name of the container that will serve as the App Mesh proxy.
    properties Map<String>
    Set of network configuration parameters to provide the Container Network Interface (CNI) plugin, specified a key-value mapping.
    type String
    Proxy type. The default value is APPMESH. The only supported value is APPMESH.

    TaskDefinitionRuntimePlatform, TaskDefinitionRuntimePlatformArgs

    CpuArchitecture string
    Must be set to either X86_64 or ARM64; see cpu architecture
    OperatingSystemFamily string
    If the requires_compatibilities is FARGATE this field is required; must be set to a valid option from the operating system family in the runtime platform setting
    CpuArchitecture string
    Must be set to either X86_64 or ARM64; see cpu architecture
    OperatingSystemFamily string
    If the requires_compatibilities is FARGATE this field is required; must be set to a valid option from the operating system family in the runtime platform setting
    cpuArchitecture String
    Must be set to either X86_64 or ARM64; see cpu architecture
    operatingSystemFamily String
    If the requires_compatibilities is FARGATE this field is required; must be set to a valid option from the operating system family in the runtime platform setting
    cpuArchitecture string
    Must be set to either X86_64 or ARM64; see cpu architecture
    operatingSystemFamily string
    If the requires_compatibilities is FARGATE this field is required; must be set to a valid option from the operating system family in the runtime platform setting
    cpu_architecture str
    Must be set to either X86_64 or ARM64; see cpu architecture
    operating_system_family str
    If the requires_compatibilities is FARGATE this field is required; must be set to a valid option from the operating system family in the runtime platform setting
    cpuArchitecture String
    Must be set to either X86_64 or ARM64; see cpu architecture
    operatingSystemFamily String
    If the requires_compatibilities is FARGATE this field is required; must be set to a valid option from the operating system family in the runtime platform setting

    TaskDefinitionVolume, TaskDefinitionVolumeArgs

    Name string
    Name of the volume. This name is referenced in the sourceVolume parameter of container definition in the mountPoints section.
    ConfigureAtLaunch bool
    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.
    DockerVolumeConfiguration TaskDefinitionVolumeDockerVolumeConfiguration
    Configuration block to configure a docker volume. Detailed below.
    EfsVolumeConfiguration TaskDefinitionVolumeEfsVolumeConfiguration
    Configuration block for an EFS volume. Detailed below.
    FsxWindowsFileServerVolumeConfiguration TaskDefinitionVolumeFsxWindowsFileServerVolumeConfiguration
    Configuration block for an FSX Windows File Server volume. Detailed below.
    HostPath string
    Path on the host container instance that is presented to the container. If not set, ECS will create a nonpersistent data volume that starts empty and is deleted after the task has finished.
    Name string
    Name of the volume. This name is referenced in the sourceVolume parameter of container definition in the mountPoints section.
    ConfigureAtLaunch bool
    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.
    DockerVolumeConfiguration TaskDefinitionVolumeDockerVolumeConfiguration
    Configuration block to configure a docker volume. Detailed below.
    EfsVolumeConfiguration TaskDefinitionVolumeEfsVolumeConfiguration
    Configuration block for an EFS volume. Detailed below.
    FsxWindowsFileServerVolumeConfiguration TaskDefinitionVolumeFsxWindowsFileServerVolumeConfiguration
    Configuration block for an FSX Windows File Server volume. Detailed below.
    HostPath string
    Path on the host container instance that is presented to the container. If not set, ECS will create a nonpersistent data volume that starts empty and is deleted after the task has finished.
    name String
    Name of the volume. This name is referenced in the sourceVolume parameter of container definition in the mountPoints section.
    configureAtLaunch Boolean
    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.
    dockerVolumeConfiguration TaskDefinitionVolumeDockerVolumeConfiguration
    Configuration block to configure a docker volume. Detailed below.
    efsVolumeConfiguration TaskDefinitionVolumeEfsVolumeConfiguration
    Configuration block for an EFS volume. Detailed below.
    fsxWindowsFileServerVolumeConfiguration TaskDefinitionVolumeFsxWindowsFileServerVolumeConfiguration
    Configuration block for an FSX Windows File Server volume. Detailed below.
    hostPath String
    Path on the host container instance that is presented to the container. If not set, ECS will create a nonpersistent data volume that starts empty and is deleted after the task has finished.
    name string
    Name of the volume. This name is referenced in the sourceVolume parameter of container definition in the mountPoints section.
    configureAtLaunch boolean
    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.
    dockerVolumeConfiguration TaskDefinitionVolumeDockerVolumeConfiguration
    Configuration block to configure a docker volume. Detailed below.
    efsVolumeConfiguration TaskDefinitionVolumeEfsVolumeConfiguration
    Configuration block for an EFS volume. Detailed below.
    fsxWindowsFileServerVolumeConfiguration TaskDefinitionVolumeFsxWindowsFileServerVolumeConfiguration
    Configuration block for an FSX Windows File Server volume. Detailed below.
    hostPath string
    Path on the host container instance that is presented to the container. If not set, ECS will create a nonpersistent data volume that starts empty and is deleted after the task has finished.
    name str
    Name of the volume. This name is referenced in the sourceVolume parameter of container definition in the mountPoints section.
    configure_at_launch bool
    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.
    docker_volume_configuration TaskDefinitionVolumeDockerVolumeConfiguration
    Configuration block to configure a docker volume. Detailed below.
    efs_volume_configuration TaskDefinitionVolumeEfsVolumeConfiguration
    Configuration block for an EFS volume. Detailed below.
    fsx_windows_file_server_volume_configuration TaskDefinitionVolumeFsxWindowsFileServerVolumeConfiguration
    Configuration block for an FSX Windows File Server volume. Detailed below.
    host_path str
    Path on the host container instance that is presented to the container. If not set, ECS will create a nonpersistent data volume that starts empty and is deleted after the task has finished.
    name String
    Name of the volume. This name is referenced in the sourceVolume parameter of container definition in the mountPoints section.
    configureAtLaunch Boolean
    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.
    dockerVolumeConfiguration Property Map
    Configuration block to configure a docker volume. Detailed below.
    efsVolumeConfiguration Property Map
    Configuration block for an EFS volume. Detailed below.
    fsxWindowsFileServerVolumeConfiguration Property Map
    Configuration block for an FSX Windows File Server volume. Detailed below.
    hostPath String
    Path on the host container instance that is presented to the container. If not set, ECS will create a nonpersistent data volume that starts empty and is deleted after the task has finished.

    TaskDefinitionVolumeDockerVolumeConfiguration, TaskDefinitionVolumeDockerVolumeConfigurationArgs

    Autoprovision bool
    If this value is true, the Docker volume is created if it does not already exist. Note: This field is only used if the scope is shared.
    Driver string
    Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement.
    DriverOpts Dictionary<string, string>
    Map of Docker driver specific options.
    Labels Dictionary<string, string>
    Map of custom metadata to add to your Docker volume.
    Scope string
    Scope for the Docker volume, which determines its lifecycle, either task or shared. 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.
    Autoprovision bool
    If this value is true, the Docker volume is created if it does not already exist. Note: This field is only used if the scope is shared.
    Driver string
    Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement.
    DriverOpts map[string]string
    Map of Docker driver specific options.
    Labels map[string]string
    Map of custom metadata to add to your Docker volume.
    Scope string
    Scope for the Docker volume, which determines its lifecycle, either task or shared. 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.
    autoprovision Boolean
    If this value is true, the Docker volume is created if it does not already exist. Note: This field is only used if the scope is shared.
    driver String
    Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement.
    driverOpts Map<String,String>
    Map of Docker driver specific options.
    labels Map<String,String>
    Map of custom metadata to add to your Docker volume.
    scope String
    Scope for the Docker volume, which determines its lifecycle, either task or shared. 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.
    autoprovision boolean
    If this value is true, the Docker volume is created if it does not already exist. Note: This field is only used if the scope is shared.
    driver string
    Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement.
    driverOpts {[key: string]: string}
    Map of Docker driver specific options.
    labels {[key: string]: string}
    Map of custom metadata to add to your Docker volume.
    scope string
    Scope for the Docker volume, which determines its lifecycle, either task or shared. 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.
    autoprovision bool
    If this value is true, the Docker volume is created if it does not already exist. Note: This field is only used if the scope is shared.
    driver str
    Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement.
    driver_opts Mapping[str, str]
    Map of Docker driver specific options.
    labels Mapping[str, str]
    Map of custom metadata to add to your Docker volume.
    scope str
    Scope for the Docker volume, which determines its lifecycle, either task or shared. 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.
    autoprovision Boolean
    If this value is true, the Docker volume is created if it does not already exist. Note: This field is only used if the scope is shared.
    driver String
    Docker volume driver to use. The driver value must match the driver name provided by Docker because it is used for task placement.
    driverOpts Map<String>
    Map of Docker driver specific options.
    labels Map<String>
    Map of custom metadata to add to your Docker volume.
    scope String
    Scope for the Docker volume, which determines its lifecycle, either task or shared. 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.

    TaskDefinitionVolumeEfsVolumeConfiguration, TaskDefinitionVolumeEfsVolumeConfigurationArgs

    FileSystemId string
    ID of the EFS File System.
    AuthorizationConfig TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon EFS file system. Detailed below.
    RootDirectory string
    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. This argument is ignored when using authorization_config.
    TransitEncryption string
    Whether or not to enable encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be enabled if Amazon EFS IAM authorization is used. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    TransitEncryptionPort int
    Port to use for transit encryption. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses.
    FileSystemId string
    ID of the EFS File System.
    AuthorizationConfig TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon EFS file system. Detailed below.
    RootDirectory string
    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. This argument is ignored when using authorization_config.
    TransitEncryption string
    Whether or not to enable encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be enabled if Amazon EFS IAM authorization is used. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    TransitEncryptionPort int
    Port to use for transit encryption. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses.
    fileSystemId String
    ID of the EFS File System.
    authorizationConfig TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon EFS file system. Detailed below.
    rootDirectory String
    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. This argument is ignored when using authorization_config.
    transitEncryption String
    Whether or not to enable encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be enabled if Amazon EFS IAM authorization is used. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    transitEncryptionPort Integer
    Port to use for transit encryption. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses.
    fileSystemId string
    ID of the EFS File System.
    authorizationConfig TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon EFS file system. Detailed below.
    rootDirectory string
    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. This argument is ignored when using authorization_config.
    transitEncryption string
    Whether or not to enable encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be enabled if Amazon EFS IAM authorization is used. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    transitEncryptionPort number
    Port to use for transit encryption. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses.
    file_system_id str
    ID of the EFS File System.
    authorization_config TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon EFS file system. Detailed below.
    root_directory str
    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. This argument is ignored when using authorization_config.
    transit_encryption str
    Whether or not to enable encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be enabled if Amazon EFS IAM authorization is used. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    transit_encryption_port int
    Port to use for transit encryption. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses.
    fileSystemId String
    ID of the EFS File System.
    authorizationConfig Property Map
    Configuration block for authorization for the Amazon EFS file system. Detailed below.
    rootDirectory String
    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. This argument is ignored when using authorization_config.
    transitEncryption String
    Whether or not to enable encryption for Amazon EFS data in transit between the Amazon ECS host and the Amazon EFS server. Transit encryption must be enabled if Amazon EFS IAM authorization is used. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    transitEncryptionPort Number
    Port to use for transit encryption. If you do not specify a transit encryption port, it will use the port selection strategy that the Amazon EFS mount helper uses.

    TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfig, TaskDefinitionVolumeEfsVolumeConfigurationAuthorizationConfigArgs

    AccessPointId string
    Access point ID to use. If an access point is specified, the root directory value will be relative to the directory set for the access point. If specified, transit encryption must be enabled in the EFSVolumeConfiguration.
    Iam string
    Whether or not to use the Amazon ECS task IAM role defined in a task definition when mounting the Amazon EFS file system. If enabled, transit encryption must be enabled in the EFSVolumeConfiguration. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    AccessPointId string
    Access point ID to use. If an access point is specified, the root directory value will be relative to the directory set for the access point. If specified, transit encryption must be enabled in the EFSVolumeConfiguration.
    Iam string
    Whether or not to use the Amazon ECS task IAM role defined in a task definition when mounting the Amazon EFS file system. If enabled, transit encryption must be enabled in the EFSVolumeConfiguration. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    accessPointId String
    Access point ID to use. If an access point is specified, the root directory value will be relative to the directory set for the access point. If specified, transit encryption must be enabled in the EFSVolumeConfiguration.
    iam String
    Whether or not to use the Amazon ECS task IAM role defined in a task definition when mounting the Amazon EFS file system. If enabled, transit encryption must be enabled in the EFSVolumeConfiguration. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    accessPointId string
    Access point ID to use. If an access point is specified, the root directory value will be relative to the directory set for the access point. If specified, transit encryption must be enabled in the EFSVolumeConfiguration.
    iam string
    Whether or not to use the Amazon ECS task IAM role defined in a task definition when mounting the Amazon EFS file system. If enabled, transit encryption must be enabled in the EFSVolumeConfiguration. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    access_point_id str
    Access point ID to use. If an access point is specified, the root directory value will be relative to the directory set for the access point. If specified, transit encryption must be enabled in the EFSVolumeConfiguration.
    iam str
    Whether or not to use the Amazon ECS task IAM role defined in a task definition when mounting the Amazon EFS file system. If enabled, transit encryption must be enabled in the EFSVolumeConfiguration. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.
    accessPointId String
    Access point ID to use. If an access point is specified, the root directory value will be relative to the directory set for the access point. If specified, transit encryption must be enabled in the EFSVolumeConfiguration.
    iam String
    Whether or not to use the Amazon ECS task IAM role defined in a task definition when mounting the Amazon EFS file system. If enabled, transit encryption must be enabled in the EFSVolumeConfiguration. Valid values: ENABLED, DISABLED. If this parameter is omitted, the default value of DISABLED is used.

    TaskDefinitionVolumeFsxWindowsFileServerVolumeConfiguration, TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationArgs

    AuthorizationConfig TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon FSx for Windows File Server file system detailed below.
    FileSystemId string
    The Amazon FSx for Windows File Server file system ID to use.
    RootDirectory string
    The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
    AuthorizationConfig TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon FSx for Windows File Server file system detailed below.
    FileSystemId string
    The Amazon FSx for Windows File Server file system ID to use.
    RootDirectory string
    The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
    authorizationConfig TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon FSx for Windows File Server file system detailed below.
    fileSystemId String
    The Amazon FSx for Windows File Server file system ID to use.
    rootDirectory String
    The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
    authorizationConfig TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon FSx for Windows File Server file system detailed below.
    fileSystemId string
    The Amazon FSx for Windows File Server file system ID to use.
    rootDirectory string
    The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
    authorization_config TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfig
    Configuration block for authorization for the Amazon FSx for Windows File Server file system detailed below.
    file_system_id str
    The Amazon FSx for Windows File Server file system ID to use.
    root_directory str
    The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
    authorizationConfig Property Map
    Configuration block for authorization for the Amazon FSx for Windows File Server file system detailed below.
    fileSystemId String
    The Amazon FSx for Windows File Server file system ID to use.
    rootDirectory String
    The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.

    TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfig, TaskDefinitionVolumeFsxWindowsFileServerVolumeConfigurationAuthorizationConfigArgs

    CredentialsParameter string
    The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an AWS Secrets Manager secret or AWS Systems Manager Parameter Store parameter. The ARNs refer to the stored credentials.
    Domain string
    A fully qualified domain name hosted by an AWS Directory Service Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.
    CredentialsParameter string
    The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an AWS Secrets Manager secret or AWS Systems Manager Parameter Store parameter. The ARNs refer to the stored credentials.
    Domain string
    A fully qualified domain name hosted by an AWS Directory Service Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.
    credentialsParameter String
    The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an AWS Secrets Manager secret or AWS Systems Manager Parameter Store parameter. The ARNs refer to the stored credentials.
    domain String
    A fully qualified domain name hosted by an AWS Directory Service Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.
    credentialsParameter string
    The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an AWS Secrets Manager secret or AWS Systems Manager Parameter Store parameter. The ARNs refer to the stored credentials.
    domain string
    A fully qualified domain name hosted by an AWS Directory Service Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.
    credentials_parameter str
    The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an AWS Secrets Manager secret or AWS Systems Manager Parameter Store parameter. The ARNs refer to the stored credentials.
    domain str
    A fully qualified domain name hosted by an AWS Directory Service Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.
    credentialsParameter String
    The authorization credential option to use. The authorization credential options can be provided using either the Amazon Resource Name (ARN) of an AWS Secrets Manager secret or AWS Systems Manager Parameter Store parameter. The ARNs refer to the stored credentials.
    domain String
    A fully qualified domain name hosted by an AWS Directory Service Managed Microsoft AD (Active Directory) or self-hosted AD on Amazon EC2.

    Import

    Using pulumi import, import ECS Task Definitions using their ARNs. For example:

    $ pulumi import aws:ecs/taskDefinition:TaskDefinition example arn:aws:ecs:us-east-1:012345678910:task-definition/mytaskfamily:123
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    AWS Classic pulumi/pulumi-aws
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the aws Terraform Provider.
    aws logo

    Try AWS Native preview for resources not in the classic version.

    AWS Classic v6.41.0 published on Tuesday, Jun 18, 2024 by Pulumi