ECS (Elastic Container Service)

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 com.pulumi.aws.ecs.TaskDefinition;
import com.pulumi.aws.ecs.TaskDefinitionArgs;
import com.pulumi.aws.ecs.CapacityProvider;
import com.pulumi.aws.ecs.CapacityProviderArgs;
import com.pulumi.aws.ecs.EcsFunctions;

@ResourceType(type="aws:ecs/cluster:Cluster")
public class Cluster extends com.pulumi.resources.CustomResource {
    public Cluster(String name);
    public Cluster(String name, @Nullable ClusterArgs args);

    public Output<String> id();
    public Output<String> arn();
    public Output<String> name();
}

public class ClusterArgs extends com.pulumi.resources.ResourceArgs {
    public static Builder builder() { return new Builder(); }

    public static final class Builder {
        public Builder name(Output<String> name);
        public Builder settings(Output<List<ClusterSettingArgs>> settings);
        public Builder configuration(Output<ClusterConfigurationArgs> configuration);
        public Builder tags(Output<Map<String, String>> tags);

        public ClusterArgs build();
    }
}

@ResourceType(type="aws:ecs/taskDefinition:TaskDefinition")
public class TaskDefinition extends com.pulumi.resources.CustomResource {
    public TaskDefinition(String name, TaskDefinitionArgs args);

    public Output<String> arn();
    public Output<String> family();
    public Output<Integer> revision();
    public Output<String> containerDefinitions();
    public Output<Optional<String>> taskRoleArn();
    public Output<Optional<String>> executionRoleArn();
    public Output<Optional<String>> networkMode();
    public Output<Optional<String>> cpu();
    public Output<Optional<String>> memory();
}

public class TaskDefinitionArgs extends com.pulumi.resources.ResourceArgs {
    public static Builder builder() { return new Builder(); }

    public static final class Builder {
        public Builder family(Output<String> family);
        public Builder containerDefinitions(Output<String> containerDefinitions);
        public Builder taskRoleArn(Output<String> taskRoleArn);
        public Builder executionRoleArn(Output<String> executionRoleArn);
        public Builder networkMode(Output<String> networkMode);
        public Builder requiresCompatibilities(Output<List<String>> requiresCompatibilities);
        public Builder cpu(Output<String> cpu);
        public Builder memory(Output<String> memory);
        public Builder volumes(Output<List<TaskDefinitionVolumeArgs>> volumes);
        public Builder runtimePlatform(Output<TaskDefinitionRuntimePlatformArgs> runtimePlatform);
        public Builder tags(Output<Map<String, String>> tags);

        public TaskDefinitionArgs build();
    }
}

@ResourceType(type="aws:ecs/service:Service")
public class Service extends com.pulumi.resources.CustomResource {
    public Service(String name, ServiceArgs args);

    public Output<String> id();
    public Output<String> name();
    public Output<String> cluster();
    public Output<String> taskDefinition();
    public Output<Optional<Integer>> desiredCount();
    public Output<Optional<String>> launchType();
}

public class ServiceArgs extends com.pulumi.resources.ResourceArgs {
    public static Builder builder() { return new Builder(); }

    public static final class Builder {
        public Builder name(Output<String> name);
        public Builder cluster(Output<String> cluster);
        public Builder taskDefinition(Output<String> taskDefinition);
        public Builder desiredCount(Output<Integer> desiredCount);
        public Builder launchType(Output<String> launchType);
        public Builder networkConfiguration(Output<ServiceNetworkConfigurationArgs> networkConfiguration);
        public Builder loadBalancers(Output<List<ServiceLoadBalancerArgs>> loadBalancers);
        public Builder capacityProviderStrategies(Output<List<ServiceCapacityProviderStrategyArgs>> capacityProviderStrategies);
        public Builder deploymentConfiguration(Output<ServiceDeploymentConfigurationArgs> deploymentConfiguration);
        public Builder tags(Output<Map<String, String>> tags);

        public ServiceArgs build();
    }
}

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.aws.ecs.*;
import com.pulumi.aws.ecs.inputs.*;
import java.util.Map;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // Create ECS cluster
        var cluster = new Cluster("my-cluster", ClusterArgs.builder()
            .name("my-app-cluster")
            .settings(ClusterSettingArgs.builder()
                .name("containerInsights")
                .value("enabled")
                .build())
            .build());

        // Create task definition
        var taskDefinition = new TaskDefinition("app-task", TaskDefinitionArgs.builder()
            .family("app-family")
            .networkMode("awsvpc")
            .requiresCompatibilities("FARGATE")
            .cpu("256")
            .memory("512")
            .executionRoleArn(executionRole.arn())
            .taskRoleArn(taskRole.arn())
            .containerDefinitions("""
                [{
                  "name": "app",
                  "image": "nginx:latest",
                  "portMappings": [{
                    "containerPort": 80,
                    "protocol": "tcp"
                  }],
                  "logConfiguration": {
                    "logDriver": "awslogs",
                    "options": {
                      "awslogs-group": "/ecs/app",
                      "awslogs-region": "us-east-1",
                      "awslogs-stream-prefix": "ecs"
                    }
                  }
                }]
                """)
            .build());

        // Create ECS service
        var service = new Service("app-service", ServiceArgs.builder()
            .name("app-service")
            .cluster(cluster.arn())
            .taskDefinition(taskDefinition.arn())
            .desiredCount(2)
            .launchType("FARGATE")
            .networkConfiguration(ServiceNetworkConfigurationArgs.builder()
                .subnets(subnetIds)
                .securityGroups(securityGroupId)
                .assignPublicIp(true)
                .build())
            .build());

        ctx.export("clusterArn", cluster.arn());
        ctx.export("serviceId", service.id());
    }
}