getTaskDefinition

AWS v7.43.0, Aug 20 26

Viewing docs for AWS v7.43.0
published on Thursday, Aug 20, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-aws

Viewing docs for AWS v7.43.0
published on Thursday, Aug 20, 2026 by Pulumi

Schema (JSON)

pulumi/pulumi-aws

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const mongoTaskDefinition = new aws.ecs.TaskDefinition("mongo", {
    family: "mongodb",
    containerDefinitions: `[
  {
    \\"cpu\\": 128,
    \\"environment\\": [{
      \\"name\\": \\"SECRET\\",
      \\"value\\": \\"KEY\\"
    }],
    \\"essential\\": true,
    \\"image\\": \\"mongo:latest\\",
    \\"memory\\": 128,
    \\"memoryReservation\\": 64,
    \\"name\\": \\"mongodb\\"
  }
]
`,
});
// Simply specify the family to find the latest ACTIVE revision in that family.
const mongo = aws.ecs.getTaskDefinitionOutput({
    taskDefinition: mongoTaskDefinition.family,
});
const foo = new aws.ecs.Cluster("foo", {name: "foo"});
const mongoService = new aws.ecs.Service("mongo", {
    name: "mongo",
    cluster: foo.id,
    desiredCount: 2,
    taskDefinition: mongo.arn,
});

import pulumi
import pulumi_aws as aws

mongo_task_definition = aws.ecs.TaskDefinition("mongo",
    family="mongodb",
    container_definitions="""[
  {
    \"cpu\": 128,
    \"environment\": [{
      \"name\": \"SECRET\",
      \"value\": \"KEY\"
    }],
    \"essential\": true,
    \"image\": \"mongo:latest\",
    \"memory\": 128,
    \"memoryReservation\": 64,
    \"name\": \"mongodb\"
  }
]
""")
# Simply specify the family to find the latest ACTIVE revision in that family.
mongo = aws.ecs.get_task_definition_output(task_definition=mongo_task_definition.family)
foo = aws.ecs.Cluster("foo", name="foo")
mongo_service = aws.ecs.Service("mongo",
    name="mongo",
    cluster=foo.id,
    desired_count=2,
    task_definition=mongo.arn)

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/ecs"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		mongoTaskDefinition, err := ecs.NewTaskDefinition(ctx, "mongo", &ecs.TaskDefinitionArgs{
			Family: pulumi.String("mongodb"),
			ContainerDefinitions: pulumi.String(`[
  {
    \"cpu\": 128,
    \"environment\": [{
      \"name\": \"SECRET\",
      \"value\": \"KEY\"
    }],
    \"essential\": true,
    \"image\": \"mongo:latest\",
    \"memory\": 128,
    \"memoryReservation\": 64,
    \"name\": \"mongodb\"
  }
]
`),
		})
		if err != nil {
			return err
		}
		// Simply specify the family to find the latest ACTIVE revision in that family.
		mongo := ecs.LookupTaskDefinitionOutput(ctx, ecs.GetTaskDefinitionOutputArgs{
			TaskDefinition: mongoTaskDefinition.Family,
		}, nil)
		foo, err := ecs.NewCluster(ctx, "foo", &ecs.ClusterArgs{
			Name: pulumi.String("foo"),
		})
		if err != nil {
			return err
		}
		_, err = ecs.NewService(ctx, "mongo", &ecs.ServiceArgs{
			Name:           pulumi.String("mongo"),
			Cluster:        foo.ID().ToIDOutput().ToStringOutput(),
			DesiredCount:   pulumi.Int(2),
			TaskDefinition: mongo.Arn(),
		})
		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 mongoTaskDefinition = new Aws.Ecs.TaskDefinition("mongo", new()
    {
        Family = "mongodb",
        ContainerDefinitions = @"[
  {
    \""cpu\"": 128,
    \""environment\"": [{
      \""name\"": \""SECRET\"",
      \""value\"": \""KEY\""
    }],
    \""essential\"": true,
    \""image\"": \""mongo:latest\"",
    \""memory\"": 128,
    \""memoryReservation\"": 64,
    \""name\"": \""mongodb\""
  }
]
",
    });

    // Simply specify the family to find the latest ACTIVE revision in that family.
    var mongo = Aws.Ecs.GetTaskDefinition.Invoke(new()
    {
        TaskDefinition = mongoTaskDefinition.Family,
    });

    var foo = new Aws.Ecs.Cluster("foo", new()
    {
        Name = "foo",
    });

    var mongoService = new Aws.Ecs.Service("mongo", new()
    {
        Name = "mongo",
        Cluster = foo.Id,
        DesiredCount = 2,
        TaskDefinition = mongo.Apply(getTaskDefinitionResult => getTaskDefinitionResult.Arn),
    });

});

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.EcsFunctions;
import com.pulumi.aws.ecs.inputs.GetTaskDefinitionArgs;
import com.pulumi.aws.ecs.Cluster;
import com.pulumi.aws.ecs.ClusterArgs;
import com.pulumi.aws.ecs.Service;
import com.pulumi.aws.ecs.ServiceArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 mongoTaskDefinition = new TaskDefinition("mongoTaskDefinition", TaskDefinitionArgs.builder()
            .family("mongodb")
            .containerDefinitions("""
[
  {
    \"cpu\": 128,
    \"environment\": [{
      \"name\": \"SECRET\",
      \"value\": \"KEY\"
    }],
    \"essential\": true,
    \"image\": \"mongo:latest\",
    \"memory\": 128,
    \"memoryReservation\": 64,
    \"name\": \"mongodb\"
  }
]
            """)
            .build());

        // Simply specify the family to find the latest ACTIVE revision in that family.
        final var mongo = EcsFunctions.getTaskDefinition(GetTaskDefinitionArgs.builder()
            .taskDefinition(mongoTaskDefinition.family())
            .build());

        var foo = new Cluster("foo", ClusterArgs.builder()
            .name("foo")
            .build());

        var mongoService = new Service("mongoService", ServiceArgs.builder()
            .name("mongo")
            .cluster(foo.id())
            .desiredCount(2)
            .taskDefinition(mongo.applyValue(_mongo -> _mongo.arn()))
            .build());

    }
}

resources:
  foo:
    type: aws:ecs:Cluster
    properties:
      name: foo
  mongoTaskDefinition:
    type: aws:ecs:TaskDefinition
    name: mongo
    properties:
      family: mongodb
      containerDefinitions: |
        [
          {
            \"cpu\": 128,
            \"environment\": [{
              \"name\": \"SECRET\",
              \"value\": \"KEY\"
            }],
            \"essential\": true,
            \"image\": \"mongo:latest\",
            \"memory\": 128,
            \"memoryReservation\": 64,
            \"name\": \"mongodb\"
          }
        ]
  mongoService:
    type: aws:ecs:Service
    name: mongo
    properties:
      name: mongo
      cluster: ${foo.id}
      desiredCount: 2 # Track the latest ACTIVE revision
      taskDefinition: ${mongo.arn}
variables:
  # Simply specify the family to find the latest ACTIVE revision in that family.
  mongo:
    fn::invoke:
      function: aws:ecs:getTaskDefinition
      arguments:
        taskDefinition: ${mongoTaskDefinition.family}

pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_ecs_gettaskdefinition" "mongo" {
  task_definition = aws_ecs_taskdefinition.mongo.family
}

resource "aws_ecs_cluster" "foo" {
  name = "foo"
}
resource "aws_ecs_taskdefinition" "mongo" {
  family                = "mongodb"
  container_definitions = "[\n  {\n    \\\"cpu\\\": 128,\n    \\\"environment\\\": [{\n      \\\"name\\\": \\\"SECRET\\\",\n      \\\"value\\\": \\\"KEY\\\"\n    }],\n    \\\"essential\\\": true,\n    \\\"image\\\": \\\"mongo:latest\\\",\n    \\\"memory\\\": 128,\n    \\\"memoryReservation\\\": 64,\n    \\\"name\\\": \\\"mongodb\\\"\n  }\n]\n"
}
resource "aws_ecs_service" "mongo" {
  name          = "mongo"
  cluster       = aws_ecs_cluster.foo.id
  desired_count = 2
  # Track the latest ACTIVE revision
  task_definition = data.aws_ecs_gettaskdefinition.mongo.arn
}
# Simply specify the family to find the latest ACTIVE revision in that family.

Using getTaskDefinition

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getTaskDefinition(args: GetTaskDefinitionArgs, opts?: InvokeOptions): Promise<GetTaskDefinitionResult>
function getTaskDefinitionOutput(args: GetTaskDefinitionOutputArgs, opts?: InvokeOutputOptions): Output<GetTaskDefinitionResult>

def get_task_definition(region: Optional[str] = None,
                        task_definition: Optional[str] = None,
                        opts: Optional[InvokeOptions] = None) -> GetTaskDefinitionResult
def get_task_definition_output(region: pulumi.Input[Optional[str]] = None,
                        task_definition: pulumi.Input[Optional[str]] = None,
                        opts: Optional[InvokeOutputOptions] = None) -> Output[GetTaskDefinitionResult]

func LookupTaskDefinition(ctx *Context, args *LookupTaskDefinitionArgs, opts ...InvokeOption) (*LookupTaskDefinitionResult, error)
func LookupTaskDefinitionOutput(ctx *Context, args *LookupTaskDefinitionOutputArgs, opts ...InvokeOption) LookupTaskDefinitionResultOutput

> Note: This function is named LookupTaskDefinition in the Go SDK.

public static class GetTaskDefinition 
{
    public static Task<GetTaskDefinitionResult> InvokeAsync(GetTaskDefinitionArgs args, InvokeOptions? opts = null)
    public static Output<GetTaskDefinitionResult> Invoke(GetTaskDefinitionInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetTaskDefinitionResult> Invoke(GetTaskDefinitionInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetTaskDefinitionResult> getTaskDefinition(GetTaskDefinitionArgs args, InvokeOptions options)
public static Output<GetTaskDefinitionResult> getTaskDefinition(GetTaskDefinitionArgs args, InvokeOptions options)
public static Output<GetTaskDefinitionResult> getTaskDefinition(GetTaskDefinitionArgs args, InvokeOutputOptions options)

fn::invoke:
  function: aws:ecs/getTaskDefinition:getTaskDefinition
  arguments:
    # arguments dictionary

data "aws_ecs_get_task_definition" "name" {
    # arguments
}

The following arguments are supported:

TaskDefinition string: Family for the latest ACTIVE revision, family and revision (family:revision) for a specific revision in the family, the ARN of the task definition to access to.
Region string: Region where this resource will be managed. Defaults to the Region set in the provider configuration.

TaskDefinition string: Family for the latest ACTIVE revision, family and revision (family:revision) for a specific revision in the family, the ARN of the task definition to access to.
Region string: Region where this resource will be managed. Defaults to the Region set in the provider configuration.

task_definition string: Family for the latest ACTIVE revision, family and revision (family:revision) for a specific revision in the family, the ARN of the task definition to access to.
region string: Region where this resource will be managed. Defaults to the Region set in the provider configuration.

taskDefinition String: Family for the latest ACTIVE revision, family and revision (family:revision) for a specific revision in the family, the ARN of the task definition to access to.
region String: Region where this resource will be managed. Defaults to the Region set in the provider configuration.

taskDefinition string: Family for the latest ACTIVE revision, family and revision (family:revision) for a specific revision in the family, the ARN of the task definition to access to.
region string: Region where this resource will be managed. Defaults to the Region set in the provider configuration.

task_definition str: Family for the latest ACTIVE revision, family and revision (family:revision) for a specific revision in the family, the ARN of the task definition to access to.
region str: Region where this resource will be managed. Defaults to the Region set in the provider configuration.

taskDefinition String: Family for the latest ACTIVE revision, family and revision (family:revision) for a specific revision in the family, the ARN of the task definition to access to.
region String: Region where this resource will be managed. Defaults to the Region set in the provider configuration.