{
  "tagging" : {
    "permissions" : [ "ecs:TagResource", "ecs:UntagResource", "ecs:ListTagsForResource" ],
    "taggable" : true,
    "tagOnCreate" : true,
    "tagUpdatable" : true,
    "tagProperty" : "/properties/Tags",
    "cloudFormationSystemTags" : true
  },
  "propertyTransform" : {
    "/properties/ExecutionRoleArn" : "ExecutionRoleArn $OR $join([\"arn:(aws)[-]{0,1}[a-z]{0,3}[-]{0,1}[a-z]{0,3}:iam::[0-9]{12}[:]role/\", ExecutionRoleArn])",
    "/properties/TaskRoleArn" : "TaskRoleArn $OR $split(TaskRoleArn, \"role/\")[-1] $OR $join([\"arn:(aws)[-]{0,1}[a-z]{0,3}[-]{0,1}[a-z]{0,3}:iam::[0-9]{12}[:]role/\", TaskRoleArn])"
  },
  "handlers" : {
    "read" : {
      "permissions" : [ "ecs:DescribeDaemonTaskDefinition", "ecs:ListTagsForResource" ]
    },
    "create" : {
      "permissions" : [ "ecs:RegisterDaemonTaskDefinition", "ecs:DescribeDaemonTaskDefinition", "ecs:TagResource", "iam:PassRole" ]
    },
    "update" : {
      "permissions" : [ "ecs:TagResource", "ecs:UntagResource", "ecs:ListTagsForResource", "ecs:DescribeDaemonTaskDefinition", "iam:PassRole" ]
    },
    "list" : {
      "permissions" : [ "ecs:ListDaemonTaskDefinitions", "ecs:DescribeDaemonTaskDefinition" ]
    },
    "delete" : {
      "permissions" : [ "ecs:DeleteDaemonTaskDefinition", "ecs:DescribeDaemonTaskDefinition", "iam:PassRole" ]
    }
  },
  "typeName" : "AWS::ECS::DaemonTaskDefinition",
  "readOnlyProperties" : [ "/properties/DaemonTaskDefinitionArn" ],
  "description" : "The details of a daemon task definition. A daemon task definition is a template that describes the containers that form a daemon. Daemons deploy cross-cutting software agents independently across your Amazon ECS infrastructure.",
  "createOnlyProperties" : [ "/properties/Family", "/properties/ContainerDefinitions", "/properties/Cpu", "/properties/Memory", "/properties/ExecutionRoleArn", "/properties/TaskRoleArn", "/properties/Volumes", "/properties/PidMode", "/properties/IpcMode" ],
  "additionalProperties" : false,
  "primaryIdentifier" : [ "/properties/DaemonTaskDefinitionArn" ],
  "definitions" : {
    "RepositoryCredentials" : {
      "description" : "The repository credentials for private registry authentication.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "CredentialsParameter" : {
          "description" : "The Amazon Resource Name (ARN) of the secret containing the private repository credentials.\n  When you use the Amazon ECS API, CLI, or AWS SDK, if the secret exists in the same Region as the task that you're launching then you can use either the full ARN or the name of the secret. When you use the AWS Management Console, you must specify the full ARN of the secret.",
          "type" : "string"
        }
      }
    },
    "KeyValuePair" : {
      "description" : "A key-value pair object.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Value" : {
          "description" : "The value of the key-value pair. For environment variables, this is the value of the environment variable.",
          "type" : "string"
        },
        "Name" : {
          "description" : "The name of the key-value pair. For environment variables, this is the name of the environment variable.",
          "type" : "string"
        }
      }
    },
    "Device" : {
      "description" : "An object representing a container instance host device.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "HostPath" : {
          "description" : "The path for the device on the host container instance.",
          "type" : "string"
        },
        "Permissions" : {
          "description" : "The explicit permissions to provide to the container for the device. By default, the container has permissions for ``read``, ``write``, and ``mknod`` for the device.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "type" : "string"
          }
        },
        "ContainerPath" : {
          "description" : "The path inside the container at which to expose the host device.",
          "type" : "string"
        }
      }
    },
    "LinuxParameters" : {
      "description" : "The Linux-specific options that are applied to the container, such as Linux [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Capabilities" : {
          "description" : "The Linux capabilities for the container that are added to or dropped from the default configuration provided by Docker.\n  For tasks that use the Fargate launch type, ``capabilities`` is supported for all platform versions but the ``add`` parameter is only supported if using platform version 1.4.0 or later.",
          "$ref" : "#/definitions/KernelCapabilities"
        },
        "Tmpfs" : {
          "description" : "The container path, mount options, and size (in MiB) of the tmpfs mount. This parameter maps to the ``--tmpfs`` option to docker run.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/Tmpfs"
          }
        },
        "Devices" : {
          "description" : "Any host devices to expose to the container. This parameter maps to ``Devices`` in the docker container create command and the ``--device`` option to docker run.\n  If you're using tasks that use the Fargate launch type, the ``devices`` parameter isn't supported.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/Device"
          }
        },
        "InitProcessEnabled" : {
          "description" : "Run an ``init`` process inside the container that forwards signals and reaps processes. This parameter maps to the ``--init`` option to docker run. This parameter requires version 1.25 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}}'``",
          "type" : "boolean"
        }
      }
    },
    "ContainerDependency" : {
      "description" : "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.\n Your Amazon ECS container instances require at least version 1.26.0 of the container agent to use 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](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html) in the *Amazon Elastic Container Service Developer Guide*. If you're 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*.\n  For tasks that use the Fargate launch type, the task or service requires the following platforms:\n  +  Linux platform version ``1.3.0`` or later.\n  +  Windows platform version ``1.0.0`` or later.\n  \n  For more information about how to create a container dependency, see [Container dependency](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/example_task_definitions.html#example_task_definition-containerdependency) in the *Amazon Elastic Container Service Developer Guide*.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Condition" : {
          "description" : "The dependency condition of the container. The following are the available conditions and their behavior:\n  +  ``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.\n  +  ``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. This condition can't be set on an essential container.\n  +  ``SUCCESS`` - This condition is the same as ``COMPLETE``, but it also requires that the container exits with a ``zero`` status. This condition can't be set on an essential container.\n  +  ``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.",
          "type" : "string"
        },
        "ContainerName" : {
          "description" : "The name of a container.",
          "type" : "string"
        }
      }
    },
    "HealthCheck" : {
      "description" : "An object representing a container health check. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image (such as those specified in a parent image or from the image's Dockerfile). This configuration maps to the ``HEALTHCHECK`` parameter of docker run.\n  The Amazon ECS container agent only monitors and reports on the health checks specified in the task definition. Amazon ECS does not monitor Docker health checks that are embedded in a container image and not specified in the container definition. Health check parameters that are specified in a container definition override any Docker health checks that exist in the container image.\n  You can view the health status of both individual containers and a task with the DescribeTasks API operation or when viewing the task details in the console.\n The health check is designed to make sure that your containers survive agent restarts, upgrades, or temporary unavailability.\n Amazon ECS performs health checks on containers with the default that launched the container instance or the task.\n The following describes the possible ``healthStatus`` values for a container:\n  +  ``HEALTHY``-The container health check has passed successfully.\n  +  ``UNHEALTHY``-The container health check has failed.\n  +  ``UNKNOWN``-The container health check is being evaluated, there's no container health check defined, or Amazon ECS doesn't have the health status of the container.\n  \n The following describes the possible ``healthStatus`` values based on the container health checker status of essential containers in the task with the following priority order (high to low):\n  +  ``UNHEALTHY``-One or more essential containers have failed their health check.\n  +  ``UNKNOWN``-Any essential container running within the task is in an ``UNKNOWN`` state and no other essential containers have an ``UNHEALTHY`` state.\n  +  ``HEALTHY``-All essential containers within the task have passed their health checks.\n  \n Consider the following task health example with 2 containers.\n  +  If Container1 is ``UNHEALTHY`` and Container2 is ``UNKNOWN``, the task health is ``UNHEALTHY``.\n  +  If Container1 is ``UNHEALTHY`` and Container2 is ``HEALTHY``, the task health is ``UNHEALTHY``.\n  +  If Container1 is ``HEALTHY`` and Container2 is ``UNKNOWN``, the task health is ``UNKNOWN``.\n  +  If Container1 is ``HEALTHY`` and Container2 is ``HEALTHY``, the task health is ``HEALTHY``.\n  \n Consider the following task health example with 3 containers.\n  +  If Container1 is ``UNHEALTHY`` and Container2 is ``UNKNOWN``, and Container3 is ``UNKNOWN``, the task health is ``UNHEALTHY``.\n  +  If Container1 is ``UNHEALTHY`` and Container2 is ``UNKNOWN``, and Container3 is ``HEALTHY``, the task health is ``UNHEALTHY``.\n  +  If Container1 is ``UNHEALTHY`` and Container2 is ``HEALTHY``, and Container3 is ``HEALTHY``, the task health is ``UNHEALTHY``.\n  +  If Container1 is ``HEALTHY`` and Container2 is ``UNKNOWN``, and Container3 is ``HEALTHY``, the task health is ``UNKNOWN``.\n  +  If Container1 is ``HEALTHY`` and Container2 is ``UNKNOWN``, and Container3 is ``UNKNOWN``, the task health is ``UNKNOWN``.\n  +  If Container1 is ``HEALTHY`` and Container2 is ``HEALTHY``, and Container3 is ``HEALTHY``, the task health is ``HEALTHY``.\n  \n If a task is run manually, and not as part of a service, the task will continue its lifecycle regardless of its health status. For tasks that are part of a service, if the task reports as unhealthy then the task will be stopped and the service scheduler will replace it.\n When a container health check fails for a task that is part of a service, the following process occurs:\n  1.  The task is marked as ``UNHEALTHY``.\n  1.  The unhealthy task will be stopped, and during the stopping process, it will go through the following states:\n  +  ``DEACTIVATING`` - In this state, Amazon ECS performs additional steps before stopping the task. For example, for tasks that are part of services configured to use Elastic Load Balancing target groups, target groups will be deregistered in this state.\n  +  ``STOPPING`` - The task is in the process of being stopped.\n  +  ``DEPROVISIONING`` - Resources associated with the task are being cleaned up.\n  +  ``STOPPED`` - The task has been completely stopped.\n  \n  1.  After the old task stops, a new task will be launched to ensure service operation, and the new task will go through the following lifecycle:\n  +  ``PROVISIONING`` - Resources required for the task are being provisioned.\n  +  ``PENDING`` - The task is waiting to be placed on a container instance.\n  +  ``ACTIVATING`` - In this state, Amazon ECS pulls container images, creates containers, configures task networking, registers load balancer target groups, and configures service discovery status.\n  +  ``RUNNING`` - The task is running and performing its work.\n  \n  \n For more detailed information about task lifecycle states, see [Task lifecycle](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-lifecycle-explanation.html) in the *Amazon Elastic Container Service Developer Guide*.\n The following are notes about container health check support:\n  +  If the Amazon ECS container agent becomes disconnected from the Amazon ECS service, this won't cause a container to transition to an ``UNHEALTHY`` status. This is by design, to ensure that containers remain running during agent restarts or temporary unavailability. The health check status is the \"last heard from\" response from the Amazon ECS agent, so if the container was considered ``HEALTHY`` prior to the disconnect, that status will remain until the agent reconnects and another health check occurs. There are no assumptions made about the status of the container health checks.\n  +  Container health checks require version ``1.17.0`` or greater of the Amazon ECS container agent. For more information, see [Updating the Amazon ECS container agent](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-update.html).\n  +  Container health checks are supported for Fargate tasks if you're using platform version ``1.1.0`` or greater. For more information, see [platform versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html).\n  +  Container health checks aren't supported for tasks that are part of a service that's configured to use a Classic Load Balancer.\n  \n For an example of how to specify a task definition with multiple containers where container dependency is specified, see [Container dependency](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/example_task_definitions.html#example_task_definition-containerdependency) in the *Amazon Elastic Container Service Developer Guide*.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Command" : {
          "description" : "A string array representing the command that the container runs to determine if it is healthy. The string array must start with ``CMD`` to run the command arguments directly, or ``CMD-SHELL`` to run the command with the container's default shell. \n  When you use the AWS Management Console JSON panel, the CLIlong, or the APIs, enclose the list of commands in double quotes and brackets.\n  ``[ \"CMD-SHELL\", \"curl -f http://localhost/ || exit 1\" ]`` \n You don't include the double quotes and brackets when you use the AWS Management Console.\n  ``CMD-SHELL, curl -f http://localhost/ || exit 1`` \n An exit code of 0 indicates success, and non-zero exit code indicates failure. For more information, see ``HealthCheck`` in the docker container create command.",
          "insertionOrder" : true,
          "type" : "array",
          "items" : {
            "type" : "string"
          }
        },
        "Timeout" : {
          "description" : "The time period in seconds to wait for a health check to succeed before it is considered a failure. You may specify between 2 and 60 seconds. The default value is 5. This value applies only when you specify a ``command``.",
          "type" : "integer"
        },
        "Retries" : {
          "description" : "The number of times to retry a failed health check before the container is considered unhealthy. You may specify between 1 and 10 retries. The default value is 3. This value applies only when you specify a ``command``.",
          "type" : "integer"
        },
        "Interval" : {
          "description" : "The time period in seconds between each health check execution. You may specify between 5 and 300 seconds. The default value is 30 seconds. This value applies only when you specify a ``command``.",
          "type" : "integer"
        },
        "StartPeriod" : {
          "description" : "The optional grace period to provide containers time to bootstrap before failed health checks count towards the maximum number of retries. You can specify between 0 and 300 seconds. By default, the ``startPeriod`` is off. This value applies only when you specify a ``command``. \n  If a health check succeeds within the ``startPeriod``, then the container is considered healthy and any subsequent failures count toward the maximum number of retries.",
          "type" : "integer"
        }
      }
    },
    "Ulimit" : {
      "description" : "The ``ulimit`` settings to pass to the container.\n Amazon ECS tasks hosted on FARGATElong use the default resource limit values set by the operating system with the exception of the ``nofile`` resource limit parameter which FARGATElong overrides. The ``nofile`` resource limit sets a restriction on the number of open files that a container can use. The default ``nofile`` soft limit is ``65535`` and the default hard limit is ``65535``.\n You can specify the ``ulimit`` settings for a container in a task definition.",
      "additionalProperties" : false,
      "type" : "object",
      "required" : [ "HardLimit", "Name", "SoftLimit" ],
      "properties" : {
        "SoftLimit" : {
          "description" : "The soft limit for the ``ulimit`` type. The value can be specified in bytes, seconds, or as a count, depending on the ``type`` of the ``ulimit``.",
          "type" : "integer"
        },
        "HardLimit" : {
          "description" : "The hard limit for the ``ulimit`` type. The value can be specified in bytes, seconds, or as a count, depending on the ``type`` of the ``ulimit``.",
          "type" : "integer"
        },
        "Name" : {
          "description" : "The ``type`` of the ``ulimit``.",
          "type" : "string"
        }
      }
    },
    "RestartPolicy" : {
      "description" : "",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "IgnoredExitCodes" : {
          "description" : "",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "type" : "integer"
          }
        },
        "RestartAttemptPeriod" : {
          "description" : "",
          "type" : "integer"
        },
        "Enabled" : {
          "description" : "",
          "type" : "boolean"
        }
      }
    },
    "SystemControl" : {
      "description" : "A list of namespaced kernel parameters to set in the container. This parameter maps to ``Sysctls`` in the docker container create command and the ``--sysctl`` option to docker run. For example, you can configure ``net.ipv4.tcp_keepalive_time`` setting to maintain longer lived connections.\n We don't recommend that you specify network-related ``systemControls`` parameters for multiple containers in a single task that also uses either the ``awsvpc`` or ``host`` network mode. Doing this has the following disadvantages:\n  +  For tasks that use the ``awsvpc`` network mode including Fargate, if you set ``systemControls`` for any container, it applies to all containers in the task. If you set different ``systemControls`` for multiple containers in a single task, the container that's started last determines which ``systemControls`` take effect.\n  +  For tasks that use the ``host`` network mode, the network namespace ``systemControls`` aren't supported.\n  \n If you're setting an IPC resource namespace to use for the containers in the task, the following conditions apply to your system controls. For more information, see [IPC mode](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_ipcmode).\n  +  For tasks that use the ``host`` IPC mode, IPC namespace ``systemControls`` aren't supported.\n  +  For tasks that use the ``task`` IPC mode, IPC namespace ``systemControls`` values apply to all containers within a task.\n  \n  This parameter is not supported for Windows containers.\n   This parameter is only supported for tasks that are hosted on FARGATElong if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Value" : {
          "description" : "The namespaced kernel parameter to set a ``value`` for.\n Valid IPC namespace values: ``\"kernel.msgmax\" | \"kernel.msgmnb\" | \"kernel.msgmni\" | \"kernel.sem\" | \"kernel.shmall\" | \"kernel.shmmax\" | \"kernel.shmmni\" | \"kernel.shm_rmid_forced\"``, and ``Sysctls`` that start with ``\"fs.mqueue.*\"``\n Valid network namespace values: ``Sysctls`` that start with ``\"net.*\"``. Only namespaced ``Sysctls`` that exist within the container starting with \"net.* are accepted.\n All of these values are supported by Fargate.",
          "type" : "string"
        },
        "Namespace" : {
          "description" : "The namespaced kernel parameter to set a ``value`` for.",
          "type" : "string"
        }
      }
    },
    "HostVolumeProperties" : {
      "description" : "Details on a container instance bind mount host volume.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "SourcePath" : {
          "description" : "When the ``host`` parameter is used, specify a ``sourcePath`` to declare the path on the host container instance that's presented to the container. If this parameter is empty, then the Docker daemon has assigned a host path for you. If the ``host`` parameter contains a ``sourcePath`` file location, then the data volume persists at the specified location on the host container instance until you delete it manually. If the ``sourcePath`` value doesn't exist on the host container instance, the Docker daemon creates it. If the location does exist, the contents of the source path folder are exported.\n If you're using the Fargate launch type, the ``sourcePath`` parameter is not supported.",
          "type" : "string"
        }
      }
    },
    "LogConfiguration" : {
      "description" : "The log configuration for the container. This parameter maps to ``LogConfig`` in the docker container create command and the ``--log-driver`` option to docker run.\n By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition.\n Understand the following when specifying a log configuration for your containers.\n  +  Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon. Additional log drivers may be available in future releases of the Amazon ECS container agent.\n For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.\n For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``,``syslog``, ``splunk``, and ``awsfirelens``.\n  +  This parameter requires version 1.18 of the Docker Remote API or greater on your container instance.\n  +  For tasks that are hosted on Amazon EC2 instances, the Amazon ECS container agent must register the available logging drivers with the ``ECS_AVAILABLE_LOGGING_DRIVERS`` environment variable before containers placed on that instance can use these log configuration options. For more information, see [Amazon ECS container agent configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html) in the *Amazon Elastic Container Service Developer Guide*.\n  +  For tasks that are on FARGATElong, because you don't have access to the underlying infrastructure your tasks are hosted on, any additional software needed must be installed outside of the task. For example, the Fluentd output aggregators or a remote host running Logstash to send Gelf logs to.",
      "additionalProperties" : false,
      "type" : "object",
      "required" : [ "LogDriver" ],
      "properties" : {
        "SecretOptions" : {
          "description" : "The secrets to pass to the log configuration. 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*.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/Secret"
          }
        },
        "Options" : {
          "patternProperties" : {
            ".{1,}" : {
              "type" : "string"
            }
          },
          "description" : "The configuration options to send to the log driver.\n The options you can specify depend on the log driver. Some of the options you can specify when you use the ``awslogs`` log driver to route logs to Amazon CloudWatch include the following:\n  + awslogs-create-group Required: No Specify whether you want the log group to be created automatically. If this option isn't specified, it defaults to false. Your IAM policy must include the logs:CreateLogGroup permission before you attempt to use awslogs-create-group. + awslogs-region Required: Yes Specify the Region that the awslogs log driver is to send your Docker logs to. You can choose to send all of your logs from clusters in different Regions to a single region in CloudWatch Logs. This is so that they're all visible in one location. Otherwise, you can separate them by Region for more granularity. Make sure that the specified log group exists in the Region that you specify with this option. + awslogs-group Required: Yes Make sure to specify a log group that the awslogs log driver sends its log streams to. + awslogs-stream-prefix Required: Yes, when using Fargate.Optional when using EC2. Use the awslogs-stream-prefix option to associate a log stream with the specified prefix, the container name, and the ID of the Amazon ECS task that the container belongs to. If you specify a prefix with this option, then the log stream takes the format prefix-name/container-name/ecs-task-id. If you don't specify a prefix with this option, then the log stream is named after the container ID that's assigned by the Docker daemon on the container instance. Because it's difficult to trace logs back to the container that sent them with just the Docker container ID (which is only available on the container instance), we recommend that you specify a prefix with this option. For Amazon ECS services, you can use the service name as the prefix. Doing so, you can trace log streams to the service that the container belongs to, the name of the container that sent them, and the ID of the task that the container belongs to. You must specify a stream-prefix for your logs to have your logs appear in the Log pane when using the Amazon ECS console. + awslogs-datetime-format Required: No This option defines a multiline start pattern in Python strftime format. A log message consists of a line that matches the pattern and any following lines that don’t match the pattern. The matched line is the delimiter between log messages. One example of a use case for using this format is for parsing output such as a stack dump, which might otherwise be logged in multiple entries. The correct pattern allows it to be captured in a single entry. For more information, see awslogs-datetime-format. You cannot configure both the awslogs-datetime-format and awslogs-multiline-pattern options. Multiline logging performs regular expression parsing and matching of all log messages. This might have a negative impact on logging performance. + awslogs-multiline-pattern Required: No This option defines a multiline start pattern that uses a regular expression. A log message consists of a line that matches the pattern and any following lines that don’t match the pattern. The matched line is the delimiter between log messages. For more information, see awslogs-multiline-pattern. This option is ignored if awslogs-datetime-format is also configured. You cannot configure both the awslogs-datetime-format and awslogs-multiline-pattern options. Multiline logging performs regular expression parsing and matching of all log messages. This might have a negative impact on logging performance. \n The following options apply to all supported log drivers.\n  + mode Required: No Valid values: non-blocking | blocking This option defines the delivery mode of log messages from the container to the log driver specified using logDriver. The delivery mode you choose affects application availability when the flow of logs from container is interrupted. If you use the blocking mode and the flow of logs is interrupted, calls from container code to write to the stdout and stderr streams will block. The logging thread of the application will block as a result. This may cause the application to become unresponsive and lead to container healthcheck failure. If you use the non-blocking mode, the container's logs are instead stored in an in-memory intermediate buffer configured with the max-buffer-size option. This prevents the application from becoming unresponsive when logs cannot be sent. We recommend using this mode if you want to ensure service availability and are okay with some log loss. For more information, see Preventing log loss with non-blocking mode in the awslogs container log driver. You can set a default mode for all containers in a specific Region by using the defaultLogDriverMode account setting. If you don't specify the mode option or configure the account setting, Amazon ECS will default to the non-blocking mode. For more information about the account setting, see Default log driver mode in the Amazon Elastic Container Service Developer Guide. On June 25, 2025, Amazon ECS changed the default log driver mode from blocking to non-blocking to prioritize task availability over logging. To continue using the blocking mode after this change, do one of the following: Set the mode option in your container definition's logConfiguration as blocking. Set the defaultLogDriverMode account setting to blocking. + max-buffer-size Required: No Default value: 10m When non-blocking mode is used, the max-buffer-size log option controls the size of the buffer that's used for intermediate message storage. Make sure to specify an adequate buffer size based on your application. When the buffer fills up, further logs cannot be stored. Logs that cannot be stored are lost. \n To route logs using the ``splunk`` log router, you need to specify a ``splunk-token`` and a ``splunk-url``.\n When you use the ``awsfirelens`` log router to route logs to an AWS Service or AWS Partner Network destination for log storage and analytics, you can set the ``log-driver-buffer-limit`` option to limit the number of events that are buffered in memory, before being sent to the log router container. It can help to resolve potential log loss issue because high throughput might result in memory running out for the buffer inside of Docker.\n Other options you can specify when using ``awsfirelens`` to route logs depend on the destination. When you export logs to Amazon Data Firehose, you can specify the AWS Region with ``region`` and a name for the log stream with ``delivery_stream``.\n When you export logs to Amazon Kinesis Data Streams, you can specify an AWS Region with ``region`` and a data stream name with ``stream``.\n  When you export logs to Amazon OpenSearch Service, you can specify options like ``Name``, ``Host`` (OpenSearch Service endpoint without protocol), ``Port``, ``Index``, ``Type``, ``Aws_auth``, ``Aws_region``, ``Suppress_Type_Name``, and ``tls``. For more information, see [Under the hood: FireLens for Amazon ECS Tasks](https://docs.aws.amazon.com/containers/under-the-hood-firelens-for-amazon-ecs-tasks/).\n When you export logs to Amazon S3, you can specify the bucket using the ``bucket`` option. You can also specify ``region``, ``total_file_size``, ``upload_timeout``, and ``use_put_object`` as options.\n This parameter requires version 1.19 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}}'``",
          "additionalProperties" : false,
          "type" : "object"
        },
        "LogDriver" : {
          "description" : "The log driver to use for the container.\n For tasks on FARGATElong, the supported log drivers are ``awslogs``, ``splunk``, and ``awsfirelens``.\n For tasks hosted on Amazon EC2 instances, the supported log drivers are ``awslogs``, ``fluentd``, ``gelf``, ``json-file``, ``journald``, ``syslog``, ``splunk``, and ``awsfirelens``.\n For more information about using the ``awslogs`` log driver, see [Send Amazon ECS logs to CloudWatch](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_awslogs.html) in the *Amazon Elastic Container Service Developer Guide*.\n For more information about using the ``awsfirelens`` log driver, see [Send Amazon ECS logs to an service or Partner](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html).\n  If you have a custom driver that isn't listed, you can fork the Amazon ECS container agent project that's [available on GitHub](https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent) and customize it to work with that driver. We encourage you to submit pull requests for changes that you would like to have included. However, we don't currently provide support for running modified copies of this software.",
          "type" : "string"
        }
      }
    },
    "Secret" : {
      "description" : "An object representing the secret to expose to your container. Secrets can be exposed to a container in the following ways:\n  +  To inject sensitive data into your containers as environment variables, use the ``secrets`` container definition parameter.\n  +  To reference sensitive information in the log configuration of a container, use the ``secretOptions`` container definition parameter.\n  \n 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*.",
      "additionalProperties" : false,
      "type" : "object",
      "required" : [ "Name", "ValueFrom" ],
      "properties" : {
        "ValueFrom" : {
          "description" : "The secret to expose to the container. The supported values are either the full ARN of the ASMlong secret or the full ARN of the parameter in the SSM Parameter Store.\n For information about the require IAMlong permissions, see [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-secrets.html#secrets-iam) (for Secrets Manager) or [Required IAM permissions for Amazon ECS secrets](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/specifying-sensitive-data-parameters.html) (for Systems Manager Parameter store) in the *Amazon Elastic Container Service Developer Guide*.\n  If the SSM Parameter Store parameter exists in the same Region as the task you're launching, then you can use either the full ARN or name of the parameter. If the parameter exists in a different Region, then the full ARN must be specified.",
          "type" : "string"
        },
        "Name" : {
          "description" : "The name of the secret.",
          "type" : "string"
        }
      }
    },
    "MountPoint" : {
      "description" : "The details for a volume mount point that's used in a container definition.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "ReadOnly" : {
          "description" : "If this value is ``true``, the container has read-only access to the volume. If this value is ``false``, then the container can write to the volume. The default value is ``false``.",
          "type" : "boolean"
        },
        "SourceVolume" : {
          "description" : "The name of the volume to mount. Must be a volume name referenced in the ``name`` parameter of task definition ``volume``.",
          "type" : "string"
        },
        "ContainerPath" : {
          "description" : "The path on the container to mount the host volume at.",
          "type" : "string"
        }
      }
    },
    "FirelensConfiguration" : {
      "description" : "The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) in the *Amazon Elastic Container Service Developer Guide*.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Options" : {
          "patternProperties" : {
            ".{1,}" : {
              "type" : "string"
            }
          },
          "description" : "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. If specified, the syntax to use is ``\"options\":{\"enable-ecs-log-metadata\":\"true|false\",\"config-file-type:\"s3|file\",\"config-file-value\":\"arn:aws:s3:::mybucket/fluent.conf|filepath\"}``. For more information, see [Creating a task definition that uses a FireLens configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html#firelens-taskdef) in the *Amazon Elastic Container Service Developer Guide*.\n  Tasks hosted on FARGATElong only support the ``file`` configuration file type.",
          "additionalProperties" : false,
          "type" : "object"
        },
        "Type" : {
          "description" : "The log router to use. The valid values are ``fluentd`` or ``fluentbit``.",
          "type" : "string"
        }
      }
    },
    "Volume" : {
      "description" : "The data volume configuration for tasks launched using this task definition. Specifying a volume configuration in a task definition is optional. The volume configuration may contain multiple volumes but only one volume configured at launch is supported. Each volume defined in the volume configuration may only specify a ``name`` and one of either ``configuredAtLaunch``, ``dockerVolumeConfiguration``, ``efsVolumeConfiguration``, ``s3filesVolumeConfiguration``, ``fsxWindowsFileServerVolumeConfiguration``, or ``host``. If an empty volume configuration is specified, by default Amazon ECS uses a host volume. For more information, see [Using data volumes in tasks](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_data_volumes.html).",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Host" : {
          "description" : "This parameter is specified when you use bind mount host volumes. The contents of the ``host`` parameter determine whether your bind mount host volume persists on the host container instance and where it's stored. If the ``host`` parameter is empty, then the Docker daemon assigns a host path for your data volume. However, the data isn't guaranteed to persist after the containers that are associated with it stop running.\n Windows containers can mount whole directories on the same drive as ``$env:ProgramData``. Windows containers can't mount directories on a different drive, and mount point can't be across drives. For example, you can mount ``C:\\my\\path:C:\\my\\path`` and ``D:\\:D:\\``, but not ``D:\\my\\path:C:\\my\\path`` or ``D:\\:C:\\my\\path``.",
          "$ref" : "#/definitions/HostVolumeProperties"
        },
        "Name" : {
          "description" : "The name of the volume. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed.\n When using a volume configured at launch, the ``name`` is required and must also be specified as the volume name in the ``ServiceVolumeConfiguration`` or ``TaskVolumeConfiguration`` parameter when creating your service or standalone task.\n For all other types of volumes, this name is referenced in the ``sourceVolume`` parameter of the ``mountPoints`` object in the container definition.\n When a volume is using the ``efsVolumeConfiguration``, the name is required.\n When a volume is using the ``s3filesVolumeConfiguration``, the name is required.",
          "type" : "string"
        }
      }
    },
    "KernelCapabilities" : {
      "description" : "The Linux capabilities to add or remove from the default Docker configuration for a container defined in the task definition. For more detailed information about these Linux capabilities, see the [capabilities(7)](https://docs.aws.amazon.com/http://man7.org/linux/man-pages/man7/capabilities.7.html) Linux manual page.\n The following describes how Docker processes the Linux capabilities specified in the ``add`` and ``drop`` request parameters. For information about the latest behavior, see [Docker Compose: order of cap_drop and cap_add](https://docs.aws.amazon.com/https://forums.docker.com/t/docker-compose-order-of-cap-drop-and-cap-add/97136/1) in the Docker Community Forum.\n  +  When the container is a privleged container, the container capabilities are all of the default Docker capabilities. The capabilities specified in the ``add`` request parameter, and the ``drop`` request parameter are ignored.\n  +  When the ``add`` request parameter is set to ALL, the container capabilities are all of the default Docker capabilities, excluding those specified in the ``drop`` request parameter.\n  +  When the ``drop`` request parameter is set to ALL, the container capabilities are the capabilities specified in the ``add`` request parameter.\n  +  When the ``add`` request parameter and the ``drop`` request parameter are both empty, the capabilities the container capabilities are all of the default Docker capabilities.\n  +  The default is to first drop the capabilities specified in the ``drop`` request parameter, and then add the capabilities specified in the ``add`` request parameter.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Add" : {
          "description" : "The Linux capabilities for the container that have been added to the default configuration provided by Docker. This parameter maps to ``CapAdd`` in the docker container create command and the ``--cap-add`` option to docker run.\n  Tasks launched on FARGATElong only support adding the ``SYS_PTRACE`` kernel capability.\n  Valid values: ``\"ALL\" | \"AUDIT_CONTROL\" | \"AUDIT_WRITE\" | \"BLOCK_SUSPEND\" | \"CHOWN\" | \"DAC_OVERRIDE\" | \"DAC_READ_SEARCH\" | \"FOWNER\" | \"FSETID\" | \"IPC_LOCK\" | \"IPC_OWNER\" | \"KILL\" | \"LEASE\" | \"LINUX_IMMUTABLE\" | \"MAC_ADMIN\" | \"MAC_OVERRIDE\" | \"MKNOD\" | \"NET_ADMIN\" | \"NET_BIND_SERVICE\" | \"NET_BROADCAST\" | \"NET_RAW\" | \"SETFCAP\" | \"SETGID\" | \"SETPCAP\" | \"SETUID\" | \"SYS_ADMIN\" | \"SYS_BOOT\" | \"SYS_CHROOT\" | \"SYS_MODULE\" | \"SYS_NICE\" | \"SYS_PACCT\" | \"SYS_PTRACE\" | \"SYS_RAWIO\" | \"SYS_RESOURCE\" | \"SYS_TIME\" | \"SYS_TTY_CONFIG\" | \"SYSLOG\" | \"WAKE_ALARM\"``",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "type" : "string"
          }
        },
        "Drop" : {
          "description" : "The Linux capabilities for the container that have been removed from the default configuration provided by Docker. This parameter maps to ``CapDrop`` in the docker container create command and the ``--cap-drop`` option to docker run.\n Valid values: ``\"ALL\" | \"AUDIT_CONTROL\" | \"AUDIT_WRITE\" | \"BLOCK_SUSPEND\" | \"CHOWN\" | \"DAC_OVERRIDE\" | \"DAC_READ_SEARCH\" | \"FOWNER\" | \"FSETID\" | \"IPC_LOCK\" | \"IPC_OWNER\" | \"KILL\" | \"LEASE\" | \"LINUX_IMMUTABLE\" | \"MAC_ADMIN\" | \"MAC_OVERRIDE\" | \"MKNOD\" | \"NET_ADMIN\" | \"NET_BIND_SERVICE\" | \"NET_BROADCAST\" | \"NET_RAW\" | \"SETFCAP\" | \"SETGID\" | \"SETPCAP\" | \"SETUID\" | \"SYS_ADMIN\" | \"SYS_BOOT\" | \"SYS_CHROOT\" | \"SYS_MODULE\" | \"SYS_NICE\" | \"SYS_PACCT\" | \"SYS_PTRACE\" | \"SYS_RAWIO\" | \"SYS_RESOURCE\" | \"SYS_TIME\" | \"SYS_TTY_CONFIG\" | \"SYSLOG\" | \"WAKE_ALARM\"``",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "type" : "string"
          }
        }
      }
    },
    "Tmpfs" : {
      "description" : "The container path, mount options, and size of the tmpfs mount.",
      "additionalProperties" : false,
      "type" : "object",
      "required" : [ "Size" ],
      "properties" : {
        "Size" : {
          "description" : "The maximum size (in MiB) of the tmpfs volume.",
          "type" : "integer"
        },
        "ContainerPath" : {
          "description" : "The absolute file path where the tmpfs volume is to be mounted.",
          "type" : "string"
        },
        "MountOptions" : {
          "description" : "The list of tmpfs volume mount options.\n Valid values: ``\"defaults\" | \"ro\" | \"rw\" | \"suid\" | \"nosuid\" | \"dev\" | \"nodev\" | \"exec\" | \"noexec\" | \"sync\" | \"async\" | \"dirsync\" | \"remount\" | \"mand\" | \"nomand\" | \"atime\" | \"noatime\" | \"diratime\" | \"nodiratime\" | \"bind\" | \"rbind\" | \"unbindable\" | \"runbindable\" | \"private\" | \"rprivate\" | \"shared\" | \"rshared\" | \"slave\" | \"rslave\" | \"relatime\" | \"norelatime\" | \"strictatime\" | \"nostrictatime\" | \"mode\" | \"uid\" | \"gid\" | \"nr_inodes\" | \"nr_blocks\" | \"mpol\"``",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "type" : "string"
          }
        }
      }
    },
    "EnvironmentFile" : {
      "description" : "A list of files containing the environment variables to pass to a container. 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.\n 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're processed from the top down. We recommend that you use unique variable names. For more information, see [Use a file to pass environment variables to a container](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/use-environment-file.html) in the *Amazon Elastic Container Service Developer Guide*.\n Environment variable files are objects in Amazon S3 and all Amazon S3 security considerations apply. \n You must use the following platforms for the Fargate launch type:\n  +  Linux platform version ``1.4.0`` or later.\n  +  Windows platform version ``1.0.0`` or later.\n  \n Consider the following when using the Fargate launch type:\n  +  The file is handled like a native Docker env-file.\n  +  There is no support for shell escape handling.\n  +  The container entry point interperts the ``VARIABLE`` values.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Type" : {
          "description" : "The file type to use. Environment files are objects in Amazon S3. The only supported value is ``s3``.",
          "type" : "string"
        },
        "Value" : {
          "description" : "The Amazon Resource Name (ARN) of the Amazon S3 object containing the environment variable file.",
          "type" : "string"
        }
      }
    },
    "DaemonContainerDefinition" : {
      "description" : "A container definition for a daemon task. Daemon container definitions describe the containers that run as part of a daemon task on container instances managed by capacity providers.",
      "additionalProperties" : false,
      "type" : "object",
      "required" : [ "Name", "Image" ],
      "properties" : {
        "User" : {
          "description" : "The user to use inside the container.",
          "type" : "string"
        },
        "Secrets" : {
          "description" : "The secrets to pass to the container.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/Secret"
          }
        },
        "Memory" : {
          "description" : "The amount (in MiB) of memory to present to the container. If the container attempts to exceed the memory specified here, the container is killed.",
          "type" : "integer"
        },
        "Privileged" : {
          "description" : "When this parameter is true, the container is given elevated privileges on the host container instance (similar to the ``root`` user).",
          "type" : "boolean"
        },
        "StartTimeout" : {
          "description" : "Time duration (in seconds) to wait before giving up on resolving dependencies for a container.",
          "type" : "integer"
        },
        "HealthCheck" : {
          "description" : "The container health check command and associated configuration parameters for the container.",
          "$ref" : "#/definitions/HealthCheck"
        },
        "Cpu" : {
          "description" : "The number of ``cpu`` units reserved for the container.",
          "type" : "integer"
        },
        "EntryPoint" : {
          "description" : "The entry point that's passed to the container.",
          "insertionOrder" : true,
          "type" : "array",
          "items" : {
            "type" : "string"
          }
        },
        "ReadonlyRootFilesystem" : {
          "description" : "When this parameter is true, the container is given read-only access to its root file system.",
          "type" : "boolean"
        },
        "Image" : {
          "description" : "The image used to start the container. This string is passed directly to the Docker daemon. Images in the Docker Hub registry are available by default. Other repositories are specified with either ``repository-url/image:tag`` or ``repository-url/image@digest``.",
          "type" : "string"
        },
        "Essential" : {
          "description" : "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.",
          "type" : "boolean"
        },
        "LogConfiguration" : {
          "description" : "The log configuration specification for the container.",
          "$ref" : "#/definitions/LogConfiguration"
        },
        "EnvironmentFiles" : {
          "description" : "A list of files containing the environment variables to pass to a container.",
          "insertionOrder" : true,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/EnvironmentFile"
          }
        },
        "Name" : {
          "description" : "The name of the container. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed.",
          "type" : "string"
        },
        "FirelensConfiguration" : {
          "description" : "The FireLens configuration for the container. This is used to specify and configure a log router for container logs.",
          "$ref" : "#/definitions/FirelensConfiguration"
        },
        "SystemControls" : {
          "description" : "A list of namespaced kernel parameters to set in the container.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/SystemControl"
          }
        },
        "Interactive" : {
          "description" : "When this parameter is ``true``, you can deploy containerized applications that require ``stdin`` or a ``tty`` to be allocated.",
          "type" : "boolean"
        },
        "Ulimits" : {
          "description" : "A list of ``ulimits`` to set in the container.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/Ulimit"
          }
        },
        "StopTimeout" : {
          "description" : "Time duration (in seconds) to wait before the container is forcefully killed if it doesn't exit normally on its own.",
          "type" : "integer"
        },
        "WorkingDirectory" : {
          "description" : "The working directory to run commands inside the container in.",
          "type" : "string"
        },
        "MemoryReservation" : {
          "description" : "The soft limit (in MiB) of memory to reserve for the container.",
          "type" : "integer"
        },
        "RepositoryCredentials" : {
          "description" : "The private repository authentication credentials to use.",
          "$ref" : "#/definitions/RepositoryCredentials"
        },
        "LinuxParameters" : {
          "description" : "Linux-specific modifications that are applied to the container configuration, such as Linux kernel capabilities.",
          "$ref" : "#/definitions/LinuxParameters"
        },
        "RestartPolicy" : {
          "description" : "The restart policy for the container. When you set up a restart policy, Amazon ECS can restart the container without needing to replace the task.",
          "$ref" : "#/definitions/RestartPolicy"
        },
        "PseudoTerminal" : {
          "description" : "When this parameter is ``true``, a TTY is allocated.",
          "type" : "boolean"
        },
        "MountPoints" : {
          "description" : "The mount points for data volumes in your container.",
          "insertionOrder" : true,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/MountPoint"
          }
        },
        "DependsOn" : {
          "description" : "The dependencies defined for container startup and shutdown. A container can contain multiple dependencies on other containers in a task definition.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/ContainerDependency"
          }
        },
        "Command" : {
          "description" : "The command that's passed to the container.",
          "insertionOrder" : true,
          "type" : "array",
          "items" : {
            "type" : "string"
          }
        },
        "Environment" : {
          "description" : "The environment variables to pass to a container.",
          "insertionOrder" : false,
          "type" : "array",
          "items" : {
            "$ref" : "#/definitions/KeyValuePair"
          }
        }
      }
    },
    "Tag" : {
      "description" : "The metadata that you apply to a resource to help you categorize and organize them. Each tag consists of a key and an optional value. You define them.\n The following basic restrictions apply to tags:\n  +  Maximum number of tags per resource - 50\n  +  For each resource, each tag key must be unique, and each tag key can have only one value.\n  +  Maximum key length - 128 Unicode characters in UTF-8\n  +  Maximum value length - 256 Unicode characters in UTF-8\n  +  If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : / @.\n  +  Tag keys and values are case-sensitive.\n  +  Do not use ``aws:``, ``AWS:``, or any upper or lowercase combination of such as a prefix for either keys or values as it is reserved for AWS use. You cannot edit or delete tag keys or values with this prefix. Tags with this prefix do not count against your tags per resource limit.",
      "additionalProperties" : false,
      "type" : "object",
      "properties" : {
        "Value" : {
          "description" : "The optional part of a key-value pair that make up a tag. A ``value`` acts as a descriptor within a tag category (key).",
          "type" : "string"
        },
        "Key" : {
          "description" : "One part of a key-value pair that make up a tag. A ``key`` is a general label that acts like a category for more specific tag values.",
          "type" : "string"
        }
      }
    }
  },
  "properties" : {
    "ExecutionRoleArn" : {
      "description" : "The Amazon Resource Name (ARN) of the task execution role that grants the Amazon ECS container agent permission to make Amazon Web Services API calls on your behalf.",
      "type" : "string"
    },
    "TaskRoleArn" : {
      "description" : "The short name or full Amazon Resource Name (ARN) of the IAM role that grants containers in the daemon task permission to call Amazon Web Services APIs on your behalf.",
      "type" : "string"
    },
    "DaemonTaskDefinitionArn" : {
      "description" : "",
      "type" : "string"
    },
    "IpcMode" : {
      "description" : "The IPC resource namespace mode for the containers in the daemon task. The valid values are ``none`` and ``shared``.\n If ``shared`` is specified, all containers within the daemon task share the same IPC resources.\n If ``none`` is specified, each container in the daemon task has a private IPC namespace.",
      "type" : "string"
    },
    "Volumes" : {
      "uniqueItems" : true,
      "description" : "The list of data volume definitions for the daemon task.",
      "insertionOrder" : false,
      "type" : "array",
      "items" : {
        "$ref" : "#/definitions/Volume"
      }
    },
    "Memory" : {
      "description" : "The amount of memory (in MiB) used by the daemon task.",
      "type" : "string"
    },
    "ContainerDefinitions" : {
      "uniqueItems" : true,
      "description" : "A list of container definitions in JSON format that describe the containers that make up the daemon task.",
      "insertionOrder" : false,
      "type" : "array",
      "items" : {
        "$ref" : "#/definitions/DaemonContainerDefinition"
      }
    },
    "Family" : {
      "description" : "The name of a family that this daemon task definition is registered to.",
      "type" : "string"
    },
    "Cpu" : {
      "description" : "The number of CPU units used by the daemon task.",
      "type" : "string"
    },
    "PidMode" : {
      "description" : "The process namespace mode for the containers in the daemon task. The valid values are ``none`` and ``shared``.\n If ``shared`` is specified, all containers within the daemon task share the same process namespace.\n If ``none`` is specified, each container in the daemon task has a private process namespace.",
      "type" : "string"
    },
    "Tags" : {
      "description" : "",
      "insertionOrder" : false,
      "type" : "array",
      "items" : {
        "$ref" : "#/definitions/Tag"
      }
    }
  }
}