# Gerenciamento de instâncias de contêiner do Linux no Amazon ECS
Ao usar as instâncias do EC2 para workloads do Amazon ECS, você é responsável pela manutenção das instâncias
**Topics**
+ [Iniciar uma instância de contêiner](launch_container_instance.md)
+ [Inicialização de instâncias de contêiner do Linux](bootstrap_container_instance.md)
+ [Configuração de instâncias de contêiner para receber avisos de instância spot](spot-instance-draining-linux-container.md)
+ [Execução de um script ao iniciar uma instância de contêiner](start_task_at_launch.md)
+ [Aumento das interfaces de rede de instâncias de contêiner do Linux no Amazon ECS](container-instance-eni.md)
+ [Reserva de memória da instância de contêiner](memory-management.md)
+ [Gerenciar remotamente instâncias de contêiner](ec2-run-command.md)
+ [Uso de um proxy HTTP para instâncias de contêiner do Linux](http_proxy_config.md)
+ [Configuração de instâncias inicializadas previamente para o grupo do Auto Scaling](using-warm-pool.md)
+ [Atualizar o agente de contêiner do Amazon ECS](ecs-agent-update.md)
Cada agente de contêiner do Amazon ECS oferece suporte a um conjunto diferente de recursos e fornece correções de erros de versões anteriores. Quando possível, sempre recomendamos usar a versão mais recente do agente de contêiner do Amazon ECS. Para atualizar o agente de contêiner para a versão mais recente, consulte [Atualizar o agente de contêiner do Amazon ECS](ecs-agent-update.md).
Para ver quais recursos e aprimoramentos estão incluídos em cada versão de agente, consulte [https://github.com/aws/amazon-ecs-agent/releases](https://github.com/aws/amazon-ecs-agent/releases).
**Importante**
A versão mínima do Docker para métricas confiáveis é a versão Docker `v20.10.13` e posteriores, que está incluída na AMI otimizada para o Amazon ECS `20220607` e posteriores.
As versões `1.20.0` e posteriores do agente do Amazon ECS descontinuaram o suporte para as versões do Docker anteriores à `18.01.0`.
# Iniciar uma instância de contêiner do Linux do Amazon ECS
É possível criar instâncias de contêiner do Amazon ECS usando o console do Amazon EC2.
É possível iniciar uma instância usando vários métodos, incluindo o console do Amazon EC2, a AWS CLI e o SDK. Para obter informações sobre outros métodos de inicialização de uma instância, consulte [Iniciar uma instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/LaunchingAndUsingInstances.html) no *Manual do usuário do Amazon EC2*.
Para obter mais informações sobre o assistente de inicialização, consulte [Iniciar uma instância usando o novo assistente de inicialização de instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance-wizard.html) no *Manual do usuário do Amazon EC2*.
Antes de começar, conclua as etapas em [Configuração para usar o Amazon ECS](get-set-up-for-amazon-ecs.md).
É possível usar o assistente do Amazon EC2 para iniciar uma instância. O assistente de lançamento de instâncias especifica todos os parâmetros de início necessários para iniciar uma instância.
**Topics**
+ [Procedimento](#linux-liw-initiate-instance-launch)
+ [Nome e tags](#linux-liw-name-and-tags)
+ [Imagens de aplicações e sistemas operacionais (imagem de máquina da Amazon)](#linux-liw-ami)
+ [Tipo de instância](#linux-liw-instance-type)
+ [Par de chaves (login)](#linux-liw-key-pair)
+ [Configurações de rede](#linux-liw-network-settings)
+ [Configurar armazenamento](#linux-liw-storage)
+ [Detalhes avançados](#linux-liw-advanced-details)
## Procedimento
Antes de começar, conclua as etapas em [Configuração para usar o Amazon ECS](get-set-up-for-amazon-ecs.md).
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Na barra de navegação na parte superior da tela, a região atual AWS é exibida [por exemplo, Leste dos EUA (Ohio)]. Selecione uma região na qual a instância será iniciada.
1. No painel do console do Amazon EC2, selecione **Launch instance (Executar instância)**.
## Nome e tags
O nome da instância é uma tag em que a chave é **Name** (Nome) e o valor é o nome que você especificar. É possível aplicar tags na instância, sos volumes e nos elementos gráficos elásticos. Para instâncias spot, é possível marcar apenas a solicitação de instância spot.
A especificação de um nome de instância e de tags adicionais é opcional.
+ Em **Name** (Nome), insira um nome descritivo para a instância. Se você não especificar um nome, a instância poderá ser identificada por seu ID, que é gerado automaticamente quando você inicia a instância.
+ Para adicionar mais tags, selecione **Add additional tag** (Adicionar outra tag). Escolha **Add tag** (Adicionar tag), insira uma chave e um valor, e selecione o tipo de recurso a aplicar a tag. Escolha **Add tag** (Adicionar tag) para cada tag adicional a acrescentar.
## Imagens de aplicações e sistemas operacionais (imagem de máquina da Amazon)
Uma imagem de máquina da Amazon (AMI) contém as informações necessárias para criar uma instância. Por exemplo, uma AMI pode conter o software necessário para atuar como servidor Web, por exemplo, Apache e seu site.
Use a barra **Search** (Pesquisa) para encontrar uma AMI otimizada para o Amazon ECS publicada pela AWS.
1. Insira um dos seguintes termos na barra **Search** (Pesquisa).
+ **ami-ecs**
+ O **Value** (Valor) de uma AMI otimizada para o Amazon ECS.
Para obter as mais recentes AMIs otimizadas para o Amazon ECS e seus valores, consulte [AMI do Linux otimizada para o Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux).
1. Pressione **Enter**.
1. Na página **Escolher uma imagem de máquina da Amazon AMI)**, selecione a guia **AMIs do AWS Marketplace**.
1. No painel esquerdo **Refine results** (Refinar os resultados), selecione **Amazon Web Services** como o **Publisher** (Editor).
1. Escolha **Select** (Selecionar) na linha da AMI que você deseja usar.
Como alternativa, escolha **Cancel** (Cancelar) (no canto superior direito) para retornar ao assistente de inicialização de instância sem escolher uma AMI. Uma AMI padrão será selecionada. Confirme se a AMI atende aos requisitos descritos nas [AMIs do Linux otimizadas para Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html).
## Tipo de instância
O tipo de instância define a configuração do hardware e o tamanho da instância. Os tipos de instâncias maiores têm mais CPU e memória. Para ter mais informações, consulte [Instance types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html), no *Guia do usuário do Amazon EC2*. Se você quiser executar uma workload somente IPv6, certos tipos de instância não oferecem suporte a endereços IPv6. Para obter mais informações, consulte [Endereços IPv6](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-instance-addressing.html#ipv6-addressing) no *Guia do usuário do Amazon EC2*.
+ Em **Instance type** (Tipo de instância), selecione o tipo de instância da instância.
O tipo de instância que você selecionar determinará os recursos disponíveis para execução de suas tarefas.
## Par de chaves (login)
Em **Key pair name** (Nome do par de chaves), escolha um par de chaves existente ou escolha **Create new key pair** (Criar um novo par de chaves) para criar um novo.
**Importante**
Se você escolher a opção **Proceed without key pair (Not recommended)** (Prosseguir sem par de chaves, não recomendado), não conseguirá se conectar à instância a menos que escolha uma AMI configurada para permitir que os usuários façam login de outro modo.
## Configurações de rede
Defina as configurações de rede conforme necessário depois de escolher o botão **Editar** na seção **Configurações de rede** do formulário.
+ Em **VPC** escolha a VPC na qual você deseja inicializar a instância. Para executar uma workload somente IPv6, escolha uma VPC de pilha dupla que inclua blocos CIDR IPv4 e IPv6.
+ Em **Sub-rede**, escolha a sub-rede na qual deseja inicializar a instância. É possível inicializar uma instância em uma sub-rede associada a uma zona de disponibilidade, a uma zona local, a uma zona Wavelength ou a um Outpost.
Para iniciar a instância em uma zona de disponibilidade, selecione a sub-rede na qual a instância será iniciada. Para criar uma nova sub-rede, escolha **Create new subnet (Criar nova sub-rede)** para acessar o console da Amazon VPC. Quando tiver concluído, retorne ao assistente de inicialização da instância e escolha o ícone Refresh (Atualizar) para carregar sua sub-rede na lista.
Para iniciar a instância em uma zona local, selecione uma sub-rede que você criou na zona local.
Para iniciar uma instância em um Outpost, selecione uma sub-rede em uma VPC associada ao Outpost.
Para executar uma workload somente IPv6, escolha uma sub-rede que inclua apenas um bloco CIDR IPv6.
+ **Auto-assign Public IP** (Atribuir IP público automaticamente): se sua instância tiver de ser acessada pela Internet pública, verifique se o campo **Auto-assign Public IP** (Atribuir IP público automaticamente) está definido como **Enable** (Habilitar). Em caso negativo, defina esse campo como **Disable** (Desabilitar).
**nota**
Instâncias de contêiner precisam de acesso para se comunicar com o endpoint do serviço do Amazon ECS. Isso pode ser feito por meio de uma interface do endpoint da VPC ou por meio dos recursos de computação das instâncias de contêiner que tenham endereços IP públicos.
Para saber mais sobre endpoints da VPC de interface, consulte [Endpoints da VPC de interface do Amazon ECS (AWS PrivateLink)](vpc-endpoints.md).
Se você não tiver um endpoint da VPC de interface configurado e suas instâncias de contêiner não tiverem endereços IP públicos, elas deverão usar a conversão de endereço de rede (NAT) para fornecer esse acesso. Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) no *Guia do usuário da Amazon VPC* e [Uso de um proxy HTTP para instâncias de contêiner do Linux no Amazon ECS](http_proxy_config.md) neste guia.
+ Se você escolher uma VPC dual-stack e uma sub-rede somente IPv6, em **Atribuir automaticamente IP IPv6**, escolha **Habilitar**.
+ **Firewall (security groups)** (Firewall, grupos de segurança): use um grupo de segurança para definir regras de firewall da sua instância de contêiner. Essas regras especificam qual tráfego de rede de entrada será fornecido para sua instância de contêiner. Todo o tráfego é ignorado.
+ Para selecionar um grupo de segurança existente, escolha **Select an existing security group** (Selecionar um grupo de segurança existente) e escolha o grupo de segurança criado em [Configuração para usar o Amazon ECS](get-set-up-for-amazon-ecs.md).
+ Se você estiver inicializando a instância para uma workload somente IPv6, escolha **Configuração de rede avançada** e, em **Atribuir IP IPv6 primário**, escolha **Sim**.
**nota**
Sem um endereço IPv6 primário, as tarefas executadas na instância de contêiner nos modos de rede host ou ponte não serão registradas nos balanceadores de carga ou no AWS Cloud Map.
## Configurar armazenamento
A AMI que você selecionou inclui um ou mais volumes de armazenamento, incluindo o volume raiz. É possível especificar volumes adicionais a serem anexados à instância.
É possível usar a exibição **Simple** (Simples).
+ **Storage type** (Tipo de armazenamento): configure o armazenamento para a sua instância de contêiner.
Se você estiver usando a AMI do Amazon Linux 2 otimizada para Amazon ECS, sua instância terá um único volume de 30 GiB configurado, que é compartilhado entre o sistema operacional e o Docker.
Se você estiver usando a AMI otimizada para Amazon ECS, a instância terá dois volumes configurados. O volume **Raiz** é para uso do sistema operacional e o segundo volume do Amazon EBS (anexado a `/dev/xvdcz`) é para uso do Docker.
Você também pode aumentar ou diminuir os tamanhos de volumes para a sua instância para atender às necessidades dos seus aplicativos.
## Detalhes avançados
Em **Advanced details (Detalhes avançados)**, expanda a seção para visualizar os campos e especifique quaisquer parâmetros adicionais para a instância.
+ **Purchasing option (Opção de compra)**: escolha **Request Spot instances** (Solicitar instâncias Spot) para solicitar instâncias Spot. Também é necessário definir os outros campos relacionados a instâncias spot. Para obter mais informações, consulte [Solicitações de instâncias spot](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/spot-requests.html).
**nota**
Se você estiver usando instâncias spot e vir uma mensagem `Not available`, pode ser necessário escolher um tipo de instância diferente.
+ **IAM instance profile** (Perfil de instância do IAM): selecione a função do IAM de instância de contêiner. Isso geralmente é chamado de `ecsInstanceRole`.
**Importante**
Se você não iniciar a instância de contêiner com as permissões apropriadas do IAM, o agente do Amazon ECS não poderá se conectar ao cluster. Para obter mais informações, consulte [Função do IAM de instância de contêiner do Amazon ECS](instance_IAM_role.md).
+ **Dados do usuário**: configure a instância de contêiner do Amazon ECS com os dados do usuário, como as variáveis de ambiente de agente de [Configuração do agente de contêiner do Amazon ECS](ecs-agent-config.md). Os scripts de dados do usuário do Amazon EC2 são executados apenas uma vez, quando a instância é iniciada pela primeira vez. Veja a seguir exemplos comuns de quais dados do usuário são usados.
+ Por padrão, sua instância de contêiner é executada em seu cluster padrão. Para executar em um cluster que não seja padrão, escolha a lista **Detalhes avançados**. Em seguida, cole o seguinte script no campo **Dados do usuário** substituindo *your\$1cluster\$1name* pelo nome do seu cluster.
```
#!/bin/bash
echo ECS_CLUSTER=your_cluster_name >> /etc/ecs/ecs.config
```
+ Se você tiver um arquivo `ecs.config` no Amazon S3 e tiver habilitado o acesso somente leitura do Amazon S3 à função de instância de contêiner, escolha a lista **Advanced Details** (Detalhes avançados). Em seguida, cole o seguinte script no campo **User data (Dados do usuário)** substituindo *your\$1bucket\$1name* pelo nome do seu bucket para instalar a AWS CLI e gravar seu arquivo de configuração no momento da inicialização.
**nota**
Para saber mais sobre essa configuração, consulte [Armazenamento da configuração da instância de contêiner do Amazon ECS no Amazon S3](ecs-config-s3.md).
```
#!/bin/bash
yum install -y aws-cli
aws s3 cp s3://your_bucket_name/ecs.config /etc/ecs/ecs.config
```
+ Especifique tags para sua instância de contêiner usando o parâmetro de configuração `ECS_CONTAINER_INSTANCE_TAGS`. Isso cria etiquetas associadas somente ao Amazon ECS, elas não podem ser listadas usando a API do Amazon EC2.
**Importante**
Se você iniciar as instâncias de contêiner usando um grupo do Amazon EC2 Auto Scaling, deverá usar o parâmetro de configuração do agente ECS\$1CONTAINER\$1INSTANCE\$1TAGS para adicionar etiquetas. Isso é decorrente da maneira como as etiquetas são adicionadas às instâncias do Amazon EC2 que são iniciadas por meio de grupos do Auto Scaling.
```
#!/bin/bash
cat <<'EOF' >> /etc/ecs/ecs.config
ECS_CLUSTER=your_cluster_name
ECS_CONTAINER_INSTANCE_TAGS={"tag_key": "tag_value"}
EOF
```
+ Especifique etiquetas para a instância de contêiner e use o parâmetro de configuração `ECS_CONTAINER_INSTANCE_PROPAGATE_TAGS_FROM` para propagá-las do Amazon EC2 para o Amazon ECS
Veja a seguir um exemplo de um script de dados do usuário que poderia propagar as tags associadas a uma instância de contêiner, bem como registrar a instância do contêiner com um cluster denominado `your_cluster_name`.
```
#!/bin/bash
cat <<'EOF' >> /etc/ecs/ecs.config
ECS_CLUSTER=your_cluster_name
ECS_CONTAINER_INSTANCE_PROPAGATE_TAGS_FROM=ec2_instance
EOF
```
+ Por padrão, o agente de contêiner do Amazon ECS tentará detectar a compatibilidade da instância de contêiner com uma configuração somente IPv6 examinando as rotas IPv4 e IPv6 padrão da instância. Para substituir esse comportamento, você pode definir o parâmetro ` ECS_INSTANCE_IP_COMPATIBILITY` como `ipv4` ou `ipv6` no arquivo `/etc/ecs/ecs.config` da instância.
```
#!/bin/bash
cat <<'EOF' >> /etc/ecs/ecs.config
ECS_CLUSTER=your_cluster_name
ECS_INSTANCE_IP_COMPATIBILITY=ipv6
EOF
```
Para obter mais informações, consulte [Inicialização de instâncias de contêiner do Linux no Amazon ECS para transmitir dados](bootstrap_container_instance.md).
# Inicialização de instâncias de contêiner do Linux no Amazon ECS para transmitir dados
Ao iniciar uma instância do Amazon EC2, é possível transmitir dados do usuário para a instância do EC2. Os dados podem ser usados para realizar tarefas de configuração automatizadas em comum e até mesmo executar scripts na inicialização da instância. Para o Amazon ECS, os casos de uso mais comuns para dados de usuário devem transmitir informações de configuração para o daemon do Docker e o agente de contêiner do Amazon ECS.
É possível transmitir vários tipos de dados de usuário para o Amazon EC2, inclusive boothooks de nuvem, scripts de shell e diretivas `cloud-init`. Para obter mais informações sobre esses e outros tipos de formato, consulte a documentação [Cloud-Init](https://cloudinit.readthedocs.io/en/latest/explanation/format.html).
Para transmitir os dados do usuário ao usar o assistente de inicialização do Amazon EC2, consulte [Iniciar uma instância de contêiner do Linux do Amazon ECS](launch_container_instance.md).
É possível configurar a instância de contêiner para transmitir dados na configuração do agente de contêiner ou na configuração do daemon do Docker.
## Agente do contêiner do Amazon ECS
As variantes do Linux da AMI otimizada para Amazon ECS procuram os dados da configuração do agente no arquivo `/etc/ecs/ecs.config` quando o agente de contêiner é iniciado. É possível especificar esses dados de configuração na inicialização com os dados de usuário do Amazon EC2. Para obter mais informações sobre as variáveis de configuração do agente de contêiner do Amazon ECS disponíveis, consulte [Configuração do agente de contêiner do Amazon ECS](ecs-agent-config.md).
Para definir apenas uma única variável de configuração do agente, como o nome do cluster, use **echo** a fim de copiar a variável para o arquivo de configuração:
```
#!/bin/bash
echo "ECS_CLUSTER=MyCluster" >> /etc/ecs/ecs.config
```
Caso você tenha várias variáveis a serem gravadas em `/etc/ecs/ecs.config`, use o formato `heredoc` a seguir. Esse formato grava tudo entre as linhas que começam com **cat** e `EOF` no arquivo de configuração.
```
#!/bin/bash
cat <<'EOF' >> /etc/ecs/ecs.config
ECS_CLUSTER=MyCluster
ECS_ENGINE_AUTH_TYPE=docker
ECS_ENGINE_AUTH_DATA={"https://index.docker.io/v1/":{"username":"my_name","password":"my_password","email":"email@example.com"}}
ECS_LOGLEVEL=debug
ECS_WARM_POOLS_CHECK=true
EOF
```
Para definir atributos de instância personalizados, defina a variável de ambiente `ECS_INSTANCE_ATTRIBUTES`.
```
#!/bin/bash
cat <<'EOF' >> ecs.config
ECS_INSTANCE_ATTRIBUTES={"envtype":"prod"}
EOF
```
## Daemon do Docker
É possível especificar informações de configuração do daemon do Docker com os dados de usuário do Amazon EC2. Para mais informações sobre as opções de configuração, consulte [a documentação de daemon do Docker](https://docs.docker.com/reference/cli/dockerd/).
**nota**
A AWS não oferece suporte a configurações personalizadas do Docker, pois ocasionalmente elas podem entrar em conflito com futuras alterações ou recursos do Amazon ECS sem aviso prévio.
No exemplo abaixo, as opções personalizadas são adicionadas ao arquivo de configuração do daemon do Docker, `/etc/docker/daemon.json`, que é então especificado nos dados de usuário quando a instância é iniciada.
```
#!/bin/bash
cat </etc/docker/daemon.json
{"debug": true}
EOF
systemctl restart docker --no-block
```
No exemplo abaixo, as opções personalizadas são adicionadas ao arquivo de configuração do daemon do Docker, `/etc/docker/daemon.json`, que é então especificado nos dados de usuário quando a instância é iniciada. Este exemplo mostra como desabilitar o docker-proxy no arquivo de configuração do daemon do Docker.
```
#!/bin/bash
cat </etc/docker/daemon.json
{"userland-proxy": false}
EOF
systemctl restart docker --no-block
```
# Configuração de instâncias de contêiner do Linux no Amazon ECS para receber avisos de instância spot
O Amazon EC2 encerra, interrompe ou coloca a instância spot em hibernação quando o preço spot excede o preço máximo da solicitação ou a capacidade não está mais disponível. O Amazon EC2 fornece um aviso de interrupção de dois minutos de instância spot para ações de terminar e interromper. Ele não fornece o aviso de dois minutos para a ação de hibernação. Se a drenagem da instância spot do Amazon ECS estiver ativada na instância, o Amazon ECS receberá o aviso de interrupção da instância spot e atribuirá a instância ao status `DRAINING`.
**Importante**
O Amazon ECS não recebe um aviso do Amazon EC2 quando as instâncias são removidas pelo rebalanceamento de capacidade do Auto Scaling. Para obter mais informações, consulte [Rebalanceamento de capacidade do Amazon EC2 Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-capacity-rebalancing.html).
Quando uma instância de contêiner é definida como `DRAINING`, o Amazon ECS impede que novas tarefas sejam programadas para posicionamento na instância de contêiner. As tarefas de serviço nas instâncias de contêiner de drenagem que estão com o status de `PENDING` são interrompidas imediatamente. Se houver instâncias de contêiner no cluster disponíveis, as tarefas de serviço de substituição serão iniciadas nelas.
Por padrão, a drenagem de instância spot está desativada.
É possível ativar a drenagem de instância spot ao iniciar uma instância. Adicione o script apresentado a seguir ao campo **Dados do usuário**. Substitua *MyCluster* pelo nome do cluster no qual deseja registrar a instância de contêiner.
```
#!/bin/bash
cat <<'EOF' >> /etc/ecs/ecs.config
ECS_CLUSTER=MyCluster
ECS_ENABLE_SPOT_INSTANCE_DRAINING=true
EOF
```
Para obter mais informações, consulte [Iniciar uma instância de contêiner do Linux do Amazon ECS](launch_container_instance.md).
**Para ativar a drenagem de instâncias spot para uma instância de contêiner existente**
1. Conecte-se à instância spot pelo SSH.
1. Edite o arquivo `/etc/ecs/ecs.config` e adicione o seguinte:
```
ECS_ENABLE_SPOT_INSTANCE_DRAINING=true
```
1. Reinicie o serviço `ecs`.
+ Para a AMI do Amazon Linux 2 otimizada para o Amazon ECS:
```
sudo systemctl restart ecs
```
1. (Opcional) É possível verificar se o agente está em execução e consultar algumas informações sobre sua nova instância de contêiner consultando a operação da API de introspecção do agente. Para obter mais informações, consulte [Introspecção de contêiner do Amazon ECS](ecs-agent-introspection.md).
```
curl http://localhost:51678/v1/metadata
```
# Execução de um script ao iniciar uma instância de contêiner do Linux no Amazon ECS
Talvez seja necessário executar um contêiner específico em cada instância de contêiner para lidar com operações ou questões de segurança, como monitoramento, segurança, métricas, descoberta de serviços ou registros em log.
Para fazer isso, você pode configurar suas instâncias de contêiner de forma que elas chamem o comando **docker run** com esse script de dados de usuário na execução ou em algum sistema init como Upstart ou **systemd**. Quando esse método funciona, existem algumas desvantagens, pois o Amazon ECS não tem qualquer conhecimento de contêiner e não pode monitorar a CPU, a memória, as portas ou quaisquer outros recursos utilizados. Para garantir que o Amazon ECS possa assumir adequadamente todos os recursos de tarefas, crie uma definição de tarefa para que o contêiner seja executado nas instâncias de contêiner. Em seguida, use o Amazon ECS para trazer a tarefa até o momento da inicialização com dados de usuário do Amazon EC2.
No procedimento a seguir, o script de dados de usuário do Amazon EC2 usa a API de introspecção do Amazon ECS para identificar a instância de contêiner. Em seguida, ele usa a AWS CLI e o comando **start-task** para executar uma tarefa específica nele durante o startup.
**Para iniciar uma tarefa no momento da execução da instância de contêiner**
1. Modifique a função do IAM `ecsInstanceRole` para adicionar permissões para a operação de API `StartTask`. Para obter mais informações, consulte [Atualizar permissões para um perfil](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_update-role-permissions.html) no *Guia do usuário do AWS Identity and Access Management*.
1. Inicie uma ou mais instâncias de contêiner usando a AMI do Amazon Linux 2 otimizada para o Amazon ECS. Inicie novas instâncias de contêiner e use o script de exemplo apresentado a seguir nos dados do usuário do EC2. Substitua *your\$1cluster\$1name* pelo cluster no qual a instância de contêiner será registrada e *my\$1task\$1def* pela definição de tarefa a ser executada na instância na inicialização.
Para obter mais informações, consulte [Iniciar uma instância de contêiner do Linux do Amazon ECS](launch_container_instance.md).
**nota**
O conteúdo MIME de várias partes abaixo usa um script de shell para definir valores de configuração e instalar os pacotes. Ele também usa um trabalho systemd para iniciar a tarefa depois que o serviço **ecs** estiver em execução e a API de introspecção ficar disponível.
```
Content-Type: multipart/mixed; boundary="==BOUNDARY=="
MIME-Version: 1.0
--==BOUNDARY==
Content-Type: text/x-shellscript; charset="us-ascii"
#!/bin/bash
# Specify the cluster that the container instance should register into
cluster=your_cluster_name
# Write the cluster configuration variable to the ecs.config file
# (add any other configuration variables here also)
echo ECS_CLUSTER=$cluster >> /etc/ecs/ecs.config
START_TASK_SCRIPT_FILE="/etc/ecs/ecs-start-task.sh"
cat <<- 'EOF' > ${START_TASK_SCRIPT_FILE}
exec 2>>/var/log/ecs/ecs-start-task.log
set -x
# Install prerequisite tools
yum install -y jq aws-cli
# Wait for the ECS service to be responsive
until curl -s http://localhost:51678/v1/metadata
do
sleep 1
done
# Grab the container instance ARN and AWS Region from instance metadata
instance_arn=$(curl -s http://localhost:51678/v1/metadata | jq -r '. | .ContainerInstanceArn' | awk -F/ '{print $NF}' )
cluster=$(curl -s http://localhost:51678/v1/metadata | jq -r '. | .Cluster' | awk -F/ '{print $NF}' )
region=$(curl -s http://localhost:51678/v1/metadata | jq -r '. | .ContainerInstanceArn' | awk -F: '{print $4}')
# Specify the task definition to run at launch
task_definition=my_task_def
# Run the AWS CLI start-task command to start your task on this container instance
aws ecs start-task --cluster $cluster --task-definition $task_definition --container-instances $instance_arn --started-by $instance_arn --region $region
EOF
# Write systemd unit file
UNIT="ecs-start-task.service"
cat <<- EOF > /etc/systemd/system/${UNIT}
[Unit]
Description=ECS Start Task
Requires=ecs.service
After=ecs.service
[Service]
Restart=on-failure
RestartSec=30
ExecStart=/usr/bin/bash ${START_TASK_SCRIPT_FILE}
[Install]
WantedBy=default.target
EOF
# Enable our ecs.service dependent service with `--no-block` to prevent systemd deadlock
# See https://github.com/aws/amazon-ecs-agent/issues/1707
systemctl enable --now --no-block "${UNIT}"
--==BOUNDARY==--
```
1. Verifique se as suas instâncias de contêiner são executadas no cluster correto e se as suas tarefas foram iniciadas.
1. Abra o console em [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).
1. Na barra de navegação, selecione a região em que seu cluster está localizado.
1. No painel de navegação, escolha **Clusters** e selecione o cluster que hospeda as suas instâncias de contêiner.
1. Na página **Cluster**, escolha **Tarefas** e, em seguida, escolha suas tarefas.
Cada instância de contêiner que você executou deve ter sua tarefa em execução nela.
Se você não vir suas tarefas, faça login em suas instâncias de contêiner com SSH e verifique o arquivo `/var/log/ecs/ecs-start-task.log` para obter informações de depuração.
# Aumento das interfaces de rede de instâncias de contêiner do Linux no Amazon ECS
**nota**
Esse recurso não está disponível no Fargate.
Cada tarefa que usa o modo de rede `awsvpc` recebe sua própria interface de rede elástica (ENI), que está conectada à instância de contêiner que a hospeda. Existe um limite padrão para o número de interfaces de rede que podem ser anexadas a uma instância do Amazon EC2, e a interface de rede primária conta como uma delas. Por exemplo, por padrão, uma instância `c5.large` pode ter até três ENIs associadas a ela. A interface de rede principal para a instância conta como uma, por isso você pode associar mais duas ENIs à instância. Como cada tarefa que usa o modo de rede `awsvpc` exige uma ENI, em geral, você pode executar somente duas dessas tarefas nesse tipo de instância.
O Amazon ECS oferece suporte à execução de instâncias de contêiner com maior densidade de ENI usando tipos de instâncias do Amazon EC2 compatíveis. Quando você usa esses tipos de instância e ativa a configuração da conta `awsvpcTrunking`, ENIs adicionais ficam disponíveis em instâncias de contêiner iniciadas recentemente. Essa configuração permite que você coloque mais tarefas em cada instância de contêiner. Para usar o console para ativar o recurso, consulte [Modificar configurações de conta do Amazon ECS](ecs-modifying-longer-id-settings.md). Para usar a AWS CLI para ativar o recurso, consulte [Gerenciar configurações de conta do Amazon ECS usando o AWS CLI](account-setting-management-cli.md).
Por exemplo, uma instância `c5.large` com `awsvpcTrunking` tem um limite de ENI aumentado para doze. A instância de contêiner terá a interface de rede prmária e o Amazon ECS cria e anexa uma interface de rede "tronco" à instância de contêiner. Portanto, essa configuração permite que você inicie 10 tarefas na instância de contêiner, em vez das duas tarefas atuais.
A interface de rede tronco é totalmente gerenciada pelo Amazon ECS e é excluída quando você encerra ou cancela o registro da instância de contêiner do cluster. Para obter mais informações, consulte [Opções da rede de tarefas do Amazon ECS para o EC2](task-networking.md).
## Considerações
Considere as informações apresentadas a seguir ao usar o recurso de entroncamento de ENI.
+ Somente variantes do Linux da AMI otimizada para o Amazon ECS ou outras variantes do Amazon Linux com a versão `1.28.1` ou posterior do agente de contêiner e a versão `1.28.1-2` ou posterior do pacote ecs-init oferecem suporte a limites maiores de ENI. Se você usar a variante do Linux mais recente da AMI otimizada para Amazon ECS, esses requisitos serão atendidos. Os contêineres do Windows não são suportados no momento.
+ Somente novas instâncias do Amazon EC2 executadas depois de habilitar `awsvpcTrunking` recebem o aumento de limites de ENI e a interface de rede de truncamento. Instâncias executadas anteriormente não recebem esses recursos, independentemente das ações executadas.
+ As instâncias do Amazon EC2 devem ter solicitações de DNS de IPv4 baseadas em recursos desativadas. Para desabilitar essa opção, desmarque a opção **Habilitar pedidos de DNS baseados em solicitações IPv4 (registo A)** ao criar uma nova instância no console do Amazon EC2. Para desabilitar essa opção usando o AWS CLI, use o comando a seguir.
```
aws ec2 modify-private-dns-name-options --instance-id i-xxxxxxx --no-enable-resource-name-dns-a-record --no-dry-run
```
+ As instâncias do Amazon EC2 em sub-redes compartilhadas não são compatíveis. Elas falharão ao registrar em um cluster se forem usadas.
+ Suas tarefas devem usar o modo de rede `awsvpc` e o EC2. As tarefas que usam o Fargate sempre recebem uma ENI dedicada, independentemente de quantas são inicializadas. Por isso, esse recurso não é necessário.
+ Suas tarefas devem ser inicializadas na mesma Amazon VPC que a instância de contêiner. Suas tarefas falharão ao iniciar com um erro de atributo se não estiverem na mesma VPC.
+ Ao executar uma nova instância de contêiner, a instância muda para o status `REGISTERING` enquanto a interface de rede elástica tronco é provisionada para a instância. Se ocorrer uma falha no registro, a instância mudará para o status `REGISTRATION_FAILED`. É possível solucionar problemas de um registro com falha descrevendo a instância de contêiner para visualizar o campo `statusReason`, que descreve o motivo da falha. Em seguida, o registro da instância de contêiner pode ser cancelado manualmente ou encerrado. Depois que o registro da instância de contêiner for cancelado ou encerrado com êxito, o Amazon ECS exclui a ENI de truncamento.
**nota**
O Amazon ECS emite eventos de alteração de estado de instância de contêiner que você pode monitorar para instâncias que fazem a transição para um estado `REGISTRATION_FAILED`. Para obter mais informações, consulte [Eventos de alteração no estado da instância de contêiner do Amazon ECS](ecs_container_instance_events.md).
+ Assim que a instância de contêiner é encerrada, ela muda para o status `DEREGISTERING` enquanto a interface de rede elástica tronco é desprovisionada. Depois, a instância muda para o status `INACTIVE`.
+ Se uma instância de contêiner em uma sub-rede pública com o aumento dos limites de ENI for encerrada e depois reiniciada, a instância perderá o endereço IP público e o agente de contêiner perderá a conexão.
+ Quando você habilita `awsvpcTrunking`, as instâncias de contêiner recebem uma ENI adicional que usa o grupo de segurança padrão da VPC e é gerenciada pelo Amazon ECS.
Uma VPC padrão vem com uma sub-rede pública em cada zona de disponibilidade, um gateway da Internet e configurações para habilitar a resolução de DNS. A sub-rede é pública, porque a tabela de rotas principal envia o tráfego da sub-rede destinado à internet para o gateway da internet. É possível transformar uma sub-rede padrão em uma sub-rede privada removendo a rota do destino 0.0.0.0/0 para o gateway da internet. Porém, se você fizer isso, nenhuma instância de container sendo executada nessa sub-rede poderá acessar a internet. Você pode adicionar ou excluir regras de grupo de segurança para controlar tráfego de entrada e saída das sub-redes. Para obter mais informações, consulte [Regras de grupo de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html) no *Manual do usuário da Amazon Virtual Private Cloud*.
## Pré-requisitos
Antes de executar uma instância de contêiner com limites de ENI maiores, os pré-requisitos a seguir devem ser atendidos.
+ A função vinculada ao serviço para Amazon ECS deve ser criada. A função vinculada ao serviço do Amazon ECS fornece ao Amazon ECS as permissões para fazer chamadas a outros serviços da AWS em seu nome. Essa função será automaticamente criada quando você criar um cluster ou se criar ou atualizar um serviço no Console de gerenciamento da AWS. Para obter mais informações, consulte [Uso de perfis vinculados ao serviço para o Amazon ECS](using-service-linked-roles.md). Também é possível criar a função vinculada ao serviço com o comando da AWS CLI a seguir.
```
aws iam [create-service-linked-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-service-linked-role.html) --aws-service-name ecs.amazonaws.com
```
+ Sua conta ou perfil do IAM da instância de contêiner deve habilitar a configuração de conta `awsvpcTrunking`. Recomendamos que você crie dois perfis de instância de contêiner (`ecsInstanceRole`). Em seguida, você pode habilitar a configuração da conta `awsvpcTrunking` para um perfil e usá-lo em tarefas que exigem truncamento de ENI. Para obter informações sobre o perfil da instância de contêiner, consulte [Função do IAM de instância de contêiner do Amazon ECS](instance_IAM_role.md).
Assim que os pré-requisitos forem atendidos, é possível executar uma nova instância de contêiner usando um dos tipos de instância do Amazon EC2 compatíveis, e a instância terá os limites de ENI maiores. Para obter uma lista dos tipos de instâncias compatíveis, consulte [Instâncias com suporte para o aumento de interfaces de rede de contêineres do Amazon ECS](eni-trunking-supported-instance-types.md). A instância de contêiner deve ter a versão `1.28.1` ou posterior do agente de contêiner e a versão `1.28.1-2` ou posterior do pacote ecs-init. Se você usar a variante do Linux mais recente da AMI otimizada para Amazon ECS, esses requisitos serão atendidos. Para obter mais informações, consulte [Iniciar uma instância de contêiner do Linux do Amazon ECS](launch_container_instance.md).
**Importante**
As instâncias do Amazon EC2 devem ter solicitações de DNS de IPv4 baseadas em recursos desativadas. Para desabilitar essa opção, certifique-se de que a opção **Enable resource-based IPV4 (A record) DNS requests** (Habilitar solicitações de DNS de IPV4 (registro A) baseadas em recursos) esteja desmarcada ao criar uma nova instância usando o console do Amazon EC2. Para desabilitar essa opção usando o AWS CLI, use o comando a seguir.
```
aws ec2 modify-private-dns-name-options --instance-id i-xxxxxxx --no-enable-resource-name-dns-a-record --no-dry-run
```
**Para visualizar as instâncias de contêiner com limites de ENI maiores com a AWS CLI**
Cada instância de contêiner tem uma interface de rede padrão, conhecida como interface de rede tronco. Use o comando a seguir para listar as instâncias de contêiner com limites maiores de ENI consultando o atributo `ecs.awsvpc-trunk-id`, que indica a existência de uma interface de rede de truncamento.
+ [list-attributes](https://docs.aws.amazon.com/cli/latest/reference/ecs/list-attributes.html) (AWS CLI)
```
aws ecs list-attributes \
--target-type container-instance \
--attribute-name ecs.awsvpc-trunk-id \
--cluster cluster_name \
--region us-east-1
```
+ [Get-ECSAttributeList](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-ECSAttributeList.html) (AWS Tools for Windows PowerShell)
```
Get-ECSAttributeList -TargetType container-instance -AttributeName ecs.awsvpc-trunk-id -Region us-east-1
```
# Instâncias com suporte para o aumento de interfaces de rede de contêineres do Amazon ECS
A seguir, são mostrados os tipos de instância do Amazon EC2 compatíveis e o número de tarefas que usam o modo de rede `awsvpc` que podem ser iniciadas em cada tipo de instância antes e após a habilitação da configuração da conta `awsvpcTrunking`.
**Importante**
Embora outros tipos de instância sejam compatíveis na mesma família de instâncias, os tipos de instância `a1.metal`, `c5.metal`, `c5a.8xlarge`, `c5ad.8xlarge`, `c5d.metal`, `m5.metal`, `p3dn.24xlarge`, `r5.metal`, `r5.8xlarge` e `r5d.metal` não são compatíveis.
As famílias de instâncias `c5n`, `d3`, `d3en`, `g3`, `g3s`, `g4dn`, `i3`, `i3en`, `inf1`, `m5dn`, `m5n`, `m5zn`, `mac1`, `r5b`, `r5n`, `r5dn`, `u-12tb1`, `u-6tb1`, `u-9tb1` e `z1d` não são compatíveis.
**Topics**
+ [Uso geral](#eni-branch-gp)
+ [Otimizadas para computação](#eni-branch-co)
+ [Otimizado para memória](#eni-branch-mo)
+ [Otimizada para armazenamento](#eni-branch-so)
+ [Computação acelerada](#eni-branch-ac)
+ [Computação de alta performance](#eni-branch-hpc)
## Uso geral
| Tipo de instância | Limite de tarefas sem truncamento da ENI | Limite de tarefas com truncamento da ENI |
| --- | --- | --- |
| a1.medium | 1 | 10 |
| a1.large | 2 | 10 |
| a1.xlarge | 3 | 20 |
| a1.2xlarge | 3 | 40 |
| a1.4xlarge | 7 | 60 |
| m5.large | 2 | 10 |
| m5.xlarge | 3 | 20 |
| m5.2xlarge | 3 | 40 |
| m5.4xlarge | 7 | 60 |
| m5.8xlarge | 7 | 60 |
| m5.12xlarge | 7 | 60 |
| m5.16xlarge | 14 | 120 |
| m5.24xlarge | 14 | 120 |
| m5a.large | 2 | 10 |
| m5a.xlarge | 3 | 20 |
| m5a.2xlarge | 3 | 40 |
| m5a.4xlarge | 7 | 60 |
| m5a.8xlarge | 7 | 60 |
| m5a.12xlarge | 7 | 60 |
| m5a.16xlarge | 14 | 120 |
| m5a.24xlarge | 14 | 120 |
| m5ad.large | 2 | 10 |
| m5ad.xlarge | 3 | 20 |
| m5ad.2xlarge | 3 | 40 |
| m5ad.4xlarge | 7 | 60 |
| m5ad.8xlarge | 7 | 60 |
| m5ad.12xlarge | 7 | 60 |
| m5ad.16xlarge | 14 | 120 |
| m5ad.24xlarge | 14 | 120 |
| m5d.large | 2 | 10 |
| m5d.xlarge | 3 | 20 |
| m5d.2xlarge | 3 | 40 |
| m5d.4xlarge | 7 | 60 |
| m5d.8xlarge | 7 | 60 |
| m5d.12xlarge | 7 | 60 |
| m5d.16xlarge | 14 | 120 |
| m5d.24xlarge | 14 | 120 |
| m5d.metal | 14 | 120 |
| m6a.large | 2 | 10 |
| m6a.xlarge | 3 | 20 |
| m6a.2xlarge | 3 | 40 |
| m6a.4xlarge | 7 | 60 |
| m6a.8xlarge | 7 | 90 |
| m6a.12xlarge | 7 | 120 |
| m6a.16xlarge | 14 | 120 |
| m6a.24xlarge | 14 | 120 |
| m6a.32xlarge | 14 | 120 |
| m6a.48xlarge | 14 | 120 |
| m6a.metal | 14 | 120 |
| m6g.medium | 1 | 4 |
| m6g.large | 2 | 10 |
| m6g.xlarge | 3 | 20 |
| m6g.2xlarge | 3 | 40 |
| m6g.4xlarge | 7 | 60 |
| m6g.8xlarge | 7 | 60 |
| m6g.12xlarge | 7 | 60 |
| m6g.16xlarge | 14 | 120 |
| m6g.metal | 14 | 120 |
| m6gd.medium | 1 | 4 |
| m6gd.large | 2 | 10 |
| m6gd.xlarge | 3 | 20 |
| m6gd.2xlarge | 3 | 40 |
| m6gd.4xlarge | 7 | 60 |
| m6gd.8xlarge | 7 | 60 |
| m6gd.12xlarge | 7 | 60 |
| m6gd.16xlarge | 14 | 120 |
| m6gd.metal | 14 | 120 |
| m6i.large | 2 | 10 |
| m6i.xlarge | 3 | 20 |
| m6i.2xlarge | 3 | 40 |
| m6i.4xlarge | 7 | 60 |
| m6i.8xlarge | 7 | 90 |
| m6i.12xlarge | 7 | 120 |
| m6i.16xlarge | 14 | 120 |
| m6i.24xlarge | 14 | 120 |
| m6i.32xlarge | 14 | 120 |
| m6i.metal | 14 | 120 |
| m6id.large | 2 | 10 |
| m6id.xlarge | 3 | 20 |
| m6id.2xlarge | 3 | 40 |
| m6id.4xlarge | 7 | 60 |
| m6id.8xlarge | 7 | 90 |
| m6id.12xlarge | 7 | 120 |
| m6id.16xlarge | 14 | 120 |
| m6id.24xlarge | 14 | 120 |
| m6id.32xlarge | 14 | 120 |
| m6id.metal | 14 | 120 |
| m6idn.large | 2 | 10 |
| m6idn.xlarge | 3 | 20 |
| m6idn.2xlarge | 3 | 40 |
| m6idn.4xlarge | 7 | 60 |
| m6idn.8xlarge | 7 | 90 |
| m6idn.12xlarge | 7 | 120 |
| m6idn.16xlarge | 14 | 120 |
| m6idn.24xlarge | 14 | 120 |
| m6idn.32xlarge | 15 | 120 |
| m6idn.metal | 15 | 120 |
| m6in.large | 2 | 10 |
| m6in.xlarge | 3 | 20 |
| m6in.2xlarge | 3 | 40 |
| m6in.4xlarge | 7 | 60 |
| m6in.8xlarge | 7 | 90 |
| m6in.12xlarge | 7 | 120 |
| m6in.16xlarge | 14 | 120 |
| m6in.24xlarge | 14 | 120 |
| m6in.32xlarge | 15 | 120 |
| m6in.metal | 15 | 120 |
| m7a.medium | 1 | 4 |
| m7a.large | 2 | 10 |
| m7a.xlarge | 3 | 20 |
| m7a.2xlarge | 3 | 40 |
| m7a.4xlarge | 7 | 60 |
| m7a.8xlarge | 7 | 90 |
| m7a.12xlarge | 7 | 120 |
| m7a.16xlarge | 14 | 120 |
| m7a.24xlarge | 14 | 120 |
| m7a.32xlarge | 14 | 120 |
| m7a.48xlarge | 14 | 120 |
| m7a.metal-48xl | 14 | 120 |
| m7g.medium | 1 | 4 |
| m7g.large | 2 | 10 |
| m7g.xlarge | 3 | 20 |
| m7g.2xlarge | 3 | 40 |
| m7g.4xlarge | 7 | 60 |
| m7g.8xlarge | 7 | 60 |
| m7g.12xlarge | 7 | 60 |
| m7g.16xlarge | 14 | 120 |
| m7g.metal | 14 | 120 |
| m7gd.medium | 1 | 4 |
| m7gd.large | 2 | 10 |
| m7gd.xlarge | 3 | 20 |
| m7gd.2xlarge | 3 | 40 |
| m7gd.4xlarge | 7 | 60 |
| m7gd.8xlarge | 7 | 60 |
| m7gd.12xlarge | 7 | 60 |
| m7gd.16xlarge | 14 | 120 |
| m7gd.metal | 14 | 120 |
| m7i.large | 2 | 10 |
| m7i.xlarge | 3 | 20 |
| m7i.2xlarge | 3 | 40 |
| m7i.4xlarge | 7 | 60 |
| m7i.8xlarge | 7 | 90 |
| m7i.12xlarge | 7 | 120 |
| m7i.16xlarge | 14 | 120 |
| m7i.24xlarge | 14 | 120 |
| m7i.48xlarge | 14 | 120 |
| m7i.metal-24xl | 14 | 120 |
| m7i.metal-48xl | 14 | 120 |
| m7i-flex.large | 2 | 4 |
| m7i-flex.xlarge | 3 | 10 |
| m7i-flex.2xlarge | 3 | 20 |
| m7i-flex.4xlarge | 7 | 40 |
| m7i-flex.8xlarge | 7 | 60 |
| m7i-flex.12xlarge | 7 | 120 |
| m7i-flex.16xlarge | 14 | 120 |
| m8a.medium | 1 | 4 |
| m8a.large | 2 | 10 |
| m8a.xlarge | 3 | 20 |
| m8a.2xlarge | 3 | 40 |
| m8a.4xlarge | 7 | 60 |
| m8a.8xlarge | 9 | 90 |
| m8a.12xlarge | 11 | 120 |
| m8a.16xlarge | 15 | 120 |
| m8a.24xlarge | 15 | 120 |
| m8a.48xlarge | 23 | 120 |
| m8a.metal-24xl | 15 | 120 |
| m8a.metal-48xl | 23 | 120 |
| m8azn.medium | 2 | 4 |
| m8azn.large | 3 | 10 |
| m8azn.xlarge | 3 | 20 |
| m8azn.3xlarge | 7 | 40 |
| m8azn.6xlarge | 7 | 60 |
| m8azn.12xlarge | 15 | 120 |
| m8azn.24xlarge | 15 | 120 |
| m8azn.metal-12xl | 15 | 120 |
| m8azn.metal-24xl | 15 | 120 |
| m8g.medium | 1 | 4 |
| m8g.large | 2 | 10 |
| m8g.xlarge | 3 | 20 |
| m8g.2xlarge | 3 | 40 |
| m8g.4xlarge | 7 | 60 |
| m8g.8xlarge | 7 | 60 |
| m8g.12xlarge | 7 | 60 |
| m8g.16xlarge | 14 | 120 |
| m8g.24xlarge | 14 | 120 |
| m8g.48xlarge | 14 | 120 |
| m8g.metal-24xl | 14 | 120 |
| m8g.metal-48xl | 14 | 120 |
| m8gb.medium | 1 | 4 |
| m8gb.large | 2 | 10 |
| m8gb.xlarge | 3 | 20 |
| m8gb.2xlarge | 3 | 40 |
| m8gb.4xlarge | 7 | 60 |
| m8gb.8xlarge | 9 | 60 |
| m8gb.12xlarge | 11 | 60 |
| m8gb.16xlarge | 15 | 120 |
| m8gb.24xlarge | 23 | 120 |
| m8gb.48xlarge | 23 | 120 |
| m8gb.metal-24xl | 23 | 120 |
| m8gb.metal-48xl | 23 | 120 |
| m8gd.medium | 1 | 4 |
| m8gd.large | 2 | 10 |
| m8gd.xlarge | 3 | 20 |
| m8gd.2xlarge | 3 | 40 |
| m8gd.4xlarge | 7 | 60 |
| m8gd.8xlarge | 7 | 60 |
| m8gd.12xlarge | 7 | 60 |
| m8gd.16xlarge | 14 | 120 |
| m8gd.24xlarge | 14 | 120 |
| m8gd.48xlarge | 14 | 120 |
| m8gd.metal-24xl | 14 | 120 |
| m8gd.metal-48xl | 14 | 120 |
| m8gn.medium | 1 | 4 |
| m8gn.large | 2 | 10 |
| m8gn.xlarge | 3 | 20 |
| m8gn.2xlarge | 3 | 40 |
| m8gn.4xlarge | 7 | 60 |
| m8gn.8xlarge | 9 | 60 |
| m8gn.12xlarge | 11 | 60 |
| m8gn.16xlarge | 15 | 120 |
| m8gn.24xlarge | 23 | 120 |
| m8gn.48xlarge | 23 | 120 |
| m8gn.metal-24xl | 23 | 120 |
| m8gn.metal-48xl | 23 | 120 |
| m8i.large | 2 | 10 |
| m8i.xlarge | 3 | 20 |
| m8i.2xlarge | 3 | 40 |
| m8i.4xlarge | 7 | 60 |
| m8i.8xlarge | 9 | 90 |
| m8i.12xlarge | 11 | 120 |
| m8i.16xlarge | 15 | 120 |
| m8i.24xlarge | 15 | 120 |
| m8i.32xlarge | 23 | 120 |
| m8i.48xlarge | 23 | 120 |
| m8i.96xlarge | 23 | 120 |
| m8i.metal-48xl | 23 | 120 |
| m8i.metal-96xl | 23 | 120 |
| m8id.large | 2 | 10 |
| m8id.xlarge | 3 | 20 |
| m8id.2xlarge | 3 | 40 |
| m8id.4xlarge | 7 | 60 |
| m8id.8xlarge | 9 | 90 |
| m8id.12xlarge | 11 | 120 |
| m8id.16xlarge | 15 | 120 |
| m8id.24xlarge | 15 | 120 |
| m8id.32xlarge | 23 | 120 |
| m8id.48xlarge | 23 | 120 |
| m8id.96xlarge | 23 | 120 |
| m8id.metal-48xl | 23 | 120 |
| m8id.metal-96xl | 23 | 120 |
| m8i-flex.large | 2 | 4 |
| m8i-flex.xlarge | 3 | 10 |
| m8i-flex.2xlarge | 3 | 20 |
| m8i-flex.4xlarge | 7 | 40 |
| m8i-flex.8xlarge | 9 | 60 |
| m8i-flex.12xlarge | 11 | 120 |
| m8i-flex.16xlarge | 15 | 120 |
| mac2.metal | 7 | 12 |
| mac2-m1ultra.metal | 7 | 12 |
| mac2-m2.metal | 7 | 12 |
| mac2-m2pro.metal | 7 | 12 |
| mac-m4.metal | 7 | 12 |
| mac-m4pro.metal | 7 | 12 |
## Otimizadas para computação
| Tipo de instância | Limite de tarefas sem truncamento da ENI | Limite de tarefas com truncamento da ENI |
| --- | --- | --- |
| c5.large | 2 | 10 |
| c5.xlarge | 3 | 20 |
| c5.2xlarge | 3 | 40 |
| c5.4xlarge | 7 | 60 |
| c5.9xlarge | 7 | 60 |
| c5.12xlarge | 7 | 60 |
| c5.18xlarge | 14 | 120 |
| c5.24xlarge | 14 | 120 |
| c5a.large | 2 | 10 |
| c5a.xlarge | 3 | 20 |
| c5a.2xlarge | 3 | 40 |
| c5a.4xlarge | 7 | 60 |
| c5a.12xlarge | 7 | 60 |
| c5a.16xlarge | 14 | 120 |
| c5a.24xlarge | 14 | 120 |
| c5ad.large | 2 | 10 |
| c5ad.xlarge | 3 | 20 |
| c5ad.2xlarge | 3 | 40 |
| c5ad.4xlarge | 7 | 60 |
| c5ad.12xlarge | 7 | 60 |
| c5ad.16xlarge | 14 | 120 |
| c5ad.24xlarge | 14 | 120 |
| c5d.large | 2 | 10 |
| c5d.xlarge | 3 | 20 |
| c5d.2xlarge | 3 | 40 |
| c5d.4xlarge | 7 | 60 |
| c5d.9xlarge | 7 | 60 |
| c5d.12xlarge | 7 | 60 |
| c5d.18xlarge | 14 | 120 |
| c5d.24xlarge | 14 | 120 |
| c6a.large | 2 | 10 |
| c6a.xlarge | 3 | 20 |
| c6a.2xlarge | 3 | 40 |
| c6a.4xlarge | 7 | 60 |
| c6a.8xlarge | 7 | 90 |
| c6a.12xlarge | 7 | 120 |
| c6a.16xlarge | 14 | 120 |
| c6a.24xlarge | 14 | 120 |
| c6a.32xlarge | 14 | 120 |
| c6a.48xlarge | 14 | 120 |
| c6a.metal | 14 | 120 |
| c6g.medium | 1 | 4 |
| c6g.large | 2 | 10 |
| c6g.xlarge | 3 | 20 |
| c6g.2xlarge | 3 | 40 |
| c6g.4xlarge | 7 | 60 |
| c6g.8xlarge | 7 | 60 |
| c6g.12xlarge | 7 | 60 |
| c6g.16xlarge | 14 | 120 |
| c6g.metal | 14 | 120 |
| c6gd.medium | 1 | 4 |
| c6gd.large | 2 | 10 |
| c6gd.xlarge | 3 | 20 |
| c6gd.2xlarge | 3 | 40 |
| c6gd.4xlarge | 7 | 60 |
| c6gd.8xlarge | 7 | 60 |
| c6gd.12xlarge | 7 | 60 |
| c6gd.16xlarge | 14 | 120 |
| c6gd.metal | 14 | 120 |
| c6gn.medium | 1 | 4 |
| c6gn.large | 2 | 10 |
| c6gn.xlarge | 3 | 20 |
| c6gn.2xlarge | 3 | 40 |
| c6gn.4xlarge | 7 | 60 |
| c6gn.8xlarge | 7 | 60 |
| c6gn.12xlarge | 7 | 60 |
| c6gn.16xlarge | 14 | 120 |
| c6i.large | 2 | 10 |
| c6i.xlarge | 3 | 20 |
| c6i.2xlarge | 3 | 40 |
| c6i.4xlarge | 7 | 60 |
| c6i.8xlarge | 7 | 90 |
| c6i.12xlarge | 7 | 120 |
| c6i.16xlarge | 14 | 120 |
| c6i.24xlarge | 14 | 120 |
| c6i.32xlarge | 14 | 120 |
| c6i.metal | 14 | 120 |
| c6id.large | 2 | 10 |
| c6id.xlarge | 3 | 20 |
| c6id.2xlarge | 3 | 40 |
| c6id.4xlarge | 7 | 60 |
| c6id.8xlarge | 7 | 90 |
| c6id.12xlarge | 7 | 120 |
| c6id.16xlarge | 14 | 120 |
| c6id.24xlarge | 14 | 120 |
| c6id.32xlarge | 14 | 120 |
| c6id.metal | 14 | 120 |
| c6in.large | 2 | 10 |
| c6in.xlarge | 3 | 20 |
| c6in.2xlarge | 3 | 40 |
| c6in.4xlarge | 7 | 60 |
| c6in.8xlarge | 7 | 90 |
| c6in.12xlarge | 7 | 120 |
| c6in.16xlarge | 14 | 120 |
| c6in.24xlarge | 14 | 120 |
| c6in.32xlarge | 15 | 120 |
| c6in.metal | 15 | 120 |
| c7a.medium | 1 | 4 |
| c7a.large | 2 | 10 |
| c7a.xlarge | 3 | 20 |
| c7a.2xlarge | 3 | 40 |
| c7a.4xlarge | 7 | 60 |
| c7a.8xlarge | 7 | 90 |
| c7a.12xlarge | 7 | 120 |
| c7a.16xlarge | 14 | 120 |
| c7a.24xlarge | 14 | 120 |
| c7a.32xlarge | 14 | 120 |
| c7a.48xlarge | 14 | 120 |
| c7a.metal-48xl | 14 | 120 |
| c7g.medium | 1 | 4 |
| c7g.large | 2 | 10 |
| c7g.xlarge | 3 | 20 |
| c7g.2xlarge | 3 | 40 |
| c7g.4xlarge | 7 | 60 |
| c7g.8xlarge | 7 | 60 |
| c7g.12xlarge | 7 | 60 |
| c7g.16xlarge | 14 | 120 |
| c7g.metal | 14 | 120 |
| c7gd.medium | 1 | 4 |
| c7gd.large | 2 | 10 |
| c7gd.xlarge | 3 | 20 |
| c7gd.2xlarge | 3 | 40 |
| c7gd.4xlarge | 7 | 60 |
| c7gd.8xlarge | 7 | 60 |
| c7gd.12xlarge | 7 | 60 |
| c7gd.16xlarge | 14 | 120 |
| c7gd.metal | 14 | 120 |
| c7gn.medium | 1 | 4 |
| c7gn.large | 2 | 10 |
| c7gn.xlarge | 3 | 20 |
| c7gn.2xlarge | 3 | 40 |
| c7gn.4xlarge | 7 | 60 |
| c7gn.8xlarge | 7 | 60 |
| c7gn.12xlarge | 7 | 60 |
| c7gn.16xlarge | 14 | 120 |
| c7gn.metal | 14 | 120 |
| c7i.large | 2 | 10 |
| c7i.xlarge | 3 | 20 |
| c7i.2xlarge | 3 | 40 |
| c7i.4xlarge | 7 | 60 |
| c7i.8xlarge | 7 | 90 |
| c7i.12xlarge | 7 | 120 |
| c7i.16xlarge | 14 | 120 |
| c7i.24xlarge | 14 | 120 |
| c7i.48xlarge | 14 | 120 |
| c7i.metal-24xl | 14 | 120 |
| c7i.metal-48xl | 14 | 120 |
| c7i-flex.large | 2 | 4 |
| c7i-flex.xlarge | 3 | 10 |
| c7i-flex.2xlarge | 3 | 20 |
| c7i-flex.4xlarge | 7 | 40 |
| c7i-flex.8xlarge | 7 | 60 |
| c7i-flex.12xlarge | 7 | 120 |
| c7i-flex.16xlarge | 14 | 120 |
| c8a.medium | 1 | 4 |
| c8a.large | 2 | 10 |
| c8a.xlarge | 3 | 20 |
| c8a.2xlarge | 3 | 40 |
| c8a.4xlarge | 7 | 60 |
| c8a.8xlarge | 9 | 90 |
| c8a.12xlarge | 11 | 120 |
| c8a.16xlarge | 15 | 120 |
| c8a.24xlarge | 15 | 120 |
| c8a.48xlarge | 23 | 120 |
| c8a.metal-24xl | 15 | 120 |
| c8a.metal-48xl | 23 | 120 |
| c8g.medium | 1 | 4 |
| c8g.large | 2 | 10 |
| c8g.xlarge | 3 | 20 |
| c8g.2xlarge | 3 | 40 |
| c8g.4xlarge | 7 | 60 |
| c8g.8xlarge | 7 | 60 |
| c8g.12xlarge | 7 | 60 |
| c8g.16xlarge | 14 | 120 |
| c8g.24xlarge | 14 | 120 |
| c8g.48xlarge | 14 | 120 |
| c8g.metal-24xl | 14 | 120 |
| c8g.metal-48xl | 14 | 120 |
| c8gb.medium | 1 | 4 |
| c8gb.large | 2 | 10 |
| c8gb.xlarge | 3 | 20 |
| c8gb.2xlarge | 3 | 40 |
| c8gb.4xlarge | 7 | 60 |
| c8gb.8xlarge | 9 | 60 |
| c8gb.12xlarge | 11 | 60 |
| c8gb.16xlarge | 15 | 120 |
| c8gb.24xlarge | 23 | 120 |
| c8gb.48xlarge | 23 | 120 |
| c8gb.metal-24xl | 23 | 120 |
| c8gb.metal-48xl | 23 | 120 |
| c8gd.medium | 1 | 4 |
| c8gd.large | 2 | 10 |
| c8gd.xlarge | 3 | 20 |
| c8gd.2xlarge | 3 | 40 |
| c8gd.4xlarge | 7 | 60 |
| c8gd.8xlarge | 7 | 60 |
| c8gd.12xlarge | 7 | 60 |
| c8gd.16xlarge | 14 | 120 |
| c8gd.24xlarge | 14 | 120 |
| c8gd.48xlarge | 14 | 120 |
| c8gd.metal-24xl | 14 | 120 |
| c8gd.metal-48xl | 14 | 120 |
| c8gn.medium | 1 | 4 |
| c8gn.large | 2 | 10 |
| c8gn.xlarge | 3 | 20 |
| c8gn.2xlarge | 3 | 40 |
| c8gn.4xlarge | 7 | 60 |
| c8gn.8xlarge | 9 | 60 |
| c8gn.12xlarge | 11 | 60 |
| c8gn.16xlarge | 15 | 120 |
| c8gn.24xlarge | 23 | 120 |
| c8gn.48xlarge | 23 | 120 |
| c8gn.metal-24xl | 23 | 120 |
| c8gn.metal-48xl | 23 | 120 |
| c8i.large | 2 | 10 |
| c8i.xlarge | 3 | 20 |
| c8i.2xlarge | 3 | 40 |
| c8i.4xlarge | 7 | 60 |
| c8i.8xlarge | 9 | 90 |
| c8i.12xlarge | 11 | 120 |
| c8i.16xlarge | 15 | 120 |
| c8i.24xlarge | 15 | 120 |
| c8i.32xlarge | 23 | 120 |
| c8i.48xlarge | 23 | 120 |
| c8i.96xlarge | 23 | 120 |
| c8i.metal-48xl | 23 | 120 |
| c8i.metal-96xl | 23 | 120 |
| c8id.large | 2 | 10 |
| c8id.xlarge | 3 | 20 |
| c8id.2xlarge | 3 | 40 |
| c8id.4xlarge | 7 | 60 |
| c8id.8xlarge | 9 | 90 |
| c8id.12xlarge | 11 | 120 |
| c8id.16xlarge | 15 | 120 |
| c8id.24xlarge | 15 | 120 |
| c8id.32xlarge | 23 | 120 |
| c8id.48xlarge | 23 | 120 |
| c8id.96xlarge | 23 | 120 |
| c8id.metal-48xl | 23 | 120 |
| c8id.metal-96xl | 23 | 120 |
| c8i-flex.large | 2 | 4 |
| c8i-flex.xlarge | 3 | 10 |
| c8i-flex.2xlarge | 3 | 20 |
| c8i-flex.4xlarge | 7 | 40 |
| c8i-flex.8xlarge | 9 | 60 |
| c8i-flex.12xlarge | 11 | 120 |
| c8i-flex.16xlarge | 15 | 120 |
## Otimizado para memória
| Tipo de instância | Limite de tarefas sem truncamento da ENI | Limite de tarefas com truncamento da ENI |
| --- | --- | --- |
| r5.large | 2 | 10 |
| r5.xlarge | 3 | 20 |
| r5.2xlarge | 3 | 40 |
| r5.4xlarge | 7 | 60 |
| r5.12xlarge | 7 | 60 |
| r5.16xlarge | 14 | 120 |
| r5.24xlarge | 14 | 120 |
| r5a.large | 2 | 10 |
| r5a.xlarge | 3 | 20 |
| r5a.2xlarge | 3 | 40 |
| r5a.4xlarge | 7 | 60 |
| r5a.8xlarge | 7 | 60 |
| r5a.12xlarge | 7 | 60 |
| r5a.16xlarge | 14 | 120 |
| r5a.24xlarge | 14 | 120 |
| r5ad.large | 2 | 10 |
| r5ad.xlarge | 3 | 20 |
| r5ad.2xlarge | 3 | 40 |
| r5ad.4xlarge | 7 | 60 |
| r5ad.8xlarge | 7 | 60 |
| r5ad.12xlarge | 7 | 60 |
| r5ad.16xlarge | 14 | 120 |
| r5ad.24xlarge | 14 | 120 |
| r5b.16xlarge | 14 | 120 |
| r5d.large | 2 | 10 |
| r5d.xlarge | 3 | 20 |
| r5d.2xlarge | 3 | 40 |
| r5d.4xlarge | 7 | 60 |
| r5d.8xlarge | 7 | 60 |
| r5d.12xlarge | 7 | 60 |
| r5d.16xlarge | 14 | 120 |
| r5d.24xlarge | 14 | 120 |
| r5dn.16xlarge | 14 | 120 |
| r6a.large | 2 | 10 |
| r6a.xlarge | 3 | 20 |
| r6a.2xlarge | 3 | 40 |
| r6a.4xlarge | 7 | 60 |
| r6a.8xlarge | 7 | 90 |
| r6a.12xlarge | 7 | 120 |
| r6a.16xlarge | 14 | 120 |
| r6a.24xlarge | 14 | 120 |
| r6a.32xlarge | 14 | 120 |
| r6a.48xlarge | 14 | 120 |
| r6a.metal | 14 | 120 |
| r6g.medium | 1 | 4 |
| r6g.large | 2 | 10 |
| r6g.xlarge | 3 | 20 |
| r6g.2xlarge | 3 | 40 |
| r6g.4xlarge | 7 | 60 |
| r6g.8xlarge | 7 | 60 |
| r6g.12xlarge | 7 | 60 |
| r6g.16xlarge | 14 | 120 |
| r6g.metal | 14 | 120 |
| r6gd.medium | 1 | 4 |
| r6gd.large | 2 | 10 |
| r6gd.xlarge | 3 | 20 |
| r6gd.2xlarge | 3 | 40 |
| r6gd.4xlarge | 7 | 60 |
| r6gd.8xlarge | 7 | 60 |
| r6gd.12xlarge | 7 | 60 |
| r6gd.16xlarge | 14 | 120 |
| r6gd.metal | 14 | 120 |
| r6i.large | 2 | 10 |
| r6i.xlarge | 3 | 20 |
| r6i.2xlarge | 3 | 40 |
| r6i.4xlarge | 7 | 60 |
| r6i.8xlarge | 7 | 90 |
| r6i.12xlarge | 7 | 120 |
| r6i.16xlarge | 14 | 120 |
| r6i.24xlarge | 14 | 120 |
| r6i.32xlarge | 14 | 120 |
| r6i.metal | 14 | 120 |
| r6id.large | 2 | 10 |
| r6id.xlarge | 3 | 20 |
| r6id.2xlarge | 3 | 40 |
| r6id.4xlarge | 7 | 60 |
| r6id.8xlarge | 7 | 90 |
| r6id.12xlarge | 7 | 120 |
| r6id.16xlarge | 14 | 120 |
| r6id.24xlarge | 14 | 120 |
| r6id.32xlarge | 14 | 120 |
| r6id.metal | 14 | 120 |
| r6idn.large | 2 | 10 |
| r6idn.xlarge | 3 | 20 |
| r6idn.2xlarge | 3 | 40 |
| r6idn.4xlarge | 7 | 60 |
| r6idn.8xlarge | 7 | 90 |
| r6idn.12xlarge | 7 | 120 |
| r6idn.16xlarge | 14 | 120 |
| r6idn.24xlarge | 14 | 120 |
| r6idn.32xlarge | 15 | 120 |
| r6idn.metal | 15 | 120 |
| r6in.large | 2 | 10 |
| r6in.xlarge | 3 | 20 |
| r6in.2xlarge | 3 | 40 |
| r6in.4xlarge | 7 | 60 |
| r6in.8xlarge | 7 | 90 |
| r6in.12xlarge | 7 | 120 |
| r6in.16xlarge | 14 | 120 |
| r6in.24xlarge | 14 | 120 |
| r6in.32xlarge | 15 | 120 |
| r6in.metal | 15 | 120 |
| r7a.medium | 1 | 4 |
| r7a.large | 2 | 10 |
| r7a.xlarge | 3 | 20 |
| r7a.2xlarge | 3 | 40 |
| r7a.4xlarge | 7 | 60 |
| r7a.8xlarge | 7 | 90 |
| r7a.12xlarge | 7 | 120 |
| r7a.16xlarge | 14 | 120 |
| r7a.24xlarge | 14 | 120 |
| r7a.32xlarge | 14 | 120 |
| r7a.48xlarge | 14 | 120 |
| r7a.metal-48xl | 14 | 120 |
| r7g.medium | 1 | 4 |
| r7g.large | 2 | 10 |
| r7g.xlarge | 3 | 20 |
| r7g.2xlarge | 3 | 40 |
| r7g.4xlarge | 7 | 60 |
| r7g.8xlarge | 7 | 60 |
| r7g.12xlarge | 7 | 60 |
| r7g.16xlarge | 14 | 120 |
| r7g.metal | 14 | 120 |
| r7gd.medium | 1 | 4 |
| r7gd.large | 2 | 10 |
| r7gd.xlarge | 3 | 20 |
| r7gd.2xlarge | 3 | 40 |
| r7gd.4xlarge | 7 | 60 |
| r7gd.8xlarge | 7 | 60 |
| r7gd.12xlarge | 7 | 60 |
| r7gd.16xlarge | 14 | 120 |
| r7gd.metal | 14 | 120 |
| r7i.large | 2 | 10 |
| r7i.xlarge | 3 | 20 |
| r7i.2xlarge | 3 | 40 |
| r7i.4xlarge | 7 | 60 |
| r7i.8xlarge | 7 | 90 |
| r7i.12xlarge | 7 | 120 |
| r7i.16xlarge | 14 | 120 |
| r7i.24xlarge | 14 | 120 |
| r7i.48xlarge | 14 | 120 |
| r7i.metal-24xl | 14 | 120 |
| r7i.metal-48xl | 14 | 120 |
| r7iz.large | 2 | 10 |
| r7iz.xlarge | 3 | 20 |
| r7iz.2xlarge | 3 | 40 |
| r7iz.4xlarge | 7 | 60 |
| r7iz.8xlarge | 7 | 90 |
| r7iz.12xlarge | 7 | 120 |
| r7iz.16xlarge | 14 | 120 |
| r7iz.32xlarge | 14 | 120 |
| r7iz.metal-16xl | 14 | 120 |
| r7iz.metal-32xl | 14 | 120 |
| r8a.medium | 1 | 4 |
| r8a.large | 2 | 10 |
| r8a.xlarge | 3 | 20 |
| r8a.2xlarge | 3 | 40 |
| r8a.4xlarge | 7 | 60 |
| r8a.8xlarge | 9 | 90 |
| r8a.12xlarge | 11 | 120 |
| r8a.16xlarge | 15 | 120 |
| r8a.24xlarge | 15 | 120 |
| r8a.48xlarge | 23 | 120 |
| m8a.metal-24xl | 15 | 120 |
| m8a.metal-48xl | 23 | 120 |
| r8g.medium | 1 | 4 |
| r8g.large | 2 | 10 |
| r8g.xlarge | 3 | 20 |
| r8g.2xlarge | 3 | 40 |
| r8g.4xlarge | 7 | 60 |
| r8g.8xlarge | 7 | 60 |
| r8g.12xlarge | 7 | 60 |
| r8g.16xlarge | 14 | 120 |
| r8g.24xlarge | 14 | 120 |
| r8g.48xlarge | 14 | 120 |
| r8g.metal-24xl | 14 | 120 |
| r8g.metal-48xl | 14 | 120 |
| r8gb.medium | 1 | 4 |
| r8gb.large | 2 | 10 |
| r8gb.xlarge | 3 | 20 |
| r8gb.2xlarge | 3 | 40 |
| r8gb.4xlarge | 7 | 60 |
| r8gb.8xlarge | 9 | 60 |
| r8gb.12xlarge | 11 | 60 |
| r8gb.16xlarge | 15 | 120 |
| r8gb.24xlarge | 23 | 120 |
| r8gb.48xlarge | 23 | 120 |
| r8gb.metal-24xl | 23 | 120 |
| r8gb.metal-48xl | 23 | 120 |
| r8gd.medium | 1 | 4 |
| r8gd.large | 2 | 10 |
| r8gd.xlarge | 3 | 20 |
| r8gd.2xlarge | 3 | 40 |
| r8gd.4xlarge | 7 | 60 |
| r8gd.8xlarge | 7 | 60 |
| r8gd.12xlarge | 7 | 60 |
| r8gd.16xlarge | 14 | 120 |
| r8gd.24xlarge | 14 | 120 |
| r8gd.48xlarge | 14 | 120 |
| r8gd.metal-24xl | 14 | 120 |
| r8gd.metal-48xl | 14 | 120 |
| r8gn.medium | 1 | 4 |
| r8gn.large | 2 | 10 |
| r8gn.xlarge | 3 | 20 |
| r8gn.2xlarge | 3 | 40 |
| r8gn.4xlarge | 7 | 60 |
| r8gn.8xlarge | 9 | 60 |
| r8gn.12xlarge | 11 | 60 |
| r8gn.16xlarge | 15 | 120 |
| r8gn.24xlarge | 23 | 120 |
| r8gn.48xlarge | 23 | 120 |
| r8gn.metal-24xl | 23 | 120 |
| r8gn.metal-48xl | 23 | 120 |
| r8i.large | 2 | 10 |
| r8i.xlarge | 3 | 20 |
| r8i.2xlarge | 3 | 40 |
| r8i.4xlarge | 7 | 60 |
| r8i.8xlarge | 9 | 90 |
| r8i.12xlarge | 11 | 120 |
| r8i.16xlarge | 15 | 120 |
| r8i.24xlarge | 15 | 120 |
| r8i.32xlarge | 23 | 120 |
| r8i.48xlarge | 23 | 120 |
| r8i.96xlarge | 23 | 120 |
| r8i.metal-48xl | 23 | 120 |
| r8i.metal-96xl | 23 | 120 |
| r8id.large | 2 | 10 |
| r8id.xlarge | 3 | 20 |
| r8id.2xlarge | 3 | 40 |
| r8id.4xlarge | 7 | 60 |
| r8id.8xlarge | 9 | 90 |
| r8id.12xlarge | 11 | 120 |
| r8id.16xlarge | 15 | 120 |
| r8id.24xlarge | 15 | 120 |
| r8id.32xlarge | 23 | 120 |
| r8id.48xlarge | 23 | 120 |
| r8id.96xlarge | 23 | 120 |
| r8id.metal-48xl | 23 | 120 |
| r8id.metal-96xl | 23 | 120 |
| r8i-flex.large | 2 | 4 |
| r8i-flex.xlarge | 3 | 10 |
| r8i-flex.2xlarge | 3 | 20 |
| r8i-flex.4xlarge | 7 | 40 |
| r8i-flex.8xlarge | 9 | 60 |
| r8i-flex.12xlarge | 11 | 120 |
| r8i-flex.16xlarge | 15 | 120 |
| u-3tb1.56xlarge | 7 | 12 |
| u-6tb1.56xlarge | 14 | 12 |
| u-18tb1.112xlarge | 14 | 12 |
| u-18tb1.metal | 14 | 12 |
| u-24tb1.112xlarge | 14 | 12 |
| u-24tb1.metal | 14 | 12 |
| u7i-6tb.112xlarge | 14 | 120 |
| u7i-8tb.112xlarge | 14 | 120 |
| u7i-12tb.224xlarge | 14 | 120 |
| u7in-16tb.224xlarge | 15 | 120 |
| u7in-24tb.224xlarge | 15 | 120 |
| u7in-32tb.224xlarge | 15 | 120 |
| u7inh-32tb.480xlarge | 15 | 120 |
| x2gd.medium | 1 | 10 |
| x2gd.large | 2 | 10 |
| x2gd.xlarge | 3 | 20 |
| x2gd.2xlarge | 3 | 40 |
| x2gd.4xlarge | 7 | 60 |
| x2gd.8xlarge | 7 | 60 |
| x2gd.12xlarge | 7 | 60 |
| x2gd.16xlarge | 14 | 120 |
| x2gd.metal | 14 | 120 |
| x2idn.16xlarge | 14 | 120 |
| x2idn.24xlarge | 14 | 120 |
| x2idn.32xlarge | 14 | 120 |
| x2idn.metal | 14 | 120 |
| x2iedn.xlarge | 3 | 13 |
| x2iedn.2xlarge | 3 | 29 |
| x2iedn.4xlarge | 7 | 60 |
| x2iedn.8xlarge | 7 | 120 |
| x2iedn.16xlarge | 14 | 120 |
| x2iedn.24xlarge | 14 | 120 |
| x2iedn.32xlarge | 14 | 120 |
| x2iedn.metal | 14 | 120 |
| x2iezn.2xlarge | 3 | 64 |
| x2iezn.4xlarge | 7 | 120 |
| x2iezn.6xlarge | 7 | 120 |
| x2iezn.8xlarge | 7 | 120 |
| x2iezn.12xlarge | 14 | 120 |
| x2iezn.metal | 14 | 120 |
| x8g.medium | 1 | 4 |
| x8g.large | 2 | 10 |
| x8g.xlarge | 3 | 20 |
| x8g.2xlarge | 3 | 40 |
| x8g.4xlarge | 7 | 60 |
| x8g.8xlarge | 7 | 60 |
| x8g.12xlarge | 7 | 60 |
| x8g.16xlarge | 14 | 120 |
| x8g.24xlarge | 14 | 120 |
| x8g.48xlarge | 14 | 120 |
| x8g.metal-24xl | 14 | 120 |
| x8g.metal-48xl | 14 | 120 |
| x8aedz.large | 3 | 10 |
| x8aedz.xlarge | 3 | 20 |
| x8aedz.3xlarge | 7 | 40 |
| x8aedz.6xlarge | 7 | 60 |
| x8aedz.12xlarge | 15 | 120 |
| x8aedz.24xlarge | 15 | 120 |
| x8aedz.metal-12xl | 15 | 120 |
| x8aedz.metal-24xl | 15 | 120 |
| x8i.large | 2 | 10 |
| x8i.xlarge | 3 | 20 |
| x8i.2xlarge | 3 | 40 |
| x8i.4xlarge | 7 | 60 |
| x8i.8xlarge | 9 | 90 |
| x8i.12xlarge | 11 | 120 |
| x8i.16xlarge | 15 | 120 |
| x8i.24xlarge | 15 | 120 |
| x8i.32xlarge | 23 | 120 |
| x8i.48xlarge | 23 | 120 |
| x8i.64xlarge | 23 | 120 |
| x8i.96xlarge | 23 | 120 |
| x8i.metal-48xl | 23 | 120 |
| x8i.metal-96xl | 23 | 120 |
## Otimizada para armazenamento
| Tipo de instância | Limite de tarefas sem truncamento da ENI | Limite de tarefas com truncamento da ENI |
| --- | --- | --- |
| i4g.large | 2 | 10 |
| i4g.xlarge | 3 | 20 |
| i4g.2xlarge | 3 | 40 |
| i4g.4xlarge | 7 | 60 |
| i4g.8xlarge | 7 | 60 |
| i4g.16xlarge | 14 | 120 |
| i4i.xlarge | 3 | 8 |
| i4i.2xlarge | 3 | 28 |
| i4i.4xlarge | 7 | 58 |
| i4i.8xlarge | 7 | 118 |
| i4i.12xlarge | 7 | 118 |
| i4i.16xlarge | 14 | 248 |
| i4i.24xlarge | 14 | 118 |
| i4i.32xlarge | 14 | 498 |
| i4i.metal | 14 | 498 |
| i7i.large | 2 | 10 |
| i7i.xlarge | 3 | 20 |
| i7i.2xlarge | 3 | 40 |
| i7i.4xlarge | 7 | 60 |
| i7i.8xlarge | 7 | 90 |
| i7i.12xlarge | 7 | 90 |
| i7i.16xlarge | 14 | 120 |
| i7i.24xlarge | 14 | 120 |
| i7i.48xlarge | 14 | 120 |
| i7i.metal-24xl | 14 | 120 |
| i7i.metal-48xl | 14 | 120 |
| i7ie.large | 2 | 20 |
| i7ie.xlarge | 3 | 29 |
| i7ie.2xlarge | 3 | 29 |
| i7ie.3xlarge | 3 | 29 |
| i7ie.6xlarge | 7 | 60 |
| i7ie.12xlarge | 7 | 60 |
| i7ie.18xlarge | 14 | 120 |
| i7ie.24xlarge | 14 | 120 |
| i7ie.48xlarge | 14 | 120 |
| i7ie.metal-24xl | 14 | 120 |
| i7ie.metal-48xl | 14 | 120 |
| i8g.large | 2 | 10 |
| i8g.xlarge | 3 | 20 |
| i8g.2xlarge | 3 | 40 |
| i8g.4xlarge | 7 | 60 |
| i8g.8xlarge | 7 | 60 |
| i8g.12xlarge | 7 | 60 |
| i8g.16xlarge | 14 | 120 |
| i8g.24xlarge | 14 | 120 |
| i8g.48xlarge | 14 | 120 |
| i8g.metal-24xl | 14 | 120 |
| i8g.metal-48xl | 14 | 120 |
| i8ge.large | 2 | 20 |
| i8ge.xlarge | 3 | 29 |
| i8ge.2xlarge | 3 | 29 |
| i8ge.3xlarge | 5 | 29 |
| i8ge.6xlarge | 9 | 60 |
| i8ge.12xlarge | 11 | 60 |
| i8ge.18xlarge | 15 | 120 |
| i8ge.24xlarge | 15 | 120 |
| i8ge.48xlarge | 23 | 120 |
| i8ge.metal-24xl | 15 | 120 |
| i8ge.metal-48xl | 23 | 120 |
| im4gn.large | 2 | 10 |
| im4gn.xlarge | 3 | 20 |
| im4gn.2xlarge | 3 | 40 |
| im4gn.4xlarge | 7 | 60 |
| im4gn.8xlarge | 7 | 60 |
| im4gn.16xlarge | 14 | 120 |
| is4gen.medium | 1 | 4 |
| is4gen.large | 2 | 10 |
| is4gen.xlarge | 3 | 20 |
| is4gen.2xlarge | 3 | 40 |
| is4gen.4xlarge | 7 | 60 |
| is4gen.8xlarge | 7 | 60 |
## Computação acelerada
| Tipo de instância | Limite de tarefas sem truncamento da ENI | Limite de tarefas com truncamento da ENI |
| --- | --- | --- |
| dl1.24xlarge | 59 | 120 |
| dl2q.24xlarge | 14 | 120 |
| f2.6xlarge | 7 | 90 |
| f2.12xlarge | 7 | 120 |
| f2.48xlarge | 14 | 120 |
| g4ad.xlarge | 1 | 12 |
| g4ad.2xlarge | 1 | 12 |
| g4ad.4xlarge | 2 | 12 |
| g4ad.8xlarge | 3 | 12 |
| g4ad.16xlarge | 7 | 12 |
| g5.xlarge | 3 | 6 |
| g5.2xlarge | 3 | 19 |
| g5.4xlarge | 7 | 40 |
| g5.8xlarge | 7 | 90 |
| g5.12xlarge | 14 | 120 |
| g5.16xlarge | 7 | 120 |
| g5.24xlarge | 14 | 120 |
| g5.48xlarge | 6 | 120 |
| g5g.xlarge | 3 | 20 |
| g5g.2xlarge | 3 | 40 |
| g5g.4xlarge | 7 | 60 |
| g5g.8xlarge | 7 | 60 |
| g5g.16xlarge | 14 | 120 |
| g5g.metal | 14 | 120 |
| g6.xlarge | 3 | 20 |
| g6.2xlarge | 3 | 40 |
| g6.4xlarge | 7 | 60 |
| g6.8xlarge | 7 | 90 |
| g6.12xlarge | 7 | 120 |
| g6.16xlarge | 14 | 120 |
| g6.24xlarge | 14 | 120 |
| g6.48xlarge | 14 | 120 |
| g6e.xlarge | 3 | 20 |
| g6e.2xlarge | 3 | 40 |
| g6e.4xlarge | 7 | 60 |
| g6e.8xlarge | 7 | 90 |
| g6e.12xlarge | 9 | 120 |
| g6e.16xlarge | 14 | 120 |
| g6e.24xlarge | 19 | 120 |
| g6e.48xlarge | 39 | 120 |
| g6f.large | 1 | 10 |
| g6f.xlarge | 3 | 20 |
| g6f.2xlarge | 3 | 40 |
| g6f.4xlarge | 7 | 60 |
| gr6.4xlarge | 7 | 60 |
| gr6.8xlarge | 7 | 90 |
| gr6f.4xlarge | 7 | 60 |
| g7e.2xlarge | 3 | 242 |
| g7e.4xlarge | 7 | 242 |
| g7e.8xlarge | 7 | 242 |
| g7e.12xlarge | 9 | 242 |
| g7e.24xlarge | 19 | 242 |
| g7e.48xlarge | 39 | 242 |
| inf2.xlarge | 3 | 20 |
| inf2.8xlarge | 7 | 90 |
| inf2.24xlarge | 14 | 120 |
| inf2.48xlarge | 14 | 120 |
| p4d.24xlarge | 59 | 120 |
| p4de.24xlarge | 59 | 120 |
| p5.4xlarge | 3 | 60 |
| p5.48xlarge | 63 | 242 |
| p5e.48xlarge | 63 | 242 |
| p5en.48xlarge | 63 | 242 |
| p6-b200.48xlarge | 31 | 242 |
| p6-b300.48xlarge | 67 | 242 |
| p6e-gb200.36xlarge | 38 | 120 |
| trn1.2xlarge | 3 | 19 |
| trn1.32xlarge | 39 | 120 |
| trn1n.32xlarge | 79 | 242 |
| trn2.3xlarge | 1 | 14 |
| trn2.48xlarge | 31 | 242 |
| trn2u.48xlarge | 31 | 242 |
| vt1.3xlarge | 3 | 40 |
| vt1.6xlarge | 7 | 60 |
| vt1.24xlarge | 14 | 120 |
## Computação de alta performance
| Tipo de instância | Limite de tarefas sem truncamento da ENI | Limite de tarefas com truncamento da ENI |
| --- | --- | --- |
| hpc6a.48xlarge | 1 | 120 |
| hpc6id.32xlarge | 1 | 120 |
| hpc7g.4xlarge | 3 | 120 |
| hpc7g.8xlarge | 3 | 120 |
| hpc7g.16xlarge | 3 | 120 |
| hpc8a.96xlarge | 3 | -2 |
# Reserva de memória da instância de contêiner do Linux no Amazon ECS
Quando o agente de contêiner do Amazon ECS registra uma instância de contêiner em um cluster, o agente deve determinar a quantidade de memória que a instância de contêiner tem disponível com a finalidade de reservar para as tarefas. Devido à sobrecarga de memória da plataforma e à memória ocupada pelo kernel do sistema, esse número é diferente da memória instalada anunciada para instâncias do Amazon EC2. Por exemplo, uma instância `m4.large` tem 8 GiB de memória instalada. No entanto, isso nem sempre significa que exatos 8.192 MiB de memória estão disponíveis para as tarefas quando a instância de contêiner é registrada.
## Determinação de recursos de memória das instâncias gerenciadas do ECS
As instâncias gerenciadas do Amazon ECS usam uma abordagem hierárquica para determinar os requisitos de recursos de memória para tarefas. Ao contrário do ECS no EC2, que depende da introspecção de memória do Docker, as instâncias gerenciadas do ECS calculam os requisitos de memória diretamente da carga útil da tarefa durante as decisões de agendamento.
Quando o agente de instâncias gerenciadas do ECS recebe uma tarefa, ele calcula a necessidade de memória usando a seguinte ordem de prioridade:
1. **Memória no nível da tarefa (prioridade mais alta)**: se a memória no nível da tarefa for especificada na definição de tarefa, o agente usará esse valor diretamente. Isso tem precedência sobre todas as configurações de memória no nível do contêiner.
1. **Soma de memória no nível do contêiner (fallback)**: se a memória no nível da tarefa não for especificada (ou for 0), o agente somará os requisitos de memória de todos os contêineres na tarefa. Para cada contêiner, ele usa:
1. *Reserva de memória (limite flexível)*: se um contêiner especificar `memoryReservation` em sua configuração, o agente usará esse valor.
1. *Memória do contêiner (limite fixo)*: se `memoryReservation` não for especificado, o agente usará o campo `memory` do contêiner.
**Example Memória especificada no nível da tarefa**
Quando a memória no nível da tarefa é especificada, ela tem precedência sobre as configurações no nível do contêiner:
```
{
"family": "my-task",
"memory": "2048",
"containerDefinitions": [
{
"name": "container1",
"memory": 1024,
"memoryReservation": 512
}
]
}
```
O agente reserva 2.048 MiB (a memória no nível da tarefa tem precedência).
**Example Memória no nível do contêiner com reservas**
Quando a memória no nível da tarefa não é especificada, o agente soma os requisitos de memória do contêiner:
```
{
"family": "my-task",
"containerDefinitions": [
{
"name": "container1",
"memory": 1024,
"memoryReservation": 512
},
{
"name": "container2",
"memory": 512
}
]
}
```
O agente reserva 512 MiB (reserva de contêiner 1) \$1 512 MiB (memória de contêiner 2) = 1.024 MiB no total.
O agente de instâncias gerenciadas do ECS executa o cálculo de memória em três fases:
1. **Recepção da tarefa**: quando uma carga útil da tarefa chega do ambiente de gerenciamento do ECS, o agente calcula imediatamente a memória necessária.
1. **Armazenamento de recursos**: a necessidade de memória calculada é armazenada no modelo de tarefas para uso posterior em operações contábeis de recursos.
1. **Decisão de agendamento**: antes de aceitar uma tarefa, o agente verifica se há memória suficiente disponível. Se a memória disponível for insuficiente, a tarefa será rejeitada e permanecerá na fila de serviços do ECS até que os recursos estejam disponíveis.
**nota**
Diferentemente do ECS no EC2, as instâncias gerenciadas do ECS não usam a variável de configuração `ECS_RESERVED_MEMORY`. A reserva de memória para os processos do sistema é feita por meio do gerenciamento de recursos da plataforma subjacente, e o agente faz uma contabilidade precisa dos recursos com base nas definições das tarefas.
Na opção ECS no EC2, o agente de contêiner do Amazon ECS fornece uma variável de configuração denominada `ECS_RESERVED_MEMORY`, que pode ser usada para remover um número específico de MiB de memória do grupo alocado para as tarefas. Isso reserva de forma efetiva a memória para processos críticos do sistema.
Se você ocupar toda a memória em uma instância de contêiner com as tarefas, é possível que elas disputem a memória com processos essenciais do sistema e iniciem uma falha no sistema.
Por exemplo, se você especificar `ECS_RESERVED_MEMORY=256` no arquivo de configuração do agente de contêiner, o agente registrará a memória total menos 256 MiB para essa instância, e 256 MiB de memória não poderão ser atribuídos para tarefas do ECS. Para obter mais informações sobre as variáveis de configuração do agente e como configurá-las, consulte [Configuração do agente de contêiner do Amazon ECS](ecs-agent-config.md) e [Inicialização de instâncias de contêiner do Linux no Amazon ECS para transmitir dados](bootstrap_container_instance.md).
Se você especificar 8.192 MiB para a tarefa e nenhuma de suas instâncias de contêiner tiver 8.192 MiB ou mais de memória disponível para atender a esse requisito, a tarefa não poderá ser posicionada no cluster. Se estiver usando um ambiente de computação gerenciado, o AWS Batch deverá executar um tipo de instância maior para acomodar a solicitação.
O atendente de contêiner do Amazon ECS usa a função `ReadMemInfo()` do Docker para consultar a memória disponível total para o sistema operacional. Tanto o Linux quanto o Windows oferecem utilitários de linha de comando para determinar a memória total.
**Example - Determinar a memória total do Linux**
O comando **free** retorna a memória total reconhecida pelo sistema operacional.
```
$ free -b
```
Exemplo de saída para uma instância `m4.large` executando a AMI do Amazon Linux otimizada para Amazon ECS.
```
total used free shared buffers cached
Mem: 8373026816 348180480 8024846336 90112 25534464 205418496
-/+ buffers/cache: 117227520 8255799296
```
Essa instância tem 8.373.026.816 bytes de memória total, ou seja, 7.985 MiB estão disponíveis para tarefas.
**Example - Determinar a memória total do Windows**
O comando **wmic** retorna a memória total reconhecida pelo sistema operacional.
```
C:\> wmic ComputerSystem get TotalPhysicalMemory
```
Exemplo de saída para uma instância `m4.large` executando a AMI do Windows otimizada para o Amazon ECS.
```
TotalPhysicalMemory
8589524992
```
Essa instância tem 8.589.524.992 bytes de memória total, ou seja, 8.191 MiB estão disponíveis para tarefas.
## Visualização da memória da instância de contêiner
É possível visualizar a quantidade de memória com a qual uma instância de contêiner é registrada no console do Amazon ECS (ou com a operação da API [DescribeContainerInstances](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html)). Se estiver tentando maximizar a utilização de recursos fornecendo às suas tarefas o máximo de memória possível para um tipo de instância específico, você pode observar a memória disponível para essa instância de contêiner e atribuir essa quantidade de memória às tarefas.
**Para visualizar a memória da instância de contêiner**
1. Abra o console em [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).
1. No painel de navegação, escolha **Clusters** e selecione o cluster que hospeda a instância de contêiner.
1. Escolha **Infraestrutura** e, em Instâncias de contêiner, selecione uma instância de contêiner.
1. A seção **Recursos** mostra a memória registrada e disponível para a instância de contêiner.
O valor da memória **Registrada** é o que a instância de contêiner registrou no Amazon ECS quando foi executada pela primeira vez, e o valor da memória **Disponível** é o que ainda não foi alocado para tarefas.
# Gerenciamento de instâncias de contêiner do Amazon ECS remotamente usando o AWS Systems Manager
É possível usar o recurso Run Command do AWS Systems Manager (Systems Manager) para gerenciar de forma remota e segura a configuração das instâncias de contêiner do Amazon ECS. O Run Command oferece uma maneira simples de executar tarefas administrativas comuns sem fazer login localmente na instância. É possível gerenciar as alterações de configuração entre clusters executando comandos simultaneamente nas várias instâncias de contêiner. O Run Command reporta o status e os resultados de cada comando.
Veja alguns exemplos dos tipos de tarefas que você pode executar com o Run Command:
+ Instale ou desinstale pacotes.
+ Execute atualizações de segurança.
+ Limpe imagens de docker.
+ Interrompa ou inicie serviços.
+ Visualize os recursos do sistema.
+ Visualize os arquivos de log.
+ Execute operações de arquivos.
Para obter mais informações sobre o Run Command, consulte [Run Command do AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/run-command.html) no *Guia do usuário do AWS Systems Manager*.
A seguir, apresentamos os pré-requisitos para usar o Systems Manager com o Amazon ECS.
1. Você deve conceder permissões para acessar as APIs do Systems Manager ao perfil de instância de contêiner (**ecsInstanceRole**). É possível fazer isso ao atribuir **AmazonSSMManagedInstanceCore** ao perfil `ecsInstanceRole`. Para obter informações sobre como anexar uma política a um perfil, consulte [Atualizar permissões para um perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-permissions.html) no *Guia do usuário do AWS Identity and Access Management*.
1. Verifique se o SSM Agent está instalado nas instâncias de contêiner. Para obter mais informações, consulte [Instalar e desinstalar manualmente o SSM Agent em instâncias do EC2 para Linux](https://docs.aws.amazon.com/systems-manager/latest/userguide/manually-install-ssm-agent-linux.html).
Depois de anexar políticas gerenciadas do Systems Manager a `ecsInstanceRole` e verificar se o Agente (SSM Agent) do AWS Systems Manager está instalado nas instâncias de contêiner, será possível começar a usar o Run Command para enviar comandos às instâncias de contêiner. Para obter informações sobre a execução de comandos e scripts de shell nas instâncias e visualizar a saída resultante, consulte [Executar comandos usando o Run Command do Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/run-command.html) e [Demonstrações do Run Command](https://docs.aws.amazon.com/systems-manager/latest/userguide/run-command-walkthroughs.html) no *Guia do usuário do AWS Systems Manager.*
Um caso de uso comum é atualizar o software da instância de contêiner com Executar comando. Você pode seguir os procedimentos no Guia do usuário do AWS Systems Manager com os parâmetros a seguir.
| Parâmetro | Valor |
| --- | --- |
| **Documento de comando** | AWS-RunShellScript |
| Comando | $ yum update -y
|
| Instâncias de destino | Suas instâncias de contêiner |
# Uso de um proxy HTTP para instâncias de contêiner do Linux no Amazon ECS
É possível configurar as instâncias de contêiner do Amazon ECS para usar um proxy HTTP para o agente de contêiner do Amazon ECS e o daemon do Docker. Isso é útil se suas as instâncias de contêiner não têm acesso à rede externa através de um gateway da Internet da Amazon VPC, um gateway NAT ou uma instância.
Para configurar sua instância de contêiner do Linux do Amazon ECS para usar um proxy HTTP, defina as variáveis a seguir nos arquivos relevantes no momento da inicialização (com dados de usuário do Amazon EC2). Além disso, é possível editar manualmente o arquivo de configuração e, em seguida, reiniciar o agente.
`/etc/ecs/ecs.config` (Amazon Linux 2 e AmazonLinux AMI)
`HTTP_PROXY=10.0.0.131:3128`
Defina esse valor para o nome do host (ou endereço IP) e o número de porta de um proxy HTTP a serem usados pelo agente do Amazon ECS para se conectar à Internet. Por exemplo, as instâncias de contêiner podem não ter acesso à rede externa através de um gateway da Internet da Amazon VPC, um gateway NAT ou uma instância.
`NO_PROXY=169.254.169.254,169.254.170.2,/var/run/docker.sock`
Defina esse valor como `169.254.169.254,169.254.170.2,/var/run/docker.sock` para filtrar metadados da instância do EC2, perfis do IAM para tarefas e o tráfego do daemon do Docker proveniente do proxy.
`/etc/systemd/system/ecs.service.d/http-proxy.conf` (somente Amazon Linux 2)
`Environment="HTTP_PROXY=10.0.0.131:3128/"`
Defina esse valor como o nome do host (ou endereço IP) e o número de porta de um proxy HTTP a serem usados pelo `ecs-init` para se conectar à Internet. Por exemplo, as instâncias de contêiner podem não ter acesso à rede externa através de um gateway da Internet da Amazon VPC, um gateway NAT ou uma instância.
`Environment="NO_PROXY=169.254.169.254,169.254.170.2,/var/run/docker.sock"`
Defina esse valor como `169.254.169.254,169.254.170.2,/var/run/docker.sock` para filtrar metadados da instância do EC2, funções do IAM para tarefas e o tráfego do daemon do Docker proveniente do proxy.
`/etc/init/ecs.override` (Somente Amazon Linux AMI)
`env HTTP_PROXY=10.0.0.131:3128`
Defina esse valor como o nome do host (ou endereço IP) e o número de porta de um proxy HTTP a serem usados pelo `ecs-init` para se conectar à Internet. Por exemplo, as instâncias de contêiner podem não ter acesso à rede externa através de um gateway da Internet da Amazon VPC, um gateway NAT ou uma instância.
`env NO_PROXY=169.254.169.254,169.254.170.2,/var/run/docker.sock`
Defina esse valor como `169.254.169.254,169.254.170.2,/var/run/docker.sock` para filtrar metadados da instância do EC2, perfis do IAM para tarefas e o tráfego do daemon do Docker proveniente do proxy.
`/etc/systemd/system/docker.service.d/http-proxy.conf` (somente Amazon Linux 2)
`Environment="HTTP_PROXY=http://10.0.0.131:3128"`
Defina este valor para o nome do host (ou endereço IP) e o número de porta de um proxy HTTP a serem usados pelo daemon do Docker para se conectar à Internet. Por exemplo, as instâncias de contêiner podem não ter acesso à rede externa através de um gateway da Internet da Amazon VPC, um gateway NAT ou uma instância.
`Environment="NO_PROXY=169.254.169.254,169.254.170.2"`
Defina este valor como `169.254.169.254,169.254.170.2` para filtrar os metadados da instância EC2 no proxy.
`/etc/sysconfig/docker` (somente AMI do Amazon Linux AMI e Amazon Linux 2)
`export HTTP_PROXY=http://10.0.0.131:3128`
Defina este valor para o nome do host (ou endereço IP) e o número de porta de um proxy HTTP a serem usados pelo daemon do Docker para se conectar à Internet. Por exemplo, as instâncias de contêiner podem não ter acesso à rede externa através de um gateway da Internet da Amazon VPC, um gateway NAT ou uma instância.
`export NO_PROXY=169.254.169.254,169.254.170.2`
Defina este valor como `169.254.169.254,169.254.170.2` para filtrar os metadados da instância EC2 no proxy.
Definir essas variáveis de ambiente nos arquivos acima só afeta o agente de contêiner do Amazon ECS, `ecs-init`, e o daemon do Docker. Elas não configuram nenhum outro serviço (como **yum**) para usar o proxy.
Para obter informações sobre como configurar o proxy, consulte [How do I set up an HTTP proxy for Docker and the Amazon ECS container agent in Amazon Linux 2 or AL2023](https://repost.aws/knowledge-center/ecs-http-proxy-docker-linux2).
# Configuração de instâncias inicializadas previamente para o grupo do Amazon ECS Auto Scaling
O Amazon ECS oferece suporte a grupos de alta atividade do Amazon EC2 Auto Scaling. Um grupo de alta atividade é um grupo de instâncias do Amazon EC2 pré-inicializadas e prontas para serem colocadas em serviço. Sempre que sua aplicação precisar sofrer aumento de escala na horizontal, o Amazon EC2 Auto Scaling usa as instâncias pré-inicializadas do grupo de alta atividade em vez de iniciar instâncias frias, permite que qualquer processo de inicialização final seja executado e, em seguida, coloca a instância em serviço.
Para saber mais sobre grupos de alta atividade e como adicionar um grupo de alta atividade ao seu grupo do Auto Scaling, consulte [Grupos de alta atividade para o Amazon EC2 Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-warm-pools.html) no *Guia do usuário do Amazon EC2 Auto Scaling*.
Ao criar ou atualizar um grupo de alta atividade para um grupo do Auto Scaling para o Amazon ECS, não é possível definir a opção que retorna instâncias para o grupo de alta atividade ao reduzir a escala horizontalmente (`ReuseOnScaleIn`). Para obter mais informações, consulte [put-warm-pool](https://docs.aws.amazon.com/cli/latest/reference/autoscaling/put-warm-pool.html) na *Referência da AWS Command Line Interface*.
Para usar grupos de alta atividade com seu cluster do Amazon ECS, defina a variável de configuração do agente `ECS_WARM_POOLS_CHECK` como `true` no campo **User data** (Dados do usuário) do seu modelo de inicialização do grupo do Amazon EC2 Auto Scaling.
A seguir há um exemplo de como a variável de configuração do agente pode ser especificada no campo **User data** (Dados do usuário) de um modelo de inicialização do Amazon EC2. Substitua *MyCluster* pelo nome do seu cluster.
```
#!/bin/bash
cat <<'EOF' >> /etc/ecs/ecs.config
ECS_CLUSTER=MyCluster
ECS_WARM_POOLS_CHECK=true
EOF
```
Só há suporte para a variável `ECS_WARM_POOLS_CHECK` nas versões `1.59.0` e posteriores do agente. Para obter mais informações sobre as variáveis, consulte [Configuração do agente de contêiner do Amazon ECS](ecs-agent-config.md).
# Atualizar o agente de contêiner do Amazon ECS
Ocasionalmente, pode ser necessário atualizar o agente de contêiner do Amazon ECS para obter correções de erros e novos recursos. A atualização do agente de contêiner do Amazon ECS não interrompe a execução das tarefas ou dos serviços na instância de contêiner. O processo de atualização do agente varia, dependendo do local em que a instância de contêiner foi iniciada, se na AMI otimizada para Amazon ECS ou em outro sistema operacional.
**nota**
As atualizações de agente não se aplicam a instâncias de contêiner do Windows. É recomendável executar novas instâncias de contêiner para atualizar a versão do agente nos clusters do Windows.
## Verificar a versão do agente de contêiner do Amazon ECS
É possível verificar a versão do agente de contêiner que está sendo executada nas instâncias de contêiner para saber se é preciso atualizá-la. A exibição da instância de contêiner no console do Amazon ECS fornece a versão do agente. Use o procedimento a seguir para verificar a versão do agente.
------
#### [ Amazon ECS console ]
1. Abra o console em [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).
1. Na barra de navegação, escolha a região em que sua instância externa está registrada.
1. No painel de navegação, escolha **Clusters** e selecione o cluster que hospeda a instância externa.
1. Na página **Cluster : *name***, escolha a guia **Infrastructure** (Infraestrutura).
1. Em **Container instances** (Instâncias de contêiner), observe a coluna **Agent version** (Versão do agente) para suas instâncias de contêiner. Se a instância de contêiner não contiver a versão mais recente do agente de contêiner, o console o alertará com uma mensagem e sinalizará a versão desatualizada do agente.
Se a sua versão do agente estiver desatualizada, será possível atualizar seu agente de contêiner com os procedimentos a seguir:
+ Se sua instância de contêiner estiver executando a AMI otimizada para o Amazon ECS, consulte [Atualizar o agente de contêiner do Amazon ECS em uma AMI otimizada para Amazon ECS](agent-update-ecs-ami.md).
+ Se sua instância de contêiner não estiver executando a AMI otimizada para o Amazon ECS, consulte [Atualizar manualmente o agente de contêiner do Amazon ECS (para AMIs não otimizadas para Amazon ECS)](manually_update_agent.md).
**Importante**
Para atualizar versões do agente do Amazon ECS anteriores à v1.0.0 na AMI otimizada para Amazon ECS, recomendamos que você encerre a instância de contêiner atual e execute uma nova instância com a versão mais recente da AMI. Todas as instâncias de contêiner que usam uma versão de pré-visualização devem ser retiradas e substituídas pela AMI mais recente. Para obter mais informações, consulte [Iniciar uma instância de contêiner do Linux do Amazon ECS](launch_container_instance.md).
------
#### [ Amazon ECS container agent introspection API ]
Também é possível usar a API de introspecção do agente de contêiner do Amazon ECS para verificar a versão do agente na própria instância de contêiner. Para obter mais informações, consulte [Introspecção de contêiner do Amazon ECS](ecs-agent-introspection.md).
**Para verificar se o agente de contêiner do Amazon ECS está executando a versão mais recente com a API de introspecção**
1. Faça login em sua instância de contêiner via SSH.
1. Consulte a API de introspecção.
```
[ec2-user ~]$ curl -s 127.0.0.1:51678/v1/metadata | python3 -mjson.tool
```
**nota**
A API de introspecção incluiu informações de `Version` na versão v1.0.0 do agente de contêiner do Amazon ECS. Se `Version` não estiver presente ao consultar a API de introspecção ou ela não estiver presente no seu agente, a versão que você está executando é v0.0.3 ou anterior. Você deve atualizar a versão.
------
# Atualizar o agente de contêiner do Amazon ECS em uma AMI otimizada para Amazon ECS
Se você estiver usando a AMI otimizada para Amazon ECS, terá várias opções para obter a versão mais recente do agente de contêiner do Amazon ECS (mostrado por ordem de recomendação):
+ Encerre as instâncias de contêiner e inicie a versão mais recente da AMI do Amazon Linux 2 otimizada para Amazon ECS (manualmente ou atualizando a configuração de execução do Auto Scaling com a AMI mais recente). O resultado será uma instância de contêiner atualizada com as versões testadas e validadas mais recentes do Amazon Linux, do Docker, do `ecs-init` e do agente de contêiner do Amazon ECS. Para obter mais informações, consulte [AMIs do Linux otimizadas para o Amazon ECS](ecs-optimized_AMI.md).
+ Conecte-se à instância com o SSH e atualize o pacote do `ecs-init` (e suas dependências) para a versão mais recente. Essa operação fornecerá as versões testadas e validadas mais recentes do Docker e do `ecs-init` que estão disponíveis nos repositórios do Amazon Linux e na versão mais recente do agente de contêiner do Amazon ECS. Para obter mais informações, consulte [Para atualizar o pacote `ecs-init` em uma AMI otimizada para o Amazon ECS](#procedure_update_ecs-init).
+ Atualize o agente de contêiner com a operação de API do `UpdateContainerAgent`, através do console ou com a AWS CLI ou os SDKs da AWS. Para obter mais informações, consulte [Atualizar o agente de contêiner do Amazon ECS com a operação de API do `UpdateContainerAgent`](#agent-update-api).
**nota**
As atualizações de agente não se aplicam a instâncias de contêiner do Windows. É recomendável executar novas instâncias de contêiner para atualizar a versão do agente nos clusters do Windows.
**Para atualizar o pacote `ecs-init` em uma AMI otimizada para o Amazon ECS**
1. Faça login em sua instância de contêiner via SSH.
1. Atualize o pacote `ecs-init` com o comando a seguir.
```
sudo yum update -y ecs-init
```
**nota**
O pacote `ecs-init` e o agente de contêiner do Amazon ECS são atualizados imediatamente. No entanto, as versões mais recentes do Docker não serão carregadas até que o daemon do Docker seja reiniciado. Inicie novamente reinicializando a instância ou executando os seguintes comandos em sua instância:
AMI do Amazon Linux 2 otimizada para Amazon ECS:
```
sudo systemctl restart docker
```
AMI do Amazon Linux otimizada para Amazon ECS:
```
sudo service docker restart && sudo start ecs
```
## Atualizar o agente de contêiner do Amazon ECS com a operação de API do `UpdateContainerAgent`
**Importante**
A API do `UpdateContainerAgent` só é compatível com variantes Linux da AMI otimizada para o Amazon ECS, com exceção da AMI do Amazon Linux 2 (arm64) otimizada para Amazon ECS. Para instâncias de contêiner que usam a AMI do Amazon Linux 2 (arm64) otimizada para Amazon ECS, atualize o pacote `ecs-init` para atualizar o agente. Para instâncias de contêiner que estão executando outros sistemas operacionais, consulte [Atualizar manualmente o agente de contêiner do Amazon ECS (para AMIs não otimizadas para Amazon ECS)](manually_update_agent.md). Se você está usando instâncias de container do Windows. recomendamos que você inicie novas instâncias de contêiner para atualizar a versão do agente nos clusters do Windows.
O processo da API do `UpdateContainerAgent` começa quando você solicita uma atualização do agente, por meio do console ou com a AWS CLI ou AWS SDKs. O Amazon ECS compara a versão atual do agente com a versão mais recente disponível e verifica se é possível realizar uma atualização. Se uma atualização não estiver disponível, por exemplo, se o agente já estiver executando a versão mais recente, um `NoUpdateAvailableException` será retornado.
Os estágios do processo de atualização mostrados acima são os seguintes:
`PENDING`
Uma atualização de agente está disponível, e o processo de atualização iniciou.
`STAGING`
O agente começou a baixar a atualização do agente. Se o agente não conseguir baixar a atualização ou se o conteúdo da atualização estiver incorreto ou corrompido, o agente enviará uma notificação da falha, e a atualização passará para o estado `FAILED`.
`STAGED`
O download do agente foi concluído e o conteúdo do agente foi verificado.
`UPDATING`
O serviço `ecs-init` é reiniciado e obtém a nova versão do agente. Se, por algum motivo, não for possível reiniciar o agente, a atualização passará para o estado `FAILED`; do contrário, o agente informará ao Amazon ECS que a atualização foi concluída.
**nota**
As atualizações de agente não se aplicam a instâncias de contêiner do Windows. É recomendável executar novas instâncias de contêiner para atualizar a versão do agente nos clusters do Windows.
**Para atualizar o agente de contêiner do Amazon ECS em uma AMI otimizada para Amazon ECS no console**
1. Abra o console em [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).
1. Na barra de navegação, escolha a região em que sua instância externa está registrada.
1. No painel de navegação, escolha **Clusters** e selecione o cluster.
1. Na página **Cluster : *name***, escolha a guia **Infrastructure** (Infraestrutura).
1. Em **Instâncias de contêiner**, selecione as instâncias a serem atualizadas e escolha **Ações**, **Agente de atualização**.
# Atualizar manualmente o agente de contêiner do Amazon ECS (para AMIs não otimizadas para Amazon ECS)
Ocasionalmente, pode ser necessário atualizar o agente de contêiner do Amazon ECS para obter correções de erros e novos recursos. A atualização do agente de contêiner do Amazon ECS não interrompe a execução das tarefas ou dos serviços na instância de contêiner.
**nota**
As atualizações de agente não se aplicam a instâncias de contêiner do Windows. É recomendável executar novas instâncias de contêiner para atualizar a versão do agente nos clusters do Windows.
1. Faça login em sua instância de contêiner via SSH.
1. Verifique se o seu agente usa a variável de ambiente `ECS_DATADIR` para salvar seu estado.
```
ubuntu:~$ docker inspect ecs-agent | grep ECS_DATADIR
```
Resultado:
```
"ECS_DATADIR=/data",
```
**Importante**
Se o comando anterior não retornar a variável de ambiente `ECS_DATADIR`, você deverá interromper todas as tarefas em execução nessa instância de contêiner antes de atualizar seu agente. Agentes mais novos com a variável de ambiente `ECS_DATADIR` salvam seu estado, e você pode atualizá-los enquanto as tarefas são executadas sem problemas.
1. Interrompa o agente de contêiner do Amazon ECS.
```
ubuntu:~$ docker stop ecs-agent
```
1. Exclua o contêiner de agente.
```
ubuntu:~$ docker rm ecs-agent
```
1. Verifique se o diretório `/etc/ecs` e o arquivo de configuração do agente de contêiner do Amazon ECS existem em `/etc/ecs/ecs.config`.
```
ubuntu:~$ sudo mkdir -p /etc/ecs && sudo touch /etc/ecs/ecs.config
```
1. Edite o arquivo `/etc/ecs/ecs.config` e verifique se ele contém pelo menos as seguintes instruções de variável. Se você não quiser que sua instância de contêiner seja registrada no cluster padrão, especifique seu nome de cluster como o valor para `ECS_CLUSTER`.
```
ECS_DATADIR=/data
ECS_ENABLE_TASK_IAM_ROLE=true
ECS_ENABLE_TASK_IAM_ROLE_NETWORK_HOST=true
ECS_LOGFILE=/log/ecs-agent.log
ECS_AVAILABLE_LOGGING_DRIVERS=["json-file","awslogs"]
ECS_LOGLEVEL=info
ECS_CLUSTER=default
```
Para obter mais informações sobre essas e outras opções de runtime de agente, consulte [Configuração do agente de contêiner do Amazon ECS](ecs-agent-config.md).
**nota**
É possível, opcionalmente, armazenar suas variáveis de ambiente do agente no Amazon S3 (que podem ser baixadas para as instâncias de contêiner no momento da inicialização usando os dados de usuário do Amazon EC2). Isso é recomendado para informações confidenciais, como credenciais de autenticação para repositórios privados. Para obter mais informações, consulte [Armazenamento da configuração da instância de contêiner do Amazon ECS no Amazon S3](ecs-config-s3.md) e [Uso de imagens de contêiner que não são da AWS no Amazon ECS](private-auth.md).
1. Extraia a imagem de agente de contêiner do Amazon ECS mais recente do Amazon Elastic Container Registry Public.
```
ubuntu:~$ docker pull public.ecr.aws/ecs/amazon-ecs-agent:latest
```
Resultado:
```
Pulling repository amazon/amazon-ecs-agent
a5a56a5e13dc: Download complete
511136ea3c5a: Download complete
9950b5d678a1: Download complete
c48ddcf21b63: Download complete
Status: Image is up to date for amazon/amazon-ecs-agent:latest
```
1. Execute o agente de contêiner do Amazon ECS mais recente na instância de contêiner.
**nota**
Use políticas de reinicialização do Docker ou um gerenciador de processos (como **upstart** ou **systemd**) para tratar o agente de contêiner como um serviço ou um daemon e garantir que ele seja reiniciado após sair. A AMI otimizada para Amazon ECS usa o RPM `ecs-init` para essa finalidade, e você pode visualizar o [código-fonte para esse RPM](https://github.com/aws/amazon-ecs-init) no GitHub.
O comando de execução de agente do exemplo a seguir é dividido em linhas separadas para mostrar cada opção. Para obter mais informações sobre essas e outras opções de runtime de agente, consulte [Configuração do agente de contêiner do Amazon ECS](ecs-agent-config.md).
**Importante**
Os sistemas operacionais com o SELinux habilitado requerem a opção `--privileged` em seu comando **docker run**. Além disso, para instâncias de contêiner habilitadas para SELinux, recomendamos que você adicione a opção `:Z` às montagens de volume `/log` e `/data`. No entanto, as montagens de host para esses volumes devem existir para que você execute o comando; caso contrário, você receberá um erro `no such file or directory`. Execute a seguinte ação se você tiver dificuldades para executar o agente do Amazon ECS em uma instância de contêiner habilitada para o SELinux:
Crie os pontos de montagem de volume de host na instância de contêiner.
```
ubuntu:~$ sudo mkdir -p /var/log/ecs /var/lib/ecs/data
```
Adicione a opção `--privileged` ao comando **docker run** abaixo.
Anexe a opção `:Z` às montagens de volume de contêiner `/log` e `/data` (por exemplo, `--volume=/var/log/ecs/:/log:Z`) ao comando **docker run** abaixo.
```
ubuntu:~$ sudo docker run --name ecs-agent \
--detach=true \
--restart=on-failure:10 \
--volume=/var/run:/var/run \
--volume=/var/log/ecs/:/log \
--volume=/var/lib/ecs/data:/data \
--volume=/etc/ecs:/etc/ecs \
--volume=/etc/ecs:/etc/ecs/pki \
--net=host \
--env-file=/etc/ecs/ecs.config \
amazon/amazon-ecs-agent:latest
```
**nota**
Se você receber uma mensagem `Error response from daemon: Cannot start container`, poderá excluir o contêiner com falha com o comando **sudo docker rm ecs-agent** e tentar executar o comando novamente.