aws.ecs.getTaskDefinition

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.apply(mongo => 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/v6/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(),
			DesiredCount: pulumi.Int(2),
			TaskDefinition: mongo.ApplyT(func(mongo ecs.GetTaskDefinitionResult) (*string, error) {
				return &mongo.Arn, nil
			}).(pulumi.StringPtrOutput),
		})
		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.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 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(getTaskDefinitionResult -> getTaskDefinitionResult).applyValue(mongo -> mongo.applyValue(getTaskDefinitionResult -> getTaskDefinitionResult.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}

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

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

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

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 CompletableFuture<GetTaskDefinitionResult> getTaskDefinition(GetTaskDefinitionArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

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