@pulumi/awsx
Version:
[](https://github.com/pulumi/pulumi-awsx/actions) [](https://slack.pulumi.com) [ • 33.2 kB
TypeScript
import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi";
import * as lb from "../lb";
export interface ContainerPortMappingProvider {
containerPortMapping(name: string, parent: pulumi.Resource): pulumi.Input<aws.ecs.PortMapping>;
}
export interface ContainerLoadBalancer {
containerPort: pulumi.Input<number>;
elbName?: pulumi.Input<string>;
targetGroupArn?: pulumi.Input<string>;
}
export interface ContainerLoadBalancerProvider {
containerLoadBalancer(name: string, parent: pulumi.Resource): pulumi.Input<ContainerLoadBalancer>;
}
/**
* See https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KeyValuePair.html
* for more details.
*/
export interface KeyValuePair {
/**
* The name of the key-value pair. For environment variables, this is the name of the
* environment variable.
*/
name: pulumi.Input<string>;
/**
* The value of the key-value pair. For environment variables, this is the value of the
* environment variable.
*/
value: pulumi.Input<string>;
}
/**
* See https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_EnvironmentFile.html
* for more details.
*/
export interface EnvironmentFile {
/**
* The file type to use. The only supported value is s3.
*/
type: "s3";
/**
* The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment
* variable file.
*/
value: string;
}
/**
* See https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDependency.html
* for more details.
*/
export interface ContainerDependency {
/**
* The dependency condition of the container. The following are the available conditions and
* their behavior: START - This condition emulates the behavior of links and volumes today.
* It validates that a dependent container is started before permitting other containers to
* start. COMPLETE - This condition validates that a dependent container runs to completion
* (exits) before permitting other containers to start. This can be useful for nonessential
* containers that run a script and then exit. SUCCESS - This condition is the same as
* COMPLETE, but it also requires that the container exits with a zero status. HEALTHY - This
* condition validates that the dependent container passes its Docker health check before
* permitting other containers to start. This requires that the dependent container has
* health checks configured. This condition is confirmed only at task startup.
*/
condition?: pulumi.Input<"START" | "COMPLETE" | "SUCCESS" | "HEALTHY">;
/**
* The name of a container.
*/
containerName: pulumi.Input<string>;
}
/**
* See https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_FirelensConfiguration.html
* for more details
*/
export interface FirelensConfiguration {
/**
* The options to use when configuring the log router. This field is optional and can be used to specify a custom
* configuration file or to add additional metadata, such as the task, task definition, cluster, and container
* instance details to the log event.
*/
options?: {
[key: string]: string;
};
/**
* The log router to use.
*/
type: pulumi.Input<"fluentd" | "fluentbit">;
}
/**
* [Container]s are used in [awsx.ec2.TaskDefinition] to describe the different containers that are
* launched as part of a task.
*
* See https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDefinition.html for
* more details.
*/
export interface Container {
/**
* The command that is passed to the container.
*
* This parameter maps to `Cmd` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the COMMAND
* parameter to [docker-run](https://docs.docker.com/engine/reference/run/). For more
* information, see https://docs.docker.com/engine/reference/builder/#cmd. If there are multiple
* arguments, each argument should be a separated string in the array.
*/
command?: pulumi.Input<string[]>;
/**
* The number of cpu units reserved for the container. This parameter maps to CpuShares in the
* Create a container section of the Docker Remote API and the --cpu-shares option to docker
* run.
*
* This parameter maps to `CpuShares` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--cpu-shared` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
cpu?: pulumi.Input<number>;
/**
* The dependencies defined for container startup and shutdown. A container can contain multiple
* dependencies. When a dependency is defined for container startup, for container shutdown it
* is reversed.
*
* For tasks using the EC2 launch type, the container instances require at least version 1.26.0
* of the container agent to enable container dependencies. However, we recommend using the
* latest container agent version. For information about checking your agent version and
* updating to the latest version, see Updating the Amazon ECS Container Agent in the Amazon
* Elastic Container Service Developer Guide. If you are using an Amazon ECS-optimized Linux
* AMI, your instance needs at least version 1.26.0-1 of the ecs-init package. If your container
* instances are launched from version 20190301 or later, then they contain the required
* versions of the container agent and ecs-init. For more information, see Amazon ECS-optimized
* Linux AMI in the Amazon Elastic Container Service Developer Guide.
*
* For tasks using the Fargate launch type, the task or service requires platform version 1.3.0
* or later.
*/
dependsOn?: pulumi.Input<ContainerDependency[]>;
/**
* When this parameter is true, networking is disabled within the container.
*
* This parameter maps to `NetworkDisabled` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/).
*
* Note: This parameter is not supported for Windows containers.
*/
disableNetworking?: pulumi.Input<boolean>;
/**
* A list of DNS search domains that are presented to the container.
*
* This parameter maps to `DnsSearch` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--dns-search` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Note: This parameter is not supported for Windows containers.
*/
dnsSearchDomains?: pulumi.Input<string[]>;
/**
* A list of DNS servers that are presented to the container.
*
* This parameter maps to `Dns` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the `--dns`
* parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Note: This parameter is not supported for Windows containers.
*/
dnsServers?: pulumi.Input<string[]>;
/**
* A key/value map of labels to add to the container.
*
* This parameter maps to `Labels` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--label` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
dockerLabels?: pulumi.Input<{
[label: string]: string;
}>;
/**
* A list of strings to provide custom labels for SELinux and AppArmor multi-level security
* systems. This field is not valid for containers in tasks using the Fargate launch type.
*
* This parameter maps to `SecurityOpt` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--security-opt` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
dockerSecurityOptions?: pulumi.Input<string[]>;
/**
* The entry point that is passed to the container.
*
* This parameter maps to `Entrypoint` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--entrypoint` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Important: Early versions of the Amazon ECS container agent do not properly handle entryPoint
* parameters. If you have problems using entryPoint, update your container agent or enter your
* commands and arguments as command array items instead.
*/
entryPoint?: pulumi.Input<string[]>;
/**
* The environment variables to pass to a container.
*
* This parameter maps to `Env` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the `--env`
* parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Important: We do not recommend using plaintext environment variables for sensitive
* information, such as credential data.
*/
environment?: pulumi.Input<KeyValuePair[]>;
/**
* A list of files containing the environment variables to pass to a container.
* This parameter maps to the --env-file option to docker run.
*
* You can specify up to ten environment files. The file must have a .env file extension. Each line in
* an environment file should contain an environment variable in VARIABLE=VALUE format. Lines beginning
* with # are treated as comments and are ignored. For more information on the environment variable file
* syntax, see [Declare default environment variables in file](https://docs.docker.com/compose/env-file/).
*
* If there are environment variables specified using the environment parameter in a container definition,
* they take precedence over the variables contained within an environment file. If multiple environment
* files are specified that contain the same variable, they are processed from the top down. It is
* recommended to use unique variable names. For more information, see [Specifying Environment
* Variables](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/taskdef-envfiles.html)
* in the Amazon Elastic Container Service Developer Guide.
*/
environmentFiles?: pulumi.Input<EnvironmentFile[]>;
/**
* If the essential parameter of a container is marked as true, and that container fails or
* stops for any reason, all other containers that are part of the task are stopped. If the
* essential parameter of a container is marked as false, then its failure does not affect the
* rest of the containers in a task. If this parameter is omitted, a container is assumed to be
* essential.
*
* All tasks must have at least one essential container. If you have an application that is
* composed of multiple containers, you should group containers that are used for a common
* purpose into components, and separate the different components into multiple task
* definitions. For more information, see
* [Application-Architecture](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html)
* in the Amazon Elastic Container Service Developer Guide.
*/
essential?: pulumi.Input<boolean>;
/**
* A list of hostnames and IP address mappings to append to the /etc/hosts file on the
* container.
*
* This parameter maps to `ExtraHosts` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--add-host` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Note: This parameter is not supported for Windows containers or tasks that use the awsvpc
* network mode.
*/
extraHosts?: pulumi.Input<aws.ecs.HostEntry[]>;
/**
* The FireLens configuration for the container. This is used to specify and configure a log router for container
* logs. For more information, see [Custom Route Logging](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html)
* in the Amazon Elastic Container Service Developer Guide.
*/
firelensConfiguration?: pulumi.Input<FirelensConfiguration>;
/**
* The health check command and associated configuration parameters for the container. This
* parameter maps to `HealthCheck` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `HEALTHCHECK` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
healthCheck?: pulumi.Input<aws.ecs.HealthCheck>;
/**
* The hostname to use for your container. container.
*
* This parameter maps to `Hostname` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--hostname` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
hostname?: pulumi.Input<string>;
/**
* When this parameter is true, this allows you to deploy containerized applications that
* require stdin or a tty to be allocated. This parameter maps to OpenStdin in the Create a
* container section of the Docker Remote API and the --interactive option to docker run.
*/
interactive?: pulumi.Input<boolean>;
/**
* The links parameter allows containers to communicate with each other without the need for
* port mappings. This parameter is only supported if the network mode of a task definition is
* bridge. The name:internalName construct is analogous to name:alias in Docker links. Up to 255
* letters (uppercase and lowercase), numbers, and hyphens are allowed. For more information
* about linking Docker containers, go to Legacy container links in the Docker documentation.
*
* This parameter maps to `Links` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--link` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Note: This parameter is not supported for Windows containers.
*
* Important: Containers that are collocated on a single container instance may be able to
* communicate with each other without requiring links or host port mappings. Network isolation
* is achieved on the container instance using security groups and VPC settings.
*/
links?: pulumi.Input<string[]>;
/**
* Linux-specific modifications that are applied to the container, such as Linux kernel
* capabilities. For more information see
* [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).
*
*/
linuxParameters?: pulumi.Input<aws.ecs.LinuxParameters>;
/**
* The log configuration specification for the container. By default, containers use the same
* logging driver that the Docker daemon uses. However the container may use a different logging
* driver than the Docker daemon by specifying a log driver with this parameter in the container
* definition. To use a different logging driver for a container, the log system must be
* configured properly on the container instance (or on a different log server for remote
* logging options). For more information on the options for different supported log drivers,
* see [Configure-logging-drivers](https://docs.docker.com/engine/admin/logging/overview/) in
* the Docker documentation.
*
* This parameter maps to `LogConfig` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--log-driver` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
logConfiguration?: pulumi.Input<aws.ecs.LogConfiguration>;
/**
* The amount (in MiB) of memory to present to the container. If your container attempts to
* exceed the memory specified here, the container is killed. The total amount of memory
* reserved for all containers within a task must be lower than the task memory value, if one is
* specified.
*
* If using the Fargate launch type, this parameter is optional.
*
* If using the EC2 launch type, you must specify either a task-level memory value or a
* container-level memory value. If you specify both a container-level memory and
* memoryReservation value, memory must be greater than memoryReservation. If you specify
* memoryReservation, then that value is subtracted from the available memory resources for the
* container instance on which the container is placed. Otherwise, the value of memory is used.
*
* The Docker daemon reserves a minimum of 4 MiB of memory for a container, so you should not
* specify fewer than 4 MiB of memory for your containers.
*
* This parameter maps to `Memory` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--memory` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
memory?: pulumi.Input<number>;
/**
* The soft limit (in MiB) of memory to reserve for the container. When system memory is under
* heavy contention, Docker attempts to keep the container memory to this soft limit. However,
* your container can consume more memory when it needs to, up to either the hard limit
* specified with the memory parameter (if applicable), or all of the available memory on the
* container instance, whichever comes first.
*
* If a task-level memory value is not specified, you must specify a non-zero integer for one or
* both of memory or memoryReservation in a container definition. If you specify both, memory
* must be greater than memoryReservation. If you specify memoryReservation, then that value is
* subtracted from the available memory resources for the container instance on which the
* container is placed. Otherwise, the value of memory is used.
*
* For example, if your container normally uses 128 MiB of memory, but occasionally bursts to
* 256 MiB of memory for short periods of time, you can set a memoryReservation of 128 MiB, and
* a memory hard limit of 300 MiB. This configuration would allow the container to only reserve
* 128 MiB of memory from the remaining resources on the container instance, but also allow the
* container to consume more memory resources when needed.
*
* The Docker daemon reserves a minimum of 4 MiB of memory for a container, so you should not
* specify fewer than 4 MiB of memory for your containers.
*
* This parameter maps to `MemoryReservation` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--memory-reservation` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
memoryReservation?: pulumi.Input<number>;
/**
* The mount points for data volumes in your container.
*
* This parameter maps to `Volumes` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--volume` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
mountPoints?: pulumi.Input<aws.ecs.MountPoint[]>;
/**
* When this parameter is true, the container is given elevated privileges on the host container
* instance (similar to the root user).
*
* This parameter maps to `Privileged` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--privileged` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Note: This parameter is not supported for Windows containers or tasks using the Fargate
* launch type.
*/
privileged?: pulumi.Input<boolean>;
/**
* When this parameter is true, a TTY is allocated. This parameter maps to `Tty` in the [Create
* a container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
* the [Docker Remote API](https://docs.docker.com/engine/api/v1.35/) and the `--tty` option to
* [docker run](https://docs.docker.com/engine/reference/run/).
*/
pseudoTerminal?: pulumi.Input<boolean>;
/**
* When this parameter is true, the container is given read-only access to its root file system.
*
* This parameter maps to `ReadonlyRootfs` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--read-only` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Note: This parameter is not supported for Windows containers.
*/
readonlyRootFilesystem?: pulumi.Input<boolean>;
/**
* The private repository authentication credentials to use.
*/
repositoryCredentials?: pulumi.Input<aws.ecs.RepositoryCredentials>;
/**
* The type and amount of a resource to assign to a container. The only supported resource is a
* GPU.
*/
resourceRequirements?: pulumi.Input<aws.ecs.ResourceRequirements[]>;
/**
* The secrets to pass to the container. For more information, see
* [Specifying-Sensitive-Data](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data.html)
* in the Amazon Elastic Container Service Developer Guide.
*/
secrets?: pulumi.Input<aws.ecs.Secret[]>;
/**
* Time duration (in seconds) to wait before giving up on resolving dependencies for a
* container. For example, you specify two containers in a task definition with containerA
* having a dependency on containerB reaching a `COMPLETE`, `SUCCESS`, or `HEALTHY` status. If a
* startTimeout value is specified for containerB and it does not reach the desired status
* within that time then containerA will give up and not start. This results in the task
* transitioning to a `STOPPED` state.
*
* For tasks using the EC2 launch type, the container instances require at least version 1.26.0
* of the container agent to enable a container start timeout value. However, we recommend using
* the latest container agent version. For information about checking your agent version and
* updating to the latest version, see [Updating the Amazon ECS Container
* Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in
* the Amazon Elastic Container Service Developer Guide. If you are using an Amazon
* ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the ecs-init
* package. If your container instances are launched from version 20190301 or later, then they
* contain the required versions of the container agent and ecs-init. For more information, see
* [Amazon ECS-optimized Linux
* AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in
* the Amazon Elastic Container Service Developer Guide.
*
* For tasks using the Fargate launch type, the task or service requires platform version
* `1.3.0` or later.
*/
startTimeout?: pulumi.Input<number>;
/**
* Time duration (in seconds) to wait before the container is forcefully killed if it doesn't
* exit normally on its own.
*
* For tasks using the Fargate launch type, the max `stopTimeout` value is 2 minutes and the
* task or service requires platform version `1.3.0` or later.
*
* For tasks using the EC2 launch type, the stop timeout value for the container takes
* precedence over the `ECS_CONTAINER_STOP_TIMEOUT` container agent configuration parameter, if
* used. Container instances require at least version 1.26.0 of the container agent to enable a
* container stop timeout value. However, we recommend using the latest container agent version.
* For information about checking your agent version and updating to the latest version, see
* [Updating the Amazon ECS Container
* Agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in
* the Amazon Elastic Container Service Developer Guide. If you are using an Amazon
* ECS-optimized Linux AMI, your instance needs at least version 1.26.0-1 of the ecs-init
* package. If your container instances are launched from version 20190301 or later, then they
* contain the required versions of the container agent and ecs-init. For more information, see
* [Amazon ECS-optimized Linux
* AMI](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) in
* the Amazon Elastic Container Service Developer Guide.
*/
stopTimeout?: pulumi.Input<number>;
/**
* A list of namespaced kernel parameters to set in the container. This parameter maps to
* `Sysctls` in the [Create a
* container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate) section of
* the [Docker Remote API](https://docs.docker.com/engine/api/v1.35/) and the `--sysctl` option
* to [`docker run`](https://docs.docker.com/engine/reference/run/).
*
* *Note*: It is not recommended that you specify network-related `systemControls` parameters
* for multiple containers in a single task that also uses either the `awsvpc` or `host` network
* modes. For tasks that use the `awsvpc` network mode, the container that is started last
* determines which `systemControls` parameters take effect. For tasks that use the host network
* mode, it changes the container instance's namespaced kernel parameters as well as the
* containers.
*/
systemControls?: pulumi.Input<aws.ecs.SystemControl[]>;
/**
* A list of ulimits to set in the container.
*
* This parameter requires version 1.18 of the Docker Remote API or greater on your container
* instance. To check the Docker Remote API version on your container instance, log in to your
* container instance and run the following command: sudo docker version --format
* '{{.Server.APIVersion}}'
*
* This parameter maps to `Ulimits` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--ulimit` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*
* Note: This parameter is not supported for Windows containers.
*/
ulimits?: pulumi.Input<aws.ecs.Ulimit[]>;
/**
* The user name to use inside the container.
*
* This parameter maps to `User` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--user` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
user?: pulumi.Input<string>;
/**
* Data volumes to mount from another container.
*
* This parameter maps to `VolumesFrom` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--volumes-from` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
volumesFrom?: pulumi.Input<aws.ecs.VolumeFrom[]>;
/**
* The working directory in which to run commands inside the container.
*
* This parameter maps to `WorkingDir` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--workdir` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
workingDirectory?: pulumi.Input<string>;
/**
* The image id to use for the container. If this is provided then the image with this idq will
* be pulled from Docker Hub. To provide customized image retrieval, provide [imageProvide]
* which can do whatever custom work is necessary. See [Image] for common ways to create an
* image from a local docker build.
*/
image: pulumi.Input<string> | ContainerImageProvider;
/**
* The list of port mappings for the container. Port mappings allow containers to access ports
* on the host container instance to send or receive traffic.
*
* If this container will be run in an `ecs.Service` that will be hooked up to an
* `lb.LoadBalancer` (either an ALB or NLB) the appropriate `lb.Listener` or `lb.TargetGroup`
* can be passed in here instead and the port mapping will be computed from it.
*
* Alternatively, to simplify the common case of having to create load balancer listeners solely
* for this purpose, the information listener can be provided directly in the container
* definition using `applicationListener` or `networkListener`. If those properties are
* provided, then `portMappings` should not be provided.
*
* For task definitions that use the awsvpc network mode, you should only specify the
* containerPort. The hostPort can be left blank or it must be the same value as the
* containerPort.
*
* Port mappings on Windows use the NetNAT gateway address rather than localhost. There is no
* loopback for port mappings on Windows, so you cannot access a container's mapped port from
* the host itself.
*
* If the network mode of a task definition is set to none, then you can't specify port
* mappings. If the network mode of a task definition is set to host, then host ports must
* either be undefined or they must match the container port in the port mapping.
*
* This parameter maps to `PortBindings` in the
* [Create-a-container](https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate)
* section of the [Docker-Remote-API](https://docs.docker.com/engine/api/v1.35/) and the
* `--publish` parameter to [docker-run](https://docs.docker.com/engine/reference/run/).
*/
portMappings?: (pulumi.Input<aws.ecs.PortMapping> | ContainerPortMappingProvider)[];
/**
* Alternative to passing in `portMappings`. If a listener (or args to create a listener) is
* passed in, it will be used instead.
*/
applicationListener?: lb.ApplicationListener | lb.ApplicationListenerArgs;
/**
* Alternative to passing in `portMappings`. If a listener (or args to create a listener) is
* passed in, it will be used instead.
*/
networkListener?: lb.NetworkListener | lb.NetworkListenerArgs;
}
export interface ContainerImageProvider {
image(name: string, parent: pulumi.Resource): pulumi.Input<string>;
environment(name: string, parent: pulumi.Resource): pulumi.Input<KeyValuePair[]>;
}