getTaskExecution function

Future<GetTaskExecutionResult> getTaskExecution(
  1. GetTaskExecutionArgs args, {
  2. InvokeOptions? options,
})

Data source for managing an AWS ECS (Elastic Container) Task Execution. This data source calls the RunTask API, allowing execution of one-time tasks that don't fit a standard resource lifecycle. See the feature request issue for additional context.

> NOTE on preview operations: This data source calls the RunTask API on every read operation, which means new task(s) may be created from a pulumi preview command if all attributes are known. Placing this functionality behind a data source is an intentional trade off to enable use cases requiring a one-time task execution without relying on provisioners. Caution should be taken to ensure the data source is only executed once, or that the resulting tasks can safely run in parallel.

Example Usage

Basic Usage

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

const example = aws.ecs.getTaskExecution({
    networkConfiguration: {
        subnets: exampleAwsSubnet.map(__item => __item.id),
        securityGroups: [exampleAwsSecurityGroup.id],
        assignPublicIp: false,
    },
    cluster: exampleAwsEcsCluster.id,
    taskDefinition: exampleAwsEcsTaskDefinition.arn,
    desiredCount: 1,
    launchType: "FARGATE",
});
import pulumi
import pulumi_aws as aws

example = aws.ecs.get_task_execution(network_configuration={
        "subnets": [__item["id"] for __item in example_aws_subnet],
        "security_groups": [example_aws_security_group["id"]],
        "assign_public_ip": False,
    },
    cluster=example_aws_ecs_cluster["id"],
    task_definition=example_aws_ecs_task_definition["arn"],
    desired_count=1,
    launch_type="FARGATE")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = Aws.Ecs.GetTaskExecution.Invoke(new()
    {
        NetworkConfiguration = new Aws.Ecs.Inputs.GetTaskExecutionNetworkConfigurationInputArgs
        {
            Subnets = exampleAwsSubnet.Select(__item => __item.Id).ToList(),
            SecurityGroups = new[]
            {
                exampleAwsSecurityGroup.Id,
            },
            AssignPublicIp = false,
        },
        Cluster = exampleAwsEcsCluster.Id,
        TaskDefinition = exampleAwsEcsTaskDefinition.Arn,
        DesiredCount = 1,
        LaunchType = "FARGATE",
    });

});
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 {
_, err := ecs.GetTaskExecution(ctx, &ecs.GetTaskExecutionArgs{
NetworkConfiguration: ecs.GetTaskExecutionNetworkConfiguration{
Subnets: pulumi.StringArray(%!v(PANIC=Format method: fatal: A failure has occurred: unlowered splat expression @ example.pp:2,22-44)),
SecurityGroups: pulumi.StringArray{
exampleAwsSecurityGroup.Id,
},
AssignPublicIp: pulumi.BoolRef(false),
},
Cluster: exampleAwsEcsCluster.Id,
TaskDefinition: exampleAwsEcsTaskDefinition.Arn,
DesiredCount: pulumi.IntRef(1),
LaunchType: pulumi.StringRef("FARGATE"),
}, nil);
if err != nil {
return err
}
return nil
})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

data "aws_ecs_gettaskexecution" "example" {
  network_configuration = {
    subnets          = exampleAwsSubnet[*].id
    security_groups  = [exampleAwsSecurityGroup.id]
    assign_public_ip = false
  }
  cluster         = exampleAwsEcsCluster.id
  task_definition = exampleAwsEcsTaskDefinition.arn
  desired_count   = 1
  launch_type     = "FARGATE"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.ecs.EcsFunctions;
import com.pulumi.aws.ecs.inputs.GetTaskExecutionArgs;
import com.pulumi.aws.ecs.inputs.GetTaskExecutionNetworkConfigurationArgs;
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) {
        final var example = EcsFunctions.getTaskExecution(GetTaskExecutionArgs.builder()
            .networkConfiguration(GetTaskExecutionNetworkConfigurationArgs.builder()
                .subnets(exampleAwsSubnet.stream().map(element -> element.id()).collect(toList()))
                .securityGroups(exampleAwsSecurityGroup.id())
                .assignPublicIp(false)
                .build())
            .cluster(exampleAwsEcsCluster.id())
            .taskDefinition(exampleAwsEcsTaskDefinition.arn())
            .desiredCount(1)
            .launchType("FARGATE")
            .build());

    }
}

args Arguments passed to this invoke. Arguments for getTaskExecution. options Invoke options controlling this call.

Implementation

Future<GetTaskExecutionResult> getTaskExecution(
  GetTaskExecutionArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'aws:ecs/getTaskExecution:getTaskExecution',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetTaskExecutionResult.fromMap(result);
}