# Parâmetros de definição de tarefa do Amazon ECS para o Fargate
As definições de tarefa se dividem em partes distintas: a família da tarefa, o perfil da tarefa do AWS Identity and Access Management (IAM), o modo de rede, definições de contêiner, volumes e tipos de inicialização. As definições de família e de contêiner são obrigatórias em uma definição de tarefa. Por outro lado, perfil de tarefa, modo da rede, volumes e tipo de inicialização são opcionais.
É possível usar esses parâmetros em um arquivo JSON para configurar sua definição de tarefa.
Veja a seguir descrições mais detalhadas de cada parâmetro de definição de tarefa para o Fargate.
## Família
`family`
Tipo: String
Exigido: sim
Ao registrar uma definição de tarefa, você dá a ela uma família, semelhante a um nome para várias versões da definição de tarefa, especificada com um número de revisão. A primeira definição de tarefa registrada em uma determinada família recebe uma revisão 1, e todas as definições de tarefa registradas depois receberão um número de revisão sequencial.
## Capacidade
Ao registrar uma definição de tarefa, você pode especificar a capacidade segundo a qual o Amazon ECS deve validar a definição de tarefa. Se a definição de tarefa não for validada em relação às compatibilidades especificadas, uma exceção de cliente será retornada.
O seguinte parâmetro é permitido em uma definição de tarefa.
`requiresCompatibilities`
Tipo: Matriz de strings
Obrigatório: não
Valores válidos: `FARGATE`
A capacidade segundo a qual a definição de tarefa é validada. Isso inicia uma verificação para garantir que todos os parâmetros usados na definição de tarefa atendam aos requisitos do Fargate.
## Função do para tarefa
`taskRoleArn`
Tipo: string
Obrigatório: não
Ao registrar uma definição de tarefa, você pode fornecer uma função de tarefa para uma função do IAM que permita que os contêineres da permissão de tarefa chame as APIs da AWS especificadas nas políticas associadas em seu nome. Para obter mais informações, consulte [Perfil do IAM para tarefas do Amazon ECS](task-iam-roles.md).
## Função do para execução de tarefas
`executionRoleArn`
Tipo: string
Obrigatório: Condicional
O nome do recurso da Amazon (ARN) da função de execução de tarefas que concede ao agente de contêiner do Amazon ECS permissão para fazer chamadas de API da AWS em seu nome.
A função do IAM para execução da tarefa é necessária dependendo dos requisitos da sua tarefa. Para obter mais informações, consulte [Função do IAM de execução de tarefas do Amazon ECS](task_execution_IAM_role.md).
## Modo de rede
`networkMode`
Tipo: String
Exigido: sim
O modo de rede do Docker a ser usado para os contêineres na tarefa. Para tarefas do Amazon ECS hospedadas no Fargate, é necessário o modo de rede `awsvpc`.
## Plataforma de runtime
`operatingSystemFamily`
Tipo: string
Obrigatório: Condicional
Padrão: LINUX
Esse parâmetro é necessário para tarefas do Amazon ECS hospedadas no Fargate.
Ao registrar uma definição de tarefa, você especifica a família do sistema operacional.
Os valores válidos são `LINUX`, `WINDOWS_SERVER_2025_FULL`, `WINDOWS_SERVER_2025_CORE`, `WINDOWS_SERVER_2022_FULL`, `WINDOWS_SERVER_2022_CORE`, `WINDOWS_SERVER_2019_FULL` e `WINDOWS_SERVER_2019_CORE`.
Todas as definições de tarefa usadas em um serviço devem ter o mesmo valor para esse parâmetro.
Quando uma definição de tarefa faz parte de um serviço, esse valor deve corresponder ao valor `platformFamily` do serviço.
`cpuArchitecture`
Tipo: string
Obrigatório: Condicional
Padrão: X86\$164
Se o parâmetro for deixado como `null`, o valor padrão é atribuído automaticamente ao iniciar uma tarefa hospedada no Fargate.
Ao registrar uma definição de tarefa, você especifica a arquitetura da CPU. Os valores válidos são `X86_64` e `ARM64`.
Todas as definições de tarefa usadas em um serviço devem ter o mesmo valor para esse parâmetro.
Quando você tem tarefas do Linux, pode definir o valor como `ARM64`. Para obter mais informações, consulte [Definições de tarefa do Amazon ECS para workloads do ARM de 64 bits](ecs-arm64.md).
## Tamanho da tarefa
Ao registrar uma definição de tarefa, você pode especificar o total de CPU e memória usados para a tarefa. Isso é separado dos valores de `cpu` e `memory` no nível de definição de contêiner. Para tarefas hospedadas no Fargate (tanto de Linux quanto de Windows), esses campos são obrigatórios e existem valores específicos para `cpu` e `memory` com suporte.
O seguinte parâmetro é permitido em uma definição de tarefa:
`cpu`
Tipo: String
Exigido: sim
É necessário informar os parâmetros de CPU e memória no nível da tarefa, que são usados para determinar o tipo e o tamanho da instância na qual as tarefas são executadas. Para tarefas do Windows, esses valores não são aplicados em runtime, porque o Windows não tem um mecanismo nativo que possa impor facilmente limites coletivos de recursos em um grupo de contêineres. Se você quiser impor limites de recursos, recomendamos usar os recursos no nível de contêiner para contêineres do Windows.
O limite rígido de unidades de CPU a ser apresentado para a tarefa. Você pode especificar valores de CPU no arquivo JSON como uma string em unidades de CPU ou em CPUs virtuais (vCPUs). Por exemplo, você pode especificar um valor de CPU como `1024` em unidades de CPU ou `1 vCPU` em vCPUs. Quando a definição de tarefa for registrada, um valor de vCPU será convertido em um inteiro indicando as unidades de CPU.
Esse campo é obrigatório e você deve usar um dos valores a seguir, o que determina o intervalo de valores compatíveis com o parâmetro `memory`. A tabela a seguir mostra as combinações válidas para CPU e memória em nível de tarefa.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonECS/latest/developerguide/task_definition_parameters.html)
`memory`
Tipo: String
Exigido: sim
É necessário informar os parâmetros de CPU e memória no nível da tarefa, que são usados para determinar o tipo e o tamanho da instância na qual as tarefas são executadas. Para tarefas do Windows, esses valores não são aplicados em runtime, porque o Windows não tem um mecanismo nativo que possa impor facilmente limites coletivos de recursos em um grupo de contêineres. Se você quiser impor limites de recursos, recomendamos usar os recursos no nível de contêiner para contêineres do Windows.
O limite fixo de memória a ser apresentada para a tarefa. É possível especificar valores de memória na definição de tarefa como uma string em mebibytes (MiB) ou gigabytes (GB). Por exemplo, você pode especificar um valor de memória como `3072` em MiB ou `3 GB` em GB. Quando a definição de tarefa for registrada, um valor em GB será convertido em um inteiro indicando o MiB.
Esse campo é obrigatório e você deve usar um dos valores a seguir, o que determina o intervalo de valores compatíveis com o parâmetro `cpu`:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonECS/latest/developerguide/task_definition_parameters.html)
## Definições de contêiner
Ao registrar uma definição de tarefa, você deve especificar uma lista de definições de contêiner passadas para o daemon do Docker em uma instância de contêiner. Os parâmetros a seguir são permitidos em uma definição de contêiner.
**Topics**
+ [
### Parâmetros padrão de definição de contêiner
](#standard_container_definition_params)
+ [
### Parâmetros avançados de definição de contêiner
](#advanced_container_definition_params)
+ [
### Outros parâmetros de definição de contêiner
](#other_container_definition_params)
### Parâmetros padrão de definição de contêiner
Os parâmetros de definição de tarefa a seguir são obrigatórios ou usados na maioria das definições de contêiner.
**Topics**
+ [
#### Nome
](#container_definition_name)
+ [
#### Imagem
](#container_definition_image)
+ [
#### Memória
](#container_definition_memory)
+ [
#### Mapeamentos de porta
](#container_definition_portmappings)
+ [
#### Credenciais de repositório privado
](#container_definition_repositoryCredentials)
#### Nome
`name`
Tipo: String
Exigido: sim
O nome de um contêiner. São permitidos até 255 letras (caixa alta e baixa), números, hífens e sublinhados. Se estiver vinculando vários contêineres em uma definição de tarefa, o `name` de um contêiner poderá ser informado no `links` de outro contêiner. Isso deve ser feito para conectar os contêineres.
#### Imagem
`image`
Tipo: String
Exigido: sim
A imagem usada para iniciar um contêiner. Essa string é passada diretamente para o daemon do Docker. Por padrão, as imagens no registro do Docker Hub estão disponíveis. Você também pode especificar outros repositórios com `repository-url/image:tag` ou `repository-url/image@digest`. São permitidos até 255 letras (caixa alta e baixa), números, hifens, sublinhados, dois pontos, ponto, barras e sinais numéricos. Esse parâmetro é mapeado para `Image` no comando create-container do docker e no parâmetro `IMAGE` do comando run do docker.
+ Quando uma nova tarefa é iniciada, o agente do contêiner do Amazon ECS obtém a versão mais recente da imagem especificada e a tag do contêiner a ser usado. No entanto, as atualizações subsequentes feitas em um repositório de imagens não são propagadas para tarefas já em execução.
+ Quando não é especificada uma tag ou um resumo no caminho da imagem na definição da tarefa, o agente de contêiner do Amazon ECS usa a tag `latest` para extrair a imagem especificada.
+ As atualizações subsequentes para um repositório de imagens não são propagadas para tarefas já em execução.
+ As imagens em registros privados são suportadas. Para obter mais informações, consulte [Uso de imagens de contêiner que não são da AWS no Amazon ECS](private-auth.md).
+ As imagens nos repositórios do Amazon ECR podem ser especificadas usando a convenção de nomenclatura completa `registry/repository:tag` ou `registry/repository@digest` (por exemplo, `aws_account_id.dkr.ecr.region.amazonaws.com``/my-web-app:latest` ou `aws_account_id.dkr.ecr.region.amazonaws.com``/my-web-app@sha256:94afd1f2e64d908bc90dbca0035a5b567EXAMPLE`).
+ As imagens em repositórios oficiais no Docker Hub usam um único nome (por exemplo, `ubuntu` ou `mongo`).
+ Imagens em outros repositórios Docker Hub são qualificadas com um nome de organização (por exemplo, `amazon/amazon-ecs-agent`).
+ Imagens em outros repositórios online também são qualificadas por um nome de domínio (por exemplo, `quay.io/assemblyline/ubuntu`).
`versionConsistency`
Tipo: string
Valores válidos: `enabled`\$1`disabled`
Obrigatório: não
Especifica se o Amazon ECS resolverá a tag de imagem do contêiner fornecida na definição do contêiner em um resumo de imagem. Por padrão, esse comportamento é `enabled`. Se você definir o valor de um contêiner como `disabled`, o Amazon ECS não resolverá a tag da imagem do contêiner como um resumo e usará o URI da imagem original especificado na definição do contêiner para implantação. Para obter mais informações sobre resolução de imagem do contêiner, consulte [Resolução da imagem do contêiner](deployment-type-ecs.md#deployment-container-image-stability).
#### Memória
`memory`
Tipo: inteiro
Obrigatório: não
A quantidade (em MiB) de memória a ser apresentada ao contêiner. Caso tente exceder a memória especificada aqui, o contêiner será excluído. A quantidade total de memória reservada para todos os contêineres dentro da tarefa deve ser menor que o valor da tarefa `memory`, se estiver especificado. Esse parâmetro é mapeado para `Memory` no comando create-container do docker na opção `--memory` de execução do docker.
O daemon para Docker 20.10.0 ou versão posterior reserva no mínimo 6 MiB de memória para um contêiner. Por isso, não especifique menos de 6 MiB de memória para os seus contêineres.
O daemon para Docker 19.03.13-ce ou versão anterior reserva no mínimo 4 MiB de memória para um contêiner. Por isso, não especifique menos de 4 MiB de memória para os seus contêineres.
Se você deseja maximizar a utilização de recursos fornecendo às tarefas o máximo de memória possível para um determinado tipo de instância, consulte [Reserva de memória da instância de contêiner do Linux no Amazon ECS](memory-management.md).
`memoryReservation`
Tipo: inteiro
Obrigatório: não
O limite flexível (em MiB) de memória a ser reservado para o contêiner. Quando a memória do sistema estiver em contenção, o Docker tentará manter a memória do contêiner dentro desse limite flexível. Entrentanto, seu contêiner pode usar mais memória quando necessário. O contêiner pode consumir até o limite rígido especificado pelo parâmetro `memory` (se aplicável), ou toda a memória disponível na instância de contêiner, o que ocorrer primeiro. Esse parâmetro é mapeado para `MemoryReservation` no comando create-container do docker na opção `--memory-reservation` de execução do docker.
Se um valor de memória no nível de tarefa não for especificado, será necessário especificar um número inteiro diferente de zero para um ou ambos `memory` ou `memoryReservation` em uma definição de contêiner. Caso você especifique ambos, `memory` deve ser maior que `memoryReservation`. Caso você especifique `memoryReservation`, o valor é subtraído dos recursos de memória disponíveis para a instância de contêiner na qual o contêiner está colocado. Caso contrário, o valor de `memory` é usado.
Por exemplo, suponha que seu contêiner normalmente use 128 MiB de memória, mas às vezes chegue a 256 MiB de memória por períodos curtos. É possível definir um `memoryReservation` de 128 MiB e um limite rígido de `memory` de 300 MiB. Essa configuração permite que contêiner reservasse apenas 128 MiB de memória dos recursos restantes na instância de contêiner. Ao mesmo tempo, essa configuração também possibilita que o contêiner utilize mais recursos de memória quando necessário.
Este parâmetro não é compatível com contêineres do Windows.
O daemon para Docker 20.10.0 ou versão posterior reserva no mínimo 6 MiB de memória para um contêiner. Por isso, não especifique menos de 6 MiB de memória para os seus contêineres.
O daemon para Docker 19.03.13-ce ou versão anterior reserva no mínimo 4 MiB de memória para um contêiner. Por isso, não especifique menos de 4 MiB de memória para os seus contêineres.
Se você deseja maximizar a utilização de recursos fornecendo às tarefas o máximo de memória possível para um determinado tipo de instância, consulte [Reserva de memória da instância de contêiner do Linux no Amazon ECS](memory-management.md).
#### Mapeamentos de porta
`portMappings`
Tipo: Matriz de objeto
Obrigatório: não
Os mapeamentos de portas expõem as portas de rede do seu contêiner ao mundo externo. Isso permite que os clientes acessem sua aplicação. Também é usado para comunicação entre contêineres dentro da mesma tarefa.
Para definições de tarefa que usam o modo de rede `awsvpc`, apenas especifique `containerPort`. A `hostPort` é sempre ignorada e a porta do contêiner é automaticamente mapeada para uma porta aleatória de alto número no host.
Os mapeamentos de porta no Windows usam o endereço de gateway `NetNAT`, e não o `localhost`. Não há loopback para mapeamentos de porta no Windows, de modo que você não pode acessar a porta mapeada de um contêiner no próprio host.
A maioria dos campos desse parâmetro (incluindo `containerPort`, `hostPort`, `protocol`) é mapeada para `PortBindings` no comando create-container do docker e a opção `--publish` de execução do docker. Caso o modo de rede de uma definição de tarefa seja definido como `host`, as portas host devem ser indefinidas ou corresponder à porta de contêiner no mapeamento de porta.
Quando a tarefa obter o status `RUNNING`, as atribuições automáticas e manuais da porta do contêiner e do host estarão visíveis nos seguintes locais:
+ Console: a seção **Network Bindings** (Associações de rede) de uma descrição de contêiner para uma tarefa selecionada.
+ AWS CLI: a seção `networkBindings` do resultado do comando **describe-tasks**.
+ API: a resposta `DescribeTasks`.
+ Metadados: o endpoint de metadados da tarefa.
`appProtocol`
Tipo: string
Obrigatório: não
O protocolo da aplicação usado no mapeamento da porta. Esse parâmetro só se aplica ao Service Connect. Recomendamos que você defina esse parâmetro para que seja consistente com o protocolo usado por sua aplicação. Se você definir esse parâmetro, o Amazon ECS adicionará o tratamento de conexão específico do protocolo ao proxy do Service Connect. Se você definir esse parâmetro, o Amazon ECS adicionará telemetria específica de protocolo no console do Amazon ECS e no CloudWatch.
Se você não definir um valor para esse parâmetro, o TCP será usado. No entanto, o Amazon ECS não adiciona telemetria específica de protocolo para TCP.
Para obter mais informações, consulte [Uso do Service Connect para conectar serviços do Amazon ECS com nomes abreviados](service-connect.md).
Valores de protocolo válidos: `"http" | "http2" | "grpc" `
`containerPort`
Tipo: inteiro
Exigido: Sim, quando `portMappings` são usados
O número da porta no contêiner vinculado à porta host atribuída automaticamente ou especificada pelo usuário.
Para as tarefas que usam o modo de rede `awsvpc`, você usa `containerPort` para especificar as portas expostas.
Para contêineres Windows no Fargate, não é possível usar a porta 3150 para `containerPort`. Isso acontece porque ela está reservada.
`containerPortRange`
Tipo: string
Obrigatório: não
O intervalo de números de porta no contêiner vinculado ao intervalo de portas host mapeado dinamicamente.
Você só pode definir esse parâmetro usando a API `register-task-definition`. A opção está disponível no parâmetro `portMappings`. Para obter mais informações, consulte [register-task-definition](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html), na *Referência da AWS Command Line Interface*.
As regras a seguir se aplicam quando você especifica um `containerPortRange`:
+ Você deve usar o modo de rede `awsvpc`.
+ Esse parâmetro está disponível para os sistemas operacionais Windows e Linux.
+ A instância de contêiner deve ter pelo menos a versão 1.67.0 do agente do contêiner e pelo menos a versão 1.67.0-1 do pacote `ecs-init`
+ É possível especificar no máximo 100 intervalos de portas para cada contêiner.
+ Você não especifica um `hostPortRange`. O valor do `hostPortRange` é definido da seguinte forma:
+ Para contêineres em uma tarefa com o modo de rede `awsvpc`, o `hostPort` é definido com o mesmo valor que `containerPort`. Essa é uma estratégia de mapeamento estático.
+ Os valores válidos de `containerPortRange` estão entre 1 e 65535.
+ Uma porta só pode ser incluída em um mapeamento de portas para cada contêiner.
+ Não é possível especificar intervalos de portas sobrepostos.
+ A primeira porta no intervalo deve ser menor que a última porta no intervalo.
+ O Docker recomenda que você desative o docker-proxy no arquivo de configuração do daemon do Docker quando tiver um grande número de portas.
Para obter mais informações, consulte [Issue \$111185](https://github.com/moby/moby/issues/11185) no GitHub.
Para obter informações sobre como desativar o docker-proxy no arquivo de configuração do daemon do Docker, consulte [Daemon do Docker](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon) no *Guia do desenvolvedor do Amazon ECS*.
É possível chamar [DescribeTasks](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html) para visualizar o `hostPortRange`, que são as portas do host vinculadas às portas do contêiner.
Os intervalos de portas não estão incluídos nos eventos de tarefas do Amazon ECS que são enviados ao EventBridge. Para obter mais informações, consulte [Automatização de respostas a erros do Amazon ECS usando o EventBridge](cloudwatch_event_stream.md).
`hostPortRange`
Tipo: Sequência
Obrigatório: não
O intervalo de números de portas no host que é usado com a vinculação de rede. Isso é atribuído pelo Docker e fornecido pelo agente do Amazon ECS.
`hostPort`
Tipo: inteiro
Obrigatório: não
O número da porta na instância de contêiner a ser reservado para o contêiner.
A `hostPort` pode ser deixada em branco ou ter um valor igual a `containerPort`.
O intervalo de portas temporárias padrão para a versão 1.6.0 e posterior do Docker é listado na instância em `/proc/sys/net/ipv4/ip_local_port_range`. Se esse parâmetro do kernel não estiver disponível, será usado o intervalo de portas temporárias padrão de `49153–65535`. Não tente especificar uma porta de host no intervalo de portas transitório. Isso ocorre porque essas portas são reservadas para atribuição automática. Em geral, as portas abaixo de `32768` estão fora do intervalo de portas temporárias.
As portas reservadas padrão são `22` para SSH, as portas do Docker `2375` e`2376` e as portas do agente de contêiner do Amazon ECS `51678-51680`. Qualquer porta de host que tenha sido especificada pelo usuário anteriormente para uma tarefa em execução também é reservada enquanto a tarefa está em execução. Depois que uma tarefa é interrompida, a porta do host é liberada. As portas reservadas atuais são exibidas nos `remainingResources` de **describe-container-instances** de saída. Uma instância de contêiner pode ter até 100 portas reservadas por vez, incluindo as portas reservadas padrão. As portas atribuídas automaticamente não contam em relação à cota de 100 portas reservadas.
`name`
Tipo: string
Obrigatório: não, obrigatório para que o Service Connect e o VPC Lattice sejam configurados em um serviço
Nome que é usado para o mapeamento da porta. Esse parâmetro só se aplica ao Service Connect e ao VPC Lattice. Esse parâmetro é o nome que você usa na configuração do Service Connect e do VPC Lattice de um serviço.
Para obter mais informações, consulte [Uso do Service Connect para conectar serviços do Amazon ECS com nomes abreviados](service-connect.md).
No exemplo a seguir, ambos os campos obrigatórios para o Service Connect e o VPC Lattice são usados.
```
"portMappings": [
{
"name": string,
"containerPort": integer
}
]
```
`protocol`
Tipo: string
Obrigatório: não
O protocolo usado no mapeamento da porta. Os valores válidos são `tcp` e `udp`. O padrão é `tcp`.
Só `tcp` é compatível com o Service Connect. Lembre-se de que `tcp` estará implícito se esse campo não estiver definido.
Caso você esteja especificando uma porta host, use a seguinte sintaxe:
```
"portMappings": [
{
"containerPort": integer,
"hostPort": integer
}
...
]
```
Caso você queira uma porta host atribuída automaticamente, use a seguinte sintaxe:
```
"portMappings": [
{
"containerPort": integer
}
...
]
```
#### Credenciais de repositório privado
`repositoryCredentials`
Tipo: objeto [RepositoryCredentials](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RepositoryCredentials.html)
Obrigatório: não
As credenciais do repositório para autenticação de registro privado.
Para obter mais informações, consulte [Uso de imagens de contêiner que não são da AWS no Amazon ECS](private-auth.md).
`credentialsParameter`
Tipo: string
Exigido: Sim, quando `repositoryCredentials` são usados
O nome de recurso da Amazon (ARN) do segredo que contém as credenciais do repositório privado.
Para obter mais informações, consulte [Uso de imagens de contêiner que não são da AWS no Amazon ECS](private-auth.md).
Quando você usa a API do Amazon ECS, a AWS CLI ou os AWS SDKs, se o segredo existir na mesma região da tarefa que estiver sendo executada, será possível usar o ARN completo ou o nome do segredo. Ao usar o Console de gerenciamento da AWS, é preciso especificar o ARN completo do segredo.
Veja a seguir um trecho de uma definição de tarefa que mostra os parâmetros necessários.
```
"containerDefinitions": [
{
"image": "private-repo/private-image",
"repositoryCredentials": {
"credentialsParameter": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name"
}
}
]
```
### Parâmetros avançados de definição de contêiner
Os parâmetros avançados de definição de contêiner a seguir fornecem recursos estendidos ao comando run do docker usado para iniciar contêineres nas instâncias de contêiner do Amazon ECS.
**Topics**
+ [
#### Política de reinicialização
](#container_definition_restart_policy)
+ [
#### Verificação de integridade
](#container_definition_healthcheck)
+ [
#### Environment
](#container_definition_environment)
+ [
#### Configurações de rede
](#container_definition_network)
+ [
#### Armazenamento e registro
](#container_definition_storage)
+ [
#### Segurança
](#container_definition_security)
+ [
#### Limites de recurso
](#container_definition_limits)
+ [
#### Rótulos do Docker
](#container_definition_labels)
#### Política de reinicialização
`restartPolicy`
A política de reinicialização do contêiner e os parâmetros de configuração associados. Quando você configura uma política de reinicialização para um contêiner, o Amazon ECS pode reiniciar o contêiner sem precisar substituir a tarefa. Para obter mais informações, consulte [Reiniciar contêineres individuais em tarefas do Amazon ECS com políticas de reinicialização de contêineres](container-restart-policy.md).
`enabled`
Tipo: booliano
Obrigatório: Sim
Especifica se uma política de reinicialização está habilitada para o contêiner.
`ignoredExitCodes`
Tipo: matriz de inteiros
Obrigatório: não
Uma lista de códigos de saída que o Amazon ECS ignorará e não tentará reiniciar. Você pode especificar um máximo de 50 códigos de saída de contêiner. Por padrão, o Amazon ECS não ignora nenhum código de saída.
`restartAttemptPeriod`
Tipo: inteiro
Obrigatório: não
A quantidade de tempo (em segundos) que o contêiner deve ser executado antes de uma tentativa de reinicialização. Um contêiner só pode ser reiniciado uma vez a cada `restartAttemptPeriod` segundos. Se um contêiner não puder ser executado nesse período e sair mais cedo, ele não será reiniciado. Você pode especificar um `restartAttemptPeriod` mínimo de 60 segundos e um `restartAttemptPeriod` máximo de 1800 segundos. Por padrão, um contêiner deve ser executado por 300 segundos antes de ser reiniciado.
#### Verificação de integridade
`healthCheck`
O comando da verificação de integridade de contêiner e os parâmetros de configuração associados para o contêiner. Para obter mais informações, consulte [Como determinar a integridade das tarefas do Amazon ECS usando verificações de integridade de contêineres](healthcheck.md).
`command`
Uma matriz de strings que representa o comando executado pelo contêiner para determinar se ela está íntegra. A matriz de strings pode começar com `CMD` para executar os argumentos de comando diretamente ou `CMD-SHELL` para executar o comando com o shell padrão do contêiner. Se nenhuma for especificado, `CMD` será usada.
Ao registrar uma definição de tarefa no Console de gerenciamento da AWS, use uma lista de comandos separados por vírgulas. Esses comandos serão convertidos em uma string após a criação da definição de tarefa. Veja a seguir um exemplo de entrada para uma verificação de integridade.
```
CMD-SHELL, curl -f http://localhost/ || exit 1
```
Ao registrar uma definição de tarefa usando o painel JSON do Console de gerenciamento da AWS, a AWS CLI ou as APIs, delimite a lista de comandos por colchetes. Veja a seguir um exemplo de entrada para uma verificação de integridade.
```
[ "CMD-SHELL", "curl -f http://localhost/ || exit 1" ]
```
Um código de saída 0, sem saída de `stderr`, indica sucesso, e um código de saída diferente de zero indica falha.
`interval`
O período em segundos entre cada verificação de integridade. É possível especificar entre 5 e 300 segundos. O valor padrão de é 30 segundos.
`timeout`
O período de espera (em segundos) para que uma verificação de integridade seja bem-sucedida antes de ser considerada uma falha. É possível especificar entre 2 e 60 segundos. O valor de padrão é 5 segundos.
`retries`
O número de novas tentativas de uma verificação de integridade com falha até o contêiner ser considerado não íntegro. É possível especificar entre 1 e 10 novas tentativas. O valor padrão é três novas tentativas.
`startPeriod`
O período de carência opcional para que os contêineres possam inicializar antes de as verificações de integridade com falha serem contabilizadas no número máximo de novas tentativas. Você pode especificar um valor entre 0 e 300 segundos. Por padrão, o `startPeriod` está desabilitado.
Se uma verificação de integridade for bem-sucedida dentro do `startPeriod`, então o contêiner é considerado saudável e quaisquer falhas subsequentes contam para o número máximo de novas tentativas.
#### Environment
`cpu`
Tipo: inteiro
Obrigatório: não
O número de unidades de `cpu` que o agente de contêiner do Amazon ECS reservará para o contêiner. No Linux, esse parâmetro é mapeado como `CpuShares` na seção [Criar um contêiner](https://docs.docker.com/reference/api/engine/version/v1.38/#operation/ContainerCreate).
Esse campo é opcional para tarefas que usam o Fargate. A quantidade total de CPU reservada para todos os contêineres dentro da tarefa deve ser menor que o valor `cpu` de nível da tarefa.
Os contêineres de Linux compartilham unidades de CPU não alocadas com outros contêineres na instância de contêiner que tem a mesma proporção que a respectiva quantidade alocada. Por exemplo, suponha que você execute uma tarefa de contêiner único em um tipo de instância de núcleo único com 512 unidades de CPU especificadas para esse contêiner. Além disso, essa tarefa é a única em execução na instância de contêiner. Nesse exemplo, o contêiner pode utilizar o compartilhamento total de 1.024 unidades de CPU a qualquer momento. Porém, suponha que você tenha iniciado outra cópia da mesma tarefa nessa instância de contêiner. Cada tarefa tem garantido um mínimo de 512 unidades de CPU quando necessário. Da mesma forma, se o outro contêiner não estiver usando a CPU restante, cada contêiner poderá flutuar para o uso maior da CPU. Porém, se ambas as tarefas estiverem 100% ativas o tempo todo, elas ficarão limitadas a 512 unidades de CPU.
Nas instâncias de contêiner de Linux, o daemon do Docker na instância de contêiner usa o valor de CPU para calcular as proporções de compartilhamento de CPU para contêineres em execução. O valor de compartilhamento de CPU mínimo válido permitido pelo kernel do Linux é 2 e o valor de compartilhamento de CPU máximo válido permitido pelo kernel do Linux é 262144. No entanto, o parâmetro de CPU não é necessário, e é possível usar valores de CPU abaixo de dois e superior a 262144 em suas definições de contêiner. Para valores de CPU abaixo de dois (inclusive nulo) e acima de 262144, o comportamento varia com base na versão do agente de contêiner do Amazon ECS:
Nas instâncias de contêiner de Windows, a cota de CPU é imposta como uma cota absoluta. Os contêineres de Windows só têm acesso à quantidade de CPU especificada na definição de tarefa. Um valor de CPU nulo ou zero é transmitido para Docker como `0`. Em seguida, Windows interpreta esse valor como 1% de uma CPU.
Para obter exemplos adicionais, consulte [Como o Amazon ECS gerencia recursos de CPU e memória](https://aws.amazon.com/blogs/containers/how-amazon-ecs-manages-cpu-and-memory-resources/).
`gpu`
Esse parâmetro não é compatível com contêineres hospedados no Fargate.
Tipo: objeto [ResourceRequirement](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ResourceRequirement.html)
Obrigatório: não
O número de `GPUs` físicas que o agente de contêiner do Amazon ECS reservará para o contêiner. O número de GPUs reservadas para todos os contêineres em uma tarefa não deve exceder o número de GPUs disponíveis na instância de contêiner na qual a tarefa é executada. Para obter mais informações, consulte [Definições de tarefa do Amazon ECS para workloads de GPU](ecs-gpu.md).
`Elastic Inference accelerator`
Esse parâmetro não é compatível com contêineres hospedados no Fargate.
Tipo: objeto [ResourceRequirement](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ResourceRequirement.html)
Obrigatório: não
Para o tipo `InferenceAccelerator`, o `value` corresponde ao `deviceName` para um `InferenceAccelerator` especificado em uma definição de tarefa. Para obter mais informações, consulte [Nome do acelerador do Elastic Inference (obsoleto)](#elastic-Inference-accelerator).
`essential`
Tipo: booliano
Obrigatório: não
Suponha que o parâmetro `essential` de um contêiner esteja marcado como `true`, e que esse contêiner falhe ou seja interrompido por algum motivo. Em seguida, todos os outros contêineres que fazem parte da tarefa são interrompidos. Caso o parâmetro `essential` de um contêiner esteja marcado como `false`, a falha não afeta o restante dos contêineres em uma tarefa. Caso esse parâmetro seja omitido, um contêiner pressupõe-se que um contêiner seja essencial.
Todas as tarefas devem ter pelo menos um contêiner essencial. Suponha que você tenha uma aplicação composta por vários contêineres. Em seguida, agrupe os contêineres usados para uma finalidade em comum em componentes e separe os componentes diferentes em várias definições de tarefa. Para obter mais informações, consulte [Projetar sua aplicação para o Amazon ECS](application_architecture.md).
```
"essential": true|false
```
`entryPoint`
As versões anteriores do agente de contêiner do Amazon ECS não lidam corretamente com parâmetros `entryPoint`. Caso você enfrente problemas para usar `entryPoint`, atualize o agente de contêiner ou informe os comandos e os argumentos como itens de matriz `command` em vez disso.
Tipo: Matriz de strings
Obrigatório: não
O ponto de entrada passado para o contêiner.
```
"entryPoint": ["string", ...]
```
`command`
Tipo: Matriz de strings
Obrigatório: não
O comando que é passado para o contêiner. Esse parâmetro é mapeado para `Cmd` no comando create-container e o parâmetro `COMMAND` de execução do docker. Se houver vários argumentos, certifique-se de que cada um seja uma string separada na matriz.
```
"command": ["string", ...]
```
`workingDirectory`
Tipo: string
Obrigatório: não
O diretório de trabalho no qual executar comandos no contêiner. Esse parâmetro é mapeado para `WorkingDir` na seção [Criar um Contêiner](https://docs.docker.com/reference/api/engine/version/v1.38/#operation/ContainerCreate) da [API remota do Docker](https://docs.docker.com/reference/api/engine/version/v1.38/) e a opção `--workdir` para [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/).
```
"workingDirectory": "string"
```
`environmentFiles`
Isso não está disponível para contêineres do Windows no Fargate.
Tipo: Matriz de objeto
Obrigatório: não
Uma lista de arquivos que contêm as variáveis de ambiente a serem passadas para um contêiner. Esse parâmetro é mapeado para a opção `--env-file` para o comando run do docker.
É possível especificar até 10 arquivos de ambiente. O arquivo deve ter uma extensão `.env`. Cada linha em um arquivo de ambiente contém uma variável de ambiente no formato `VARIABLE=VALUE`. As linhas que começam com `#` são tratadas como comentários e são ignoradas.
Se houver variáveis de ambiente individuais especificadas na definição de contêiner, elas terão precedência sobre as variáveis contidas em um arquivo de ambiente. Se forem especificados vários arquivos de ambiente que contenham a mesma variável, elas serão processadas de cima para baixo. Recomendamos usar nomes de variáveis exclusivos. Para obter mais informações, consulte [Transferência de uma variável de ambiente individual para um contêiner do Amazon ECS](taskdef-envfiles.md).
`value`
Tipo: String
Exigido: sim
O nome de recurso da Amazon (ARN) do objeto do Amazon S3 que contém o arquivo de variáveis de ambiente.
`type`
Tipo: String
Exigido: sim
Tipo de arquivo a ser usado O único valor aceito é `s3`.
`environment`
Tipo: Matriz de objeto
Obrigatório: não
As variáveis de ambiente a serem passadas para um contêiner. Esse parâmetro é mapeado para `Env` no comando create-container do docker na opção `--env` para o comando run do docker.
Não recomendamos o uso de variáveis de ambiente de texto simples para informações confidenciais, tais como dados de credenciais.
`name`
Tipo: string
Exigido: sim, quando `environment` for usado
O nome da variável de ambiente.
`value`
Tipo: string
Exigido: sim, quando `environment` for usado
O valor da variável de ambiente.
```
"environment" : [
{ "name" : "string", "value" : "string" },
{ "name" : "string", "value" : "string" }
]
```
`secrets`
Tipo: Matriz de objeto
Obrigatório: não
Um objeto que representa o segredo a ser exposto ao seu contêiner. Para obter mais informações, consulte [Transferência de dados confidenciais para um contêiner do Amazon ECS](specifying-sensitive-data.md).
`name`
Tipo: String
Exigido: sim
O valor a ser definido como a variável de ambiente no contêiner.
`valueFrom`
Tipo: String
Exigido: sim
O segredo a ser exposto ao contêiner. Os valores com suporte são o nome do recurso da Amazon (ARN) completo do segredo do AWS Secrets Manager ou o ARN completo do parâmetro no Parameter Store do AWS Systems Manager.
Se o parâmetro do Systems Manager Parameter Store ou do Secrets Manager existir na mesma Região da AWS que a tarefa sendo iniciada, você poderá usar o ARN completo ou o nome do segredo. Se o parâmetro existir em uma Região diferente, o ARN completo deverá ser especificado.
```
"secrets": [
{
"name": "environment_variable_name",
"valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
}
]
```
#### Configurações de rede
`disableNetworking`
Esse parâmetro não é compatível com tarefas que são executadas no Fargate.
Tipo: booliano
Obrigatório: não
Quando esse parâmetro é verdadeiro, a rede é desativada dentro do contêiner.
O padrão é `false`.
```
"disableNetworking": true|false
```
`links`
Esse parâmetro não é compatível com tarefas que usam o modo de rede `awsvpc`.
Tipo: Matriz de strings
Obrigatório: não
O parâmetro `link` permite que os contêineres se comuniquem entre si sem a necessidade de mapeamentos de porta. Só há suporte para esse parâmetro se o modo de rede de uma definição de tarefa estiver definido como `bridge`. O construto `name:internalName` é igual ao `name:alias` em links do Docker. São permitidos até 255 letras (caixa alta e baixa), números, hífens e sublinhados.
Os contêineres colocados na mesma instância de contêiner podem se comunicar entre si sem exigir links ou mapeamentos de porta de host. O isolamento de rede em uma instância de contêiner é controlado por grupos de segurança e configurações de VPC.
```
"links": ["name:internalName", ...]
```
`hostname`
Tipo: string
Obrigatório: não
O nome de host a ser usado para o contêiner. Esse parâmetro é mapeado para `Hostname` em create-container do docker na opção `--hostname` de execução do docker.
Se você estiver usando o modo de rede `awsvpc`, o parâmetro `hostname` não terá suporte.
```
"hostname": "string"
```
`dnsServers`
Esse parâmetro não é compatível com tarefas sendo executadas no Fargate.
Tipo: Matriz de strings
Obrigatório: não
Uma lista de servidores DNS apresentados ao contêiner.
```
"dnsServers": ["string", ...]
```
`extraHosts`
Esse parâmetro não é compatível com tarefas que usam o modo de rede `awsvpc`.
Tipo: Matriz de objeto
Obrigatório: não
Uma lista de nomes de host e mapeamentos de endereço IP a ser acrescentada ao arquivo `/etc/hosts` no contêiner.
Esse parâmetro é mapeado para `ExtraHosts` no comando create-container do docker na opção `--add-host` de execução do docker.
```
"extraHosts": [
{
"hostname": "string",
"ipAddress": "string"
}
...
]
```
`hostname`
Tipo: string
Exigido: Sim, quando `extraHosts` são usados
O nome do host a ser usado na entrada `/etc/hosts`.
`ipAddress`
Tipo: string
Exigido: Sim, quando `extraHosts` são usados
O endereço IP a ser usado na entrada `/etc/hosts`.
#### Armazenamento e registro
`readonlyRootFilesystem`
Tipo: booliano
Obrigatório: Não
Quando esse parâmetro é verdadeiro, o contêiner recebe acesso somente leitura ao sistema de arquivos raiz. Esse parâmetro é mapeado para `ReadonlyRootfs` no comando create-container do docker na opção `--read-only` de execução do docker.
Este parâmetro não é compatível com contêineres do Windows.
O padrão é `false`.
```
"readonlyRootFilesystem": true|false
```
`mountPoints`
Tipo: Matriz de objeto
Obrigatório: não
Os pontos de montagem dos volumes de dados no contêiner. Esse parâmetro é mapeado em `Volumes` na API create-container do Docker na opção `--volume` de execução do docker.
Os contêineres do Windows podem montar diretórios inteiros na mesma unidade como `$env:ProgramData`. Os contêineres do Windows não podem montar diretórios em uma unidade diferente, e os pontos de montagem não podem ser usados entre unidades. Você deve especificar pontos de montagem para anexar um volume do Amazon EBS diretamente a uma tarefa do Amazon ECS.
`sourceVolume`
Tipo: string
Exigido: Sim, quando `mountPoints` são usados
O nome do volume a ser montado.
`containerPath`
Tipo: string
Exigido: Sim, quando `mountPoints` são usados
O caminho no contêiner onde o volume será montado.
`readOnly`
Tipo: booliano
Obrigatório: não
Caso o valor seja `true`, o contêiner tem acesso somente leitura ao volume. Caso esse valor seja `false`, o contêiner pode gravar no volume. O valor padrão é `false`.
Para tarefas executadas em instâncias do EC2 que executam o sistema operacional Windows, deixe o valor como o padrão de `false`.
`volumesFrom`
Tipo: Matriz de objeto
Obrigatório: não
Volumes de dados a serem montados de outro contêiner. Esse parâmetro é mapeado para `VolumesFrom` no comando create-container do docker na opção `--volumes-from` de execução do docker.
`sourceContainer`
Tipo: string
Exigido: sim, quando `volumesFrom` for usado
O nome do contêiner com base no qual montar volumes.
`readOnly`
Tipo: booliano
Obrigatório: não
Caso o valor seja `true`, o contêiner tem acesso somente leitura ao volume. Caso esse valor seja `false`, o contêiner pode gravar no volume. O valor padrão é `false`.
```
"volumesFrom": [
{
"sourceContainer": "string",
"readOnly": true|false
}
]
```
`logConfiguration`
Tipo: objeto [LogConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html)
Obrigatório: não
A especificação de configuração do log para o contêiner.
Para obter definições de tarefa de exemplo que usam uma configuração de log, consulte [Exemplos de definições de tarefa do Amazon ECS](example_task_definitions.md).
Esse parâmetro é mapeado para `LogConfig` no comando create-container do docker na opção `--log-driver` de execução do docker. Por padrão, os contêineres usam o mesmo driver de registro em log que o daemon do Docker usa. No entanto, o contêiner pode usar um driver de registro em log diferente do daemon do Docker especificando um driver de log com esse parâmetro na definição de contêiner. Para usar um driver de registro em log diferente para um contêiner, o sistema de log deve ser configurado corretamente na instância de contêiner (ou em um servidor de log diferente para opções de registro em log remotas).
Considere o seguinte ao especificar uma configuração de log para seus contêineres:
+ O Amazon ECS oferece suporte a um subconjunto dos drivers de registro em log disponíveis para o daemon Docker.
+ Esse parâmetro exige a versão 1.18 ou posterior da API remota do Docker na sua instância de contêiner.
+ Qualquer software adicional deve ser instalado fora da tarefa. Por exemplo, os agregadores de saída Fluentd ou um host remoto executando o Logstash para o qual enviar logs Gelf.
```
"logConfiguration": {
"logDriver": "awslogs","fluentd","gelf","json-file","journald","splunk","syslog","awsfirelens",
"options": {"string": "string"
...},
"secretOptions": [{
"name": "string",
"valueFrom": "string"
}]
}
```
`logDriver`
Tipo: string
Valores válidos: `"awslogs","fluentd","gelf","json-file","journald","splunk","syslog","awsfirelens"`
Exigido: sim, quando `logConfiguration` for usado
O driver de log a ser usado para o contêiner. Por padrão, os valores válidos listados anteriormente são drivers de log com os quais o agente de contêiner do Amazon ECS pode se comunicar.
Os drivers de log compatíveis são `awslogs`, `splunk` e `awsfirelens`.
Para obter mais informações sobre como usar o driver de log `awslogs` nas definições de tarefa para enviar os logs de contêiner ao CloudWatch Logs, consulte [Envio de logs do Amazon ECS para o CloudWatch](using_awslogs.md).
Para obter mais informações sobre como usar o driver de log `awsfirelens`, consulte [Roteamento de logs personalizados](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html).
Se tiver um driver personalizado que não esteja listado acima, será possível bifurcar o projeto do agente de contêiner do Amazon ECS que está [disponível no GitHub](https://github.com/aws/amazon-ecs-agent) e personalizá-lo para funcionar com esse driver. Incentivamos você a enviar solicitações pull para alterações que você gostaria de ter incluído. Porém, no momento, não oferecemos suporte à execução de cópias modificadas desse software.
Este parâmetro requer a versão 1.18 da Docker Remote API ou posterior em sua instância de contêiner.
`options`
Tipo: mapa de string para string
Obrigatório: não
O mapa chave/valor de opções de configuração a serem enviadas para o driver de log.
As opções que você pode especificar dependem do driver de log. Algumas das opções que você pode especificar ao usar o roteador `awslogs` para rotear os logs para o Amazon CloudWatch incluem o seguinte:
`awslogs-create-group`
Obrigatório: não
Especifique se você deseja que o grupo de logs seja criado automaticamente. Se essa opção não for especificada, o padrão será `false`.
Sua política do IAM deve incluir a permissão `logs:CreateLogGroup` antes que você tente usar `awslogs-create-group`.
`awslogs-region`
Obrigatório: Sim
Especifique a Região da AWS para a qual o driver de log do `awslogs` deve enviar seus logs do Docker. É possível optar por enviar todos os logs de clusters em regiões distintas para uma única região no CloudWatch Logs. Isso tem o objetivo de fazer com que todos fiquem visíveis em um único local. Caso contrário, você pode separá-los por região para mais granularidade. Certifique-se de que o grupo de logs especificado exista na região especificada com essa opção.
`awslogs-group`
Obrigatório: Sim
Certifique-se de especificar um grupo de logs para o qual o driver de log do `awslogs` envia seus fluxos de logs.
`awslogs-stream-prefix`
Obrigatório: Sim
Use a opção `awslogs-stream-prefix` para associar um fluxo de log ao prefixo especificado, ao nome do contêiner e ao ID da tarefa do Amazon ECS à qual o contêiner pertence. Caso você especifique um prefixo com essa opção, o fluxo de log utiliza o seguinte formato.
```
prefix-name/container-name/ecs-task-id
```
Se você não especificar um prefixo com essa opção, o fluxo de log será nomeado depois que o ID do contêiner for atribuído pelo daemon do Docker na instância de contêiner. Como é difícil rastrear logs até o contêiner que os enviou apenas com o ID do contêiner do Docker (disponível apenas na instância de contêiner), recomendamos especificar um prefixo com essa opção.
Para serviços do Amazon ECS, é possível utilizar o nome do serviço como prefixo. Ao fazer isso, será possível rastrear fluxos de logs até o serviço ao qual o contêiner pertence, o nome do contêiner que os enviou e o ID da tarefa à qual o contêiner pertence.
Você deve especificar um stream-prefix para seus logs para fazer com que eles apareçam no painel Logs quando o console do Amazon ECS for usado.
`awslogs-datetime-format`
Obrigatório: não
Essa opção define um padrão de início de várias linhas no formato `strftime` em Python. Uma mensagem de log é formada por uma linha em conformidade com o padrão e as linhas seguintes que não correspondem ao padrão. A linha em conformidade é o delimitador entre as mensagens de log.
Um exemplo de um caso de uso para esse formato é a análise da saída, como um despejo de pilha, que poderia ser registrado em várias entradas. O padrão correto permite que ele seja capturado em uma única entrada.
Para obter mais informações, consulte [awslogs-datetime-format](https://docs.docker.com/engine/logging/drivers/awslogs/#awslogs-datetime-format).
Você não pode configurar as opções `awslogs-datetime-format` e `awslogs-multiline-pattern`.
O registro em várias linhas executa a análise da expressão regular e a correspondência de todas as mensagens de log. Isso pode ter um impacto negativo na performance do registro em log.
`awslogs-multiline-pattern`
Obrigatório: não
Essa opção define um padrão inicial de várias linhas que usa uma expressão regular. Uma mensagem de log é formada por uma linha em conformidade com o padrão e as linhas seguintes que não correspondem ao padrão. A linha em conformidade é o delimitador entre as mensagens de log.
Para obter mais informações, consulte [awslogs-multiline-pattern](https://docs.docker.com/engine/logging/drivers/awslogs/#awslogs-multiline-pattern).
Essa opção será ignorada se `awslogs-datetime-format` também estiver configurado.
Você não pode configurar as opções `awslogs-datetime-format` e `awslogs-multiline-pattern`.
O registro em várias linhas executa a análise da expressão regular e a correspondência de todas as mensagens de log. Isso pode ter um impacto negativo na performance do registro em log.
As opções a seguir se aplicam a todos os drivers de logs compatíveis.
`mode`
Obrigatório: não
Valores válidos: `non-blocking` \$1 `blocking`
Essa opção define o modo de entrega de mensagens de log do contêiner para o driver de logs especificado usando o `logDriver`. O modo de entrega escolhido afeta a disponibilidade da aplicação quando o fluxo de logs do contêiner é interrompido.
Se você usar o modo `blocking` e o fluxo de logs for interrompido, as chamadas do código do contêiner para gravar nos fluxos `stdout` e `stderr` serão bloqueadas. Como resultado, o encadeamento de logs da aplicação será bloqueado. Isso pode fazer com que a aplicação pare de responder e causar uma falha na verificação de integridade do contêiner.
Se você usar o modo `non-blocking`, os registros do contêiner serão armazenados em um buffer intermediário na memória configurado com a opção `max-buffer-size`. Isso evita que a aplicação pare de responder quando não for possível enviar os logs. Recomendamos usar esse modo se você quiser garantir a disponibilidade do serviço e aceitar alguma perda de logs. Para obter mais informações, consulte [Preventing log loss with non-blocking mode in the `awslogs` container log driver](https://aws.amazon.com/blogs/containers/preventing-log-loss-with-non-blocking-mode-in-the-awslogs-container-log-driver/).
Você pode definir um `mode` padrão para todos os contêineres em uma determinada Região da AWS usando a configuração de conta `defaultLogDriverMode`. Se você não especificar a opção de `mode` na `logConfiguration` nem definir a configuração de conta, o Amazon ECS usará o modo `non-blocking` como padrão. Para obter mais informações sobre a configuração de conta, consulte [Modo de driver de logs padrão](ecs-account-settings.md#default-log-driver-mode).
Quando o modo `non-blocking` é usado, a opção de log `max-buffer-size` controla o tamanho do buffer de anel usado para armazenamento de mensagens intermediárias. Certifique-se de especificar um tamanho de buffer adequado com base na sua aplicação. A quantidade total de memória alocada no nível da tarefa deve ser maior que a quantidade de memória alocada para todos os contêineres, mais o limite de buffer da memória.
Em 25 de junho de 2025, o Amazon ECS alterou o modo padrão do driver de log de `blocking` para `non-blocking` a fim de priorizar a disponibilidade das tarefas em relação ao registro em log. Para continuar usando o modo `blocking` após essa alteração, siga uma destas opções:
+ Defina a opção `mode` na definição `logConfiguration` do seu contêiner como `blocking`.
+ Defina a configuração da conta `defaultLogDriverMode` como `blocking`.
`max-buffer-size`
Obrigatório: não
Valor padrão: `10m`
Quando o modo `non-blocking` é usado, a opção de log `max-buffer-size` controla o tamanho do buffer de anel usado para armazenamento de mensagens intermediárias. Certifique-se de especificar um tamanho de buffer adequado com base na sua aplicação. Quando o buffer ficar cheio, logs adicionais não poderão ser armazenados. Os logs que não puderem ser armazenados serão perdidos.
Para rotear logs usando o roteador de logs do `splunk`, você precisa especificar um `splunk-token` e um `splunk-url`.
Ao usar o roteador de log `awsfirelens` para rotear logs para um destino do AWS service (Serviço da AWS) ou do AWS Partner Network para armazenamento e analytics de logs, você pode definir a opção `log-driver-buffer-limit` para limitar o número de linhas de log que são armazenadas em buffer na memória antes de serem enviadas ao contêiner do roteador de logs. Isso pode ajudar a resolver possíveis problemas de perda de logs, pois o alto throughput pode resultar na falta de memória para o buffer dentro do Docker. Para obter mais informações, consulte [Configuração de logs do Amazon ECS para obtenção de alto throughput](firelens-docker-buffer-limit.md).
Outras opções que você pode especificar ao usar o `awsfirelens` para rotear logs dependem do destino. Ao exportar logs para o Amazon Data Firehose, você pode especificar a Região da AWS com a `region` e um nome para o fluxo de logs com `delivery_stream`.
Ao exportar logs para o Amazon Kinesis Data Streams, você pode especificar um Região da AWS com a `region` um com e um nome de fluxo de dados com `stream`.
Ao exportar logs para o Amazon OpenSearch Service, você pode especificar opções como `Name`, `Host` (endpoint do OpenSearch Service sem protocolo) `Port`, `Index`, `Type`, `Aws_auth`, `Aws_region`, `Suppress_Type_Name` e `tls`.
Ao exportar logs para o Amazon S3, você pode especificar o bucket usando a opção `bucket`. Você também pode especificar `region`, `total_file_size`, `upload_timeout` e `use_put_object` como opções.
Este parâmetro requer a versão 1.19 da Docker Remote API ou posterior em sua instância de contêiner.
`secretOptions`
Tipo: Matriz de objeto
Obrigatório: não
Um objeto que representa o segredo a ser passado para a configuração de log. Os segredos usados na configuração de log podem incluir tokens de autenticação, certificados ou chaves de criptografia. Para obter mais informações, consulte [Transferência de dados confidenciais para um contêiner do Amazon ECS](specifying-sensitive-data.md).
`name`
Tipo: String
Exigido: sim
O valor a ser definido como a variável de ambiente no contêiner.
`valueFrom`
Tipo: String
Exigido: sim
O segredo a ser exposto à configuração de log do contêiner.
```
"logConfiguration": {
"logDriver": "splunk",
"options": {
"splunk-url": "https://cloud.splunk.com:8080",
"splunk-token": "...",
"tag": "...",
...
},
"secretOptions": [{
"name": "splunk-token",
"valueFrom": "/ecs/logconfig/splunkcred"
}]
}
```
`firelensConfiguration`
Tipe: objeto [FirelensConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_FirelensConfiguration.html)
Obrigatório: não
A configuração do FireLens para o contêiner. Isso é usado para especificar e configurar um roteador de log para logs de contêiner. Para obter mais informações, consulte [Envio de logs do Amazon ECS para um serviço da AWS ou para uma AWS Partner](using_firelens.md).
```
{
"firelensConfiguration": {
"type": "fluentd",
"options": {
"KeyName": ""
}
}
}
```
`options`
Tipo: Mapa de string para string
Obrigatório: não
O mapa chave/valor de opções a serem usadas ao configurar o roteador de log. Esse campo é opcional e pode ser usado para especificar um arquivo de configuração personalizado ou para adicionar outros metadados, como a tarefa, a definição de tarefa, o cluster e detalhes da instância de contêiner ao evento de log. Se especificado, a sintaxe a ser usada é `"options":{"enable-ecs-log-metadata":"true|false","config-file-type:"s3|file","config-file-value":"arn:aws:s3:::amzn-s3-demo-bucket/fluent.conf|filepath"}`. Para obter mais informações, consulte [Exemplo de definição de tarefa do Amazon ECS: rotear logs para o FireLens](firelens-taskdef.md).
`type`
Tipo: String
Exigido: sim
O roteador de log a ser usado. Os valores válidos são `fluentd` ou `fluentbit`.
#### Segurança
Para obter mais informações sobre a segurança de contêineres, consulte [Práticas recomendadas de segurança de tarefas e contêineres no Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/security-tasks-containers.html).
`credentialSpecs`
Tipo: Matriz de strings
Obrigatório: não
Uma lista de ARNs no SSM ou no Amazon S3 para um arquivo de especificação de credencial (`CredSpec`) que configura o contêiner para autenticação do Active Directory. Recomendamos o uso deste parâmetro, em vez de `dockerSecurityOptions`. O número máximo de ARNs é 1.
Há dois formatos para cada ARN.
credentialspecdomainless:MyARN
Você usa `credentialspecdomainless:MyARN` para fornecer uma `CredSpec` com uma seção adicional para um segredo no Secrets Manager. Você fornece as credenciais de login para o domínio no segredo.
Cada tarefa executada em qualquer instância de contêiner pode se associar a domínios diferentes.
É possível usar esse formato sem associar a instância de contêiner a um domínio.
credentialspec:MyARN
Você usa `credentialspec:MyARN` para fornecer um `CredSpec` para um único domínio.
Você deve associar a instância de contêiner ao domínio antes de iniciar qualquer tarefa que use essa definição de tarefa.
Em ambos os formatos, substitua `MyARN` pelo ARN no SSM ou no Amazon S3.
A `credspec` deve fornecer um ARN no Secrets Manager para um segredo contendo o nome de usuário, a senha e o domínio ao qual se conectar. Para maior segurança, a instância não é associada ao domínio para autenticação sem domínio. Outras aplicações na instância não podem usar as credenciais sem domínio. É possível usar esse parâmetro para executar tarefas na mesma instância, mesmo que as tarefas precisem ser associadas a domínios diferentes. Para obter mais informações, consulte [Uso de gMSAs para contêineres de Windows](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows-gmsa.html) e [Uso de gMSAs para contêineres de Linux](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/linux-gmsa.html).
`user`
Tipo: string
Obrigatório: não
O usuário a ser utilizado dentro do contêiner. Esse parâmetro é mapeado para `User` no comando create-container do docker na opção `--user` de execução do docker.
Ao executar tarefas que usam o modo de rede `host`, não execute contêineres usando o usuário raiz (UID 0). Como uma prática recomendada de segurança, sempre utilize um usuário não raiz.
É possível especificar o `user` usando os formatos a seguir. Se especificar um UID ou um GID, você deverá especificá-lo como um número inteiro positivo.
+ `user`
+ `user:group`
+ `uid`
+ `uid:gid`
+ `user:gid`
+ `uid:group`
Este parâmetro não é compatível com contêineres do Windows.
```
"user": "string"
```
#### Limites de recurso
`ulimits`
Tipo: Matriz de objeto
Obrigatório: não
Lista de valores `ulimit` a serem definidos para um contêiner. Esse valor substitui a configuração de cota de recursos padrão do sistema operacional. Esse parâmetro é mapeado para `Ulimits` no comando create-container do docker na opção `--ulimit` de execução do docker.
As tarefas do Amazon ECS hospedadas no Fargate usam os valores de limite de recursos padrão limitados pelo sistema operacional, com exceção do parâmetro de limite de recursos `nofile`. O limite de recursos `nofile` define uma restrição sobre o número de arquivos abertos que um contêiner pode usar. No Fargate, o limite flexível padrão de `nofile` é ` 65535`, e o limite rígido é `65535`. É possível definir os valores de ambos os limites até `1048576`. Para obter mais informações, consulte [Limites de recursos de tarefa](fargate-tasks-services.md#fargate-resource-limits).
Este parâmetro requer a versão 1.18 da Docker Remote API ou posterior em sua instância de contêiner.
Este parâmetro não é compatível com contêineres do Windows.
```
"ulimits": [
{
"name": "core"|"cpu"|"data"|"fsize"|"locks"|"memlock"|"msgqueue"|"nice"|"nofile"|"nproc"|"rss"|"rtprio"|"rttime"|"sigpending"|"stack",
"softLimit": integer,
"hardLimit": integer
}
...
]
```
`name`
Tipo: string
Valores válidos: `"core" | "cpu" | "data" | "fsize" | "locks" | "memlock" | "msgqueue" | "nice" | "nofile" | "nproc" | "rss" | "rtprio" | "rttime" | "sigpending" | "stack"`
Exigido: Sim, quando `ulimits` são usados
O `type` do `ulimit`.
`hardLimit`
Tipo: inteiro
Exigido: Sim, quando `ulimits` são usados
O limite rígido do tipo `ulimit`. O valor pode ser especificado em bytes, segundos ou como uma contagem, dependendo `type` do `ulimit`.
`softLimit`
Tipo: inteiro
Exigido: Sim, quando `ulimits` são usados
O limite flexível do tipo `ulimit`. O valor pode ser especificado em bytes, segundos ou como uma contagem, dependendo `type` do `ulimit`.
#### Rótulos do Docker
`dockerLabels`
Tipo: mapa de string para string
Obrigatório: não
Um mapa de chave/valor de rótulos a ser adicionado ao contêiner. Esse parâmetro é mapeado para `Labels` no comando create-container do docker na opção `--label` de execução do docker.
Este parâmetro requer a versão 1.18 da Docker Remote API ou posterior em sua instância de contêiner.
```
"dockerLabels": {"string": "string"
...}
```
### Outros parâmetros de definição de contêiner
Os parâmetros de definição de contêiner a seguir podem ser usados durante o registro das definições de tarefa no console do Amazon ECS usando a opção **Configure via JSON** (Configurar via JSON). Para obter mais informações, consulte [Criar uma definição de tarefa do Amazon ECS usando o console](create-task-definition.md).
**Topics**
+ [
#### Parâmetros do Linux
](#container_definition_linuxparameters)
+ [
#### Dependência de contêiner
](#container_definition_dependson)
+ [
#### Tempos limite de contêiner
](#container_definition_timeout)
+ [
#### Controles do sistema
](#container_definition_systemcontrols)
+ [
#### Interativo
](#container_definition_interactive)
+ [
#### Pseudoterminal
](#container_definition_pseudoterminal)
#### Parâmetros do Linux
`linuxParameters`
Tipo: Objeto [LinuxParameters](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LinuxParameters.html)
Obrigatório: não
Opções específicas do Linux que são aplicadas ao contêiner, como [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html).
Não há suporte para este parâmetro em contêineres do Windows.
```
"linuxParameters": {
"capabilities": {
"add": ["string", ...],
"drop": ["string", ...]
}
}
```
`capabilities`
Tipo: objeto [KernelCapabilities](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html)
Obrigatório: não
Os recursos do Linux para o contêiner que são descartados da configuração padrão fornecida pelo Docker. Para obter mais informações sobre esses recursos do Linux, consulte a página do manual do Linux [recursos(7)](http://man7.org/linux/man-pages/man7/capabilities.7.html).
`add`
Tipo: Matriz de strings
Valores válidos: `"SYS_PTRACE"`
Obrigatório: não
Os recursos do Linux para o contêiner que são adicionados à configuração padrão que é fornecida pelo Docker. Esse parâmetro é mapeado para `CapAdd` no comando create-container do docker na opção `--cap-add` de execução do docker.
`drop`
Tipo: Matriz de strings
Valores válidos: `"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"`
Obrigatório: não
Os recursos do Linux para o contêiner que são removidos da configuração padrão fornecida pelo Docker. Esse parâmetro é mapeado para `CapDrop` no comando create-container do docker na opção `--cap-drop` de execução do docker.
`devices`
Todos os dispositivos do host a serem expostos ao contêiner. Esse parâmetro é mapeado para `Devices` no comando create-container do docker na opção `--device` de execução do docker.
O parâmetro `devices` não é compatível com o tipo de inicialização do Fargate.
Tipo: Matriz de objetos [Device](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Device.html)
Obrigatório: não
`hostPath`
O caminho para o dispositivo na instância de contêiner host.
Tipo: String
Exigido: sim
`containerPath`
O caminho dentro do contêiner no qual expor o dispositivo do host.
Tipo: string
Obrigatório: não
`permissions`
As permissões explícitas a serem fornecidas ao contêiner para o dispositivo. Por padrão, o contêiner tem permissões para `read`, `write` e `mknod` no dispositivo.
Tipo: matriz de strings
Valores válidos: `read` \$1 `write` \$1 `mknod`
`initProcessEnabled`
Execute um processo `init` dentro do contêiner que encaminha sinais e colhe processos. Esse parâmetro é mapeado para a opção `--init` de execução do docker.
Este parâmetro requer a versão 1.25 ou posterior da Docker Remote API ou posterior em sua instância de contêiner.
`maxSwap`
Esse parâmetro não é compatível com tarefas sendo executadas no Fargate.
A quantidade total de memória de troca (em MiB) que um contêiner pode usar. Esse parâmetro será convertido na opção `--memory-swap` para execução do docker em que o valor é a soma da memória do contêiner mais o valor de `maxSwap`.
Se um valor `maxSwap` de `0` for especificado, o contêiner não usará a troca. Os valores aceitos são `0` ou qualquer número inteiro positivo. Se o parâmetro `maxSwap` for omitido, o contêiner usará a configuração de troca para a instância de contêiner na qual ele está sendo executado. Um valor `maxSwap` deve ser definido para que o parâmetro `swappiness` seja usado.
`sharedMemorySize`
O valor do tamanho (em MiB) do volume `/dev/shm`. Esse parâmetro é mapeado para a opção `--shm-size` de execução do docker.
Se você estiver usando tarefas que utilizam o Fargate, o parâmetro `sharedMemorySize` não será compatível.
Tipo: inteiro
`tmpfs`
O caminho do contêiner, as opções de montagem e o tamanho (em MiB) da montagem do tmpfs. Esse parâmetro é mapeado para a opção `--tmpfs` de execução do docker.
Tipo: Matriz de objetos [Tmpfs](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Tmpfs.html)
Obrigatório: não
`containerPath`
O caminho absoluto do arquivo no qual o volume tmpfs deve ser montado.
Tipo: String
Obrigatório: Sim
`mountOptions`
A lista de opções de montagem do volume tmpfs.
Tipo: matriz de strings
Obrigatório: Não
Valores válidos: `"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"`
`size`
O tamanho máximo (em MiB) do volume tmpfs.
Tipo: inteiro
Obrigatório: Sim
#### Dependência de contêiner
`dependsOn`
Tipo: matriz de objetos [ContainerDependency](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDependency.html)
Obrigatório: não
As dependências definidas para startup e desligamento do contêiner. Um contêiner pode conter várias dependências. Quando uma dependência é definida para o startup do contêiner, ela é revertida para o desligamento do contêiner. Para ver um exemplo, consulte [Dependência de contêiner](example_task_definitions.md#example_task_definition-containerdependency).
Se um contêiner não atender a uma restrição de dependência ou expirar antes de cumprir a restrição, o Amazon ECS não evoluirá contêineres dependentes para seu próximo estado.
Este parâmetro exige que a tarefa ou o serviço usem a plataforma versão `1.3.0` ou posterior (Linux), ou `1.0.0` (Windows).
```
"dependsOn": [
{
"containerName": "string",
"condition": "string"
}
]
```
`containerName`
Tipo: String
Exigido: sim
O nome do contêiner que deve atender à condição especificada.
`condition`
Tipo: String
Exigido: sim
A condição de dependência do contêiner. A seguir estão as condições disponíveis e seus comportamentos.
+ `START`: essa condição emula o comportamento de links e volumes atuais. A condição valida que um contêiner dependente seja iniciado antes de permitir que outros contêineres sejam iniciados.
+ `COMPLETE`: essa condição valida que um contêiner dependente seja executado até a conclusão (encerramento) antes de permitir que outros contêineres sejam iniciados. Isso pode ser útil para os contêineres não essenciais que executam um script e depois são encerrados. Não é possível definir essa condição em um contêiner essencial.
+ `SUCCESS`: essa condição é igual a `COMPLETE`, mas também exige que o contêiner seja encerrado com um status `zero`. Não é possível definir essa condição em um contêiner essencial.
+ `HEALTHY`: essa condição valida que o contêiner dependente foi aprovado na verificação de integridade do Docker antes de permitir que outros contêineres sejam iniciados. Isso requer que o contêiner dependente tenha verificações de integridade configuradas na definição de tarefa. Essa condição é confirmada apenas no startup da tarefa.
#### Tempos limite de contêiner
`startTimeout`
Tipo: inteiro
Obrigatório: não
Valores de exemplo: `120`
Tempo a ser aguardado (em segundos) antes de desistir de resolver dependências para um contêiner.
Por exemplo, você especifica dois contêineres em uma definição de tarefa com o `containerA` tendo uma dependência do `containerB` atingir um status `COMPLETE`, `SUCCESS` ou `HEALTHY`. Se um valor de `startTimeout` for especificado para o `containerB` e ele não atingir o status desejado nesse tempo, o `containerA` não será iniciado.
Se um contêiner não atender a uma restrição de dependência ou expirar antes de cumprir a restrição, o Amazon ECS não evoluirá contêineres dependentes para seu próximo estado.
Este parâmetro exige que a tarefa ou o serviço usem a plataforma versão `1.3.0` ou posterior (Linux). O valor máximo é 120 segundos.
`stopTimeout`
Tipo: inteiro
Obrigatório: não
Valores de exemplo: `120`
Período (em segundos) a ser aguardado antes de o contêiner ser eliminado de maneira forçada se não for encerrado normalmente por conta própria.
Este parâmetro exige que a tarefa ou o serviço usem a plataforma versão `1.3.0` ou posterior (Linux). Se o parâmetro não for especificado, então o valor padrão de 30 segundos será usado. O valor máximo é 120 segundos.
#### Controles do sistema
`systemControls`
Tipo: objeto [SystemControl](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_SystemControl.html)
Obrigatório: não
Uma lista de parâmetros de kernel com namespace a ser definida no contêiner. Esse parâmetro é mapeado para `Sysctls` no comando create-container do docker e na opção `--sysctl` de execução do docker. Por exemplo, é possível definir a configuração `net.ipv4.tcp_keepalive_time` para manter conexões de longa duração.
Não recomendamos que você especifique parâmetros `systemControls` relacionados à rede para vários contêineres em uma única tarefa que também use o modo de rede `awsvpc` ou `host`. Fazer isso apresenta as desvantagens a seguir:
+ Se você definir `systemControls` para algum contêiner, isso se aplicará a todos os contêineres na tarefa. Se você definir um `systemControls` diferente para vários contêineres em uma única tarefa, o contêiner iniciado por último determinará qual `systemControls` entra em vigor.
Se você estiver configurando um namespace de recurso IPC para usar nos contêineres da tarefa, as condições a seguir serão aplicadas aos controles do sistema. Para obter mais informações, consulte [Modo IPC](#task_definition_ipcmode).
+ Para tarefas que usam o modo IPC `host`, o namespace IPC `systemControls` não é compatível.
+ Para tarefas que usam o modo IPC de `task`, os valores de `systemControls` do namespace IPC serão aplicados a todos os contêineres em uma tarefa.
Este parâmetro não é compatível com contêineres do Windows.
Só há suporte para o parâmetro para tarefas hospedadas no AWS Fargate que usem a versão da plataforma `1.4.0` ou posterior (Linux). Não há suporte para isso nos contêineres do Windows no Fargate.
```
"systemControls": [
{
"namespace":"string",
"value":"string"
}
]
```
`namespace`
Tipo: string
Obrigatório: não
O parâmetro de kernel com namespace para o qual definir um `value`.
Valores de namespace IPC válidos: `"kernel.msgmax" | "kernel.msgmnb" | "kernel.msgmni" | "kernel.sem" | "kernel.shmall" | "kernel.shmmax" | "kernel.shmmni" | "kernel.shm_rmid_forced"` e `Sysctls`, que comecem com `"fs.mqueue.*"`
Valores de namespace de rede válidos: `Sysctls`, que comece com `"net.*"`. No Fargate, apenas os `Sysctls` com namespace existentes dentro do contêiner são aceitos.
Há suporte para todos esses valores no Fargate.
`value`
Tipo: string
Obrigatório: não
O valor do parâmetro de kernel com namespace especificado em `namespace`.
#### Interativo
`interactive`
Tipo: booliano
Obrigatório: não
Quando esse parâmetro é `true`, você pode implantar aplicações em contêineres que exigem a alocação de `stdin` ou `tty`. Esse parâmetro é mapeado para `OpenStdin` no comando create-container do docker na opção `--interactive` de execução do docker.
O padrão é `false`.
#### Pseudoterminal
`pseudoTerminal`
Tipo: booliano
Obrigatório: não
Quando esse parâmetro é `true`, um TTY é alocado. Esse parâmetro é mapeado para `Tty` no comando create-container do docker na opção `--tty` de execução do docker.
O padrão é `false`.
## Nome do acelerador do Elastic Inference (obsoleto)
Requisito do recurso acelerador Elastic Inference para a definição de tarefa.
**nota**
O Amazon Elastic Inference (EI) não está mais disponível para clientes.
Os seguintes parâmetros são permitidos em uma definição de tarefa:
`deviceName`
Tipo: String
Exigido: sim
O nome do dispositivo do acelerador de inferência elástica. O `deviceName` também deve ser referenciado em uma definição de contêiner, consulte [Elastic Inference accelerator](#ContainerDefinition-elastic-inference).
`deviceType`
Tipo: String
Exigido: sim
O acelerador de inferência elástica a ser usado.
## Configuração do proxy
`proxyConfiguration`
Tipo: objeto [ProxyConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ProxyConfiguration.html)
Obrigatório: não
Os detalhes de configuração do proxy do App Mesh.
Este parâmetro não é compatível com contêineres do Windows.
```
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "string",
"properties": [
{
"name": "string",
"value": "string"
}
]
}
```
`type`
Tipo: string
Valor: `APPMESH`
Obrigatório: não
O tipo de proxy. O único valor aceito é `APPMESH`.
`containerName`
Tipo: String
Exigido: sim
O nome do contêiner que serve como proxy do App Mesh.
`properties`
Tipo: matriz de objetos [KeyValuePair](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KeyValuePair.html)
Obrigatório: não
O conjunto de parâmetros de configuração de rede para fornecer o plugin Container Network Interface (CNI), especificado como pares de chave/valor.
+ `IgnoredUID`: (obrigatório) o ID de usuário (UID) do contêiner de proxy conforme definido pelo parâmetro `user` em uma definição de contêiner. Isso é usado para garantir que o proxy ignore seu próprio tráfego. Se `IgnoredGID` for especificado, esse campo poderá estar vazio.
+ `IgnoredGID`: (obrigatório) o ID de grupo (GID) do contêiner de proxy conforme definido pelo parâmetro `user` em uma definição de contêiner. Isso é usado para garantir que o proxy ignore seu próprio tráfego. Se `IgnoredUID` for especificado, esse campo poderá estar vazio.
+ `AppPorts`: (obrigatório) a lista de portas usadas pelo aplicativo. O tráfego de rede para essas portas é encaminhado para `ProxyIngressPort` e `ProxyEgressPort`.
+ `ProxyIngressPort`: (obrigatório) especifica a porta para a qual o tráfego de entrada para `AppPorts` é direcionado.
+ `ProxyEgressPort`: (obrigatório) especifica a porta para a qual o tráfego de saída de `AppPorts` é direcionado.
+ `EgressIgnoredPorts`: (obrigatório) o tráfego de saída para essas portas especificadas é ignorado e não é redirecionado para `ProxyEgressPort`. Ele pode ser uma lista vazia.
+ `EgressIgnoredIPs`: (obrigatório) o tráfego de saída para esses endereços IP especificados é ignorado e não é redirecionado para `ProxyEgressPort`. Ele pode ser uma lista vazia.
`name`
Tipo: string
Obrigatório: não
O nome do par de chave/valor.
`value`
Tipo: string
Obrigatório: não
O valor do par de chave/valor.
## Volumes
Se preferir, ao registrar uma definição de tarefa, é possível especificar uma lista de volumes a serem passados para o daemon do Docker em uma instância de contêiner, que se tornará disponível para o acesso de outros contêineres da mesma instância de contêiner.
A seguir estão os tipos de volumes de dados que podem ser usados.
+ Volumes do Amazon EBS: fornece armazenamento em blocos econômico, durável e de alto desempenho para workloads em contêineres com uso intenso de dados. Você pode anexar um volume do Amazon EBS por tarefa do Amazon ECS ao executar uma tarefa autônoma ou ao criar ou atualizar um serviço. Os volumes do Amazon EBS são compatíveis com as tarefas do Linux hospedadas no Fargate. Para obter mais informações, consulte [Uso de volumes do Amazon EBS com o Amazon ECS](ebs-volumes.md).
+ Volumes do Amazon EFS: oferece armazenamento de arquivos simples, escalável e persistente para uso com tarefas do Amazon ECS. Com o Amazon EFS, a capacidade de armazenamento é elástica. Ela aumenta e diminui automaticamente à medida que arquivos são adicionados e removidos. As aplicações podem ter o armazenamento de que precisam, quando precisam. Os volumes do Amazon EFS são compatíveis com as tarefas hospedadas no Fargate. Para obter mais informações, consulte [Uso de volumes do Amazon EFS com o Amazon ECS](efs-volumes.md).
+ Volumes do FSx para Windows File Server: fornece servidores de arquivos Microsoft Windows totalmente gerenciados. Esses servidores têm o suporte de um sistema de arquivos do Windows. Ao usar o FSx for Windows File Server junto com o Amazon ECS, você pode provisionar tarefas do Windows com armazenamento de arquivos persistente, distribuído, compartilhado e estático. Para obter mais informações, consulte [Uso de volumes do FSx para Windows File Server com Amazon ECS](wfsx-volumes.md).
Não há suporte para essa opção nos contêineres do Windows no Fargate.
+ Montagens vinculadas: um arquivo ou diretório do computador host é montado em um contêiner. Volumes de host de montagem vinculada são compatíveis ao executar tarefas. Para usar os volumes de host de montagens bind, especifique um `host` e um valor `sourcePath` opcional em sua definição de tarefa.
Para obter mais informações, consulte [Opções de armazenamento para tarefas do Amazon ECS](using_data_volumes.md).
Os parâmetros a seguir são permitidos em uma definição de contêiner.
`name`
Tipo: string
Obrigatório: não
O nome do volume. São permitidos até 255 letras (caixa alta e baixa), números, hífens (`-`) e sublinhados (`_`). Esse nome é referenciado no parâmetro `sourceVolume` do objeto `mountPoints` de definição do contêiner.
`host`
Obrigatório: não
O parâmetro `host` é usado para vincular o ciclo de vida da montagem bind à instância host do Amazon EC2, em vez da tarefa, e onde ela está armazenada. Caso o parâmetro `host` esteja vazio, o daemon do Docker atribui um caminho host para o volume de dados, mas os dados não têm garantia de persistir depois que os contêineres associados deixarem de ser executados.
Os contêineres do Windows podem montar diretórios inteiros na mesma unidade como `$env:ProgramData`.
O parâmetro `sourcePath` é compatível apenas quando se utilizam tarefas hospedadas em instâncias do Amazon EC2 ou em instâncias gerenciadas do Amazon ECS.
`sourcePath`
Tipo: string
Obrigatório: não
Quando o parâmetro `host` é usado, especifique um `sourcePath` para declarar o caminho na instância host do Amazon EC2 que é apresentada ao contêiner. Caso esse parâmetro esteja vazio, o daemon do Docker atribui um caminho host para você. Caso o parâmetro `host` contenha um local de arquivo `sourcePath`, o volume de dados persistirá no local especificado na instância host do Amazon EC2 até você excluí-lo manualmente. Caso o valor `sourcePath` não exista na instância host do Amazon EC2, o daemon do Docker o criará. Caso o local exista, o conteúdo da pasta do caminho de origem é exportado.
`configuredAtLaunch`
Tipo: booliano
Obrigatório: não
Especifica se um volume é configurável na execução. Quando definido como `true`, você pode configurar o volume ao executar uma tarefa autônoma ou ao criar ou atualizar um serviço. Quando definido como `true`, não será possível fornecer outra configuração de volume na definição da tarefa. Esse parâmetro deve ser definido como `true` para configurar um volume do Amazon EBS para anexação a uma tarefa. Definir `configuredAtLaunch` como `true` e adiar a configuração do volume para a fase de execução permite criar definições de tarefas que não estão restritas a um tipo de volume ou a configurações de volume específicas. Isso torna a definição de tarefa reutilizável em diferentes ambientes de execução. Para obter mais informações, consulte [Volumes do Amazon EBS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ebs-volumes.html).
`dockerVolumeConfiguration`
Tipo: objeto [DockerVolumeConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DockerVolumeConfiguration.html)
Obrigatório: não
Esse parâmetro é especificado ao usar volumes do Docker. Os volumes do Docker só são compatíveis ao executar tarefas em instâncias do EC2. Os contêineres do Windows só são compatíveis com o uso do driver `local`. Para usar montagens bind, em vez disso, especifique um `host`.
`scope`
Tipo: string
Valores válidos: `task` \$1 `shared`
Obrigatório: não
O escopo para o volume do Docker, que determina o ciclo de vida. Os volumes do Docker que são delimitados para uma `task` são provisionados automaticamente quando a tarefa é iniciada e destruídos quando a tarefa é interrompida. Volumes do Docker delimitados como `shared` são mantidos após a interrupção da tarefa.
`autoprovision`
Tipo: booliano
Valor padrão: `false`
Obrigatório: não
Se o valor for `true`, o volume de Docker será criado se ele ainda não existir. Esse campo só será usado se `scope` for `shared`. Se `scope` for `task`, esse parâmetro deverá ser omitido.
`driver`
Tipo: string
Obrigatório: não
O driver do volume do Docker a ser usado. O valor do driver deve corresponder ao nome do driver fornecido pelo Docker porque esse nome é usado no posicionamento de tarefas. Se o driver foi instalado usando a CLI de plug-in do Docker, use `docker plugin ls` para recuperar o nome do driver na instância de contêiner. Se o driver foi instalado usando outro método, use a descoberta de plug-in do Docker para recuperar o nome do driver.
`driverOpts`
Tipo: string
Obrigatório: não
Um mapa de opções específicas do driver do Docker pelas quais passar. Esse parâmetro é mapeado para `DriverOpts` na seção Criar um volume da API remota do Docker.
`labels`
Tipo: string
Obrigatório: não
Metadados personalizados para adicionar ao volume do Docker.
`efsVolumeConfiguration`
Tipo: objeto [EFSVolumeConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_EFSVolumeConfiguration.html)
Obrigatório: não
Esse parâmetro é especificado quando volumes Amazon EFS são usados.
`fileSystemId`
Tipo: String
Exigido: sim
A ID do sistema de arquivamento Amazon EFS a ser usada.
`rootDirectory`
Tipo: string
Obrigatório: Não
O diretório dentro do sistema de arquivamento Amazon EFS a ser montado como diretório raiz dentro do host. Se esse parâmetro for omitido, a raiz do volume do Amazon EFS será usada. Especificar `/` tem o mesmo efeito que omitir esse parâmetro.
Se um ponto de acesso do EFS for especificado em `authorizationConfig`, o parâmetro de diretório raiz deverá ser omitido ou definido como `/`, o que imporá o caminho definido no ponto de acesso do EFS.
`transitEncryption`
Tipo: string
Valores válidos: `ENABLED` \$1 `DISABLED`
Obrigatório: não
Especifica se a criptografia deve ou não ser habilitada para dados do Amazon EFS em trânsito entre o host do Amazon ECS e o servidor do Amazon EFS. A criptografia de trânsito deverá ser habilitada se a autorização do IAM do Amazon EFS for usada. Se o parâmetro for omitido, o valor padrão `DISABLED` será usado. Para obter mais informações, consulte [Criptografar dados em trânsito](https://docs.aws.amazon.com/efs/latest/ug/encryption-in-transit.html) no *Guia do usuário do Amazon Elastic File System*.
`transitEncryptionPort`
Tipo: inteiro
Obrigatório: não
A porta a ser usada ao enviar dados criptografados entre o host do Amazon ECS e o servidor do Amazon EFS. Caso não especifique uma porta de criptografia em trânsito, a tarefa usará a estratégia de seleção de porta usada pelo assistente de montagem do Amazon EFS. Para mais informações, consulte [Auxiliar de Montagem EFS](https://docs.aws.amazon.com/efs/latest/ug/efs-mount-helper.html) no *Guia de Usuário Amazon Elastic File System*.
`authorizationConfig`
Tipo: objeto [EFSAuthorizationConfig](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_EFSAuthorizationConfig.html)
Obrigatório: não
Detalhes de configuração de autorização do sistema de arquivamento Amazon EFS.
`accessPointId`
Tipo: Sequência
Obrigatório: não
ID do ponto de acesso a ser usado. Se um ponto de acesso for especificado, o valor do diretório raiz em `efsVolumeConfiguration` deve ser omitido ou definido como `/`, o que imporá o caminho definido no ponto de acesso do EFS. Se um ponto de acesso for usado, a criptografia em trânsito deverá ser habilitada em `EFSVolumeConfiguration`. Para mais informações, consulte [Trabalhando com Pontos de Acesso Amazon EFS](https://docs.aws.amazon.com/efs/latest/ug/efs-access-points.html) no *Guia de Usuário Amazon Elastic File System*.
`iam`
Tipo: string
Valores válidos: `ENABLED` \$1 `DISABLED`
Obrigatório: não
Especifica se é necessário ou não usar o perfil do IAM para a tarefa do Amazon ECS estabelecida em uma definição de tarefa ao montar o sistema de arquivos do Amazon EFS. Em caso positivo, a criptografia de trânsito deve estar habilitada em `EFSVolumeConfiguration`. Se o parâmetro for omitido, o valor padrão `DISABLED` será usado. Para obter mais informações, consulte [Funções do IAM para tarefas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html).
`FSxWindowsFileServerVolumeConfiguration`
Tipo: objeto [FSxWindowsFileServerVolumeConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_FSxWindowsFileServerVolumeConfiguration.html)
Obrigatório: Sim
Esse parâmetro é especificado quando você está usando um sistema de arquivos do [Amazon FSx para Windows File Server](https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html) para armazenamento de tarefas.
`fileSystemId`
Tipo: String
Exigido: sim
O ID do sistema de arquivos do FSx for Windows File Server a ser usado.
`rootDirectory`
Tipo: String
Exigido: sim
O diretório no sistema de arquivos do FSx for Windows File Server que deve ser montado como o diretório raiz dentro do host.
`authorizationConfig`
`credentialsParameter`
Tipo: String
Exigido: sim
As opções de credencial de autorização.
**opções:**
+ O nome do recurso da Amazon (ARN) do segredo do [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html).
+ ARN de um parâmetro do [AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html).
`domain`
Tipo: String
Exigido: sim
Um nome de domínio totalmente qualificado hospedado por um diretório do [AWS Directory Service for Microsoft Active Directory](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html) (AWS Managed Microsoft AD) ou por um Active Directory do EC2 auto-hospedado.
## Tags
Quando você registra uma definição de tarefa, pode especificar opcionalmente etiquetas de metadados aplicadas à definição de tarefa. As etiquetas ajudam você a categorizar e organizar sua definição de tarefa. Cada tag consiste em uma chave e um valor opcional. Defina ambos. Para obter mais informações, consulte [Marcação de recursos do Amazon ECS](ecs-using-tags.md).
**Importante**
Não adicione informações de identificação pessoal nem outras informações confidenciais ou sigilosas em tags. As tags são acessíveis a muitos serviços da AWS, incluindo faturamento. As tags não devem ser usadas para dados privados ou confidenciais.
Os parâmetros a seguir são permitidos em um objeto de etiqueta.
`key`
Tipo: string
Obrigatório: não
Uma parte de um par de chave/valor que compõe uma tag. Uma chave é um rótulo geral que age como uma categoria para valores de tag mais específicos.
`value`
Tipo: string
Obrigatório: não
A parte opcional de um par de chave/valor que compõe uma tag. Um valor atua como um descritor dentro de uma categoria de tag (chave).
## Outros parâmetros de definição de tarefa
Os parâmetros de definição de tarefa a seguir podem ser usados durante o registro das definições de tarefa no console do Amazon ECS usando a opção **Configure via JSON** (Configurar via JSON). Para obter mais informações, consulte [Criar uma definição de tarefa do Amazon ECS usando o console](create-task-definition.md).
**Topics**
+ [
### Armazenamento temporário
](#task_definition_ephemeralStorage)
+ [
### Modo IPC
](#task_definition_ipcmode)
+ [
### Modo PID
](#task_definition_pidmode)
+ [
### Injeção de falhas
](#task_definition_faultInjection)
### Armazenamento temporário
`ephemeralStorage`
Tipo: objeto [EphemeralStorage](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_EphemeralStorage.html)
Obrigatório: não
A quantidade de armazenamento temporário (em GB) a ser alocado para a tarefa. Esse parâmetro é usado para expandir a quantidade total de armazenamento temporário, além da quantidade padrão, para tarefas hospedadas no AWS Fargate. Para obter mais informações, consulte [Uso de montagens vinculadas com o Amazon ECS](bind-mounts.md).
Este parâmetro é compatível apenas com a plataforma versão `1.4.0` ou posterior (Linux), ou `1.0.0` ou posterior (Windows).
### Modo IPC
`ipcMode`
Esse parâmetro não é compatível com tarefas sendo executadas no Fargate.
Tipo: string
Obrigatório: não
O namespace de recurso IPC a ser usado para os contêineres na tarefa. Os valores válidos são `host`, `task` ou `none`. Se o `host` for especificado, todos os contêineres dentro das tarefas que especificaram o modo IPC `host` na mesma instância de contêiner compartilham os mesmos recursos IPC com a instância do Amazon EC2 do host. Se `task` for especificado, todos os contêineres dentro da tarefa especificada compartilharão os mesmos recursos IPC. Se `none` for especificado, os recursos IPC nos contêineres de uma tarefa serão privados e não serão compartilhados com outros contêineres em uma tarefa ou na instância de contêiner. Se nenhum valor for especificado, o compartilhamento do namespace de recurso IPC dependerá da configuração do daemon do Docker na instância de contêiner.
Se o modo IPC `host` for usado, haverá um risco elevado de exposição indesejada do namespace IPC.
Se você estiver definindo parâmetros de kernel com namespace que usa `systemControls` para os contêineres na tarefa, os itens a seguir serão aplicados ao seu namespace de recurso IPC.
+ Para tarefas que usam o modo IPC `host`, o namespace IPC relacionado `systemControls` não é compatível.
+ Para tarefas que usam o modo IPC `task`, `systemControls` relacionados ao namespace IPC serão aplicados a todos os contêineres em uma tarefa.
**nota**
Esse parâmetro não é compatível com os contêineres do Windows ou tarefas que usam o tipo de inicialização Fargate.
### Modo PID
`pidMode`
Tipo: string
Valores válidos: `host` \$1 `task`
Obrigatório: não
O namespace do processo a ser usado para os contêineres na tarefa. Os valores válidos são `host` ou `task`. Em contêineres do Linux, o único valor válido é `task`. Por exemplo, o monitoramento de arquivos associados pode precisar que `pidMode` acesse informações sobre outros contêineres em execução na mesma tarefa.
Se a `task` for especificada, todos os contêineres da tarefa especificada compartilharão o mesmo namespace de processo.
Se nenhum valor for especificado, o padrão será um namespace privado para cada contêiner.
**nota**
Só há suporte para o parâmetro para tarefas hospedadas no AWS Fargate que usem a versão da plataforma `1.4.0` ou posterior (Linux). Não há suporte para isso nos contêineres do Windows no Fargate.
### Injeção de falhas
`enableFaultInjection`
Tipo: booliano
Valores válidos: `true` \$1 `false`
Obrigatório: não
Se esse parâmetro estiver definido como `true`, na carga útil de uma tarefa, o Amazon ECS e o Fargate aceitam solicitações de injeção de falhas dos contêineres da tarefa. Esse parâmetro é definido como por padrão `false`.