# Definições de tarefa do Amazon ECS para workloads de GPU
O Amazon ECS é compatível com workloads que utilizam GPUs quando você cria clusters com instâncias de contêiner compatíveis com GPU. As instâncias de contêiner baseadas em GPU do Amazon EC2 que usam os tipos de instância p2, p3, p5, g3, g4 e g5 fornecem acesso a GPUs NVIDIA. Para obter mais informações, consulte [Instâncias com computação acelerada do Linux](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html) no *Guia de tipos de instância do Amazon EC2*.
O Amazon ECS fornece uma AMI otimizada para GPU que é fornecida com drivers de kernel NVIDIA pré-configurados e um runtime de GPU do Docker. Para obter mais informações, consulte [AMIs do Linux otimizadas para o Amazon ECS](ecs-optimized_AMI.md).
É possível designar várias GPUs na sua definição de tarefa para consideração do posicionamento de tarefas em um nível de contêiner. O Amazon ECS programa instâncias de contêineres disponíveis compatíveis com GPU, atribuindo GPUs físicas a contêineres adequados para proporcionar a performance ideal.
Os seguintes tipos de instância do Amazon EC2 baseados em GPU são compatíveis. Para obter mais informações, consulte [Instâncias P2 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/p2/), [Instâncias P3 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/p3/), [Instâncias P4d do Amazon EC2](https://aws.amazon.com/ec2/instance-types/p4/), [Instâncias P5 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/p5/), [Instâncias G3 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/g3/), [Instâncias G4 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/g4/), [Instâncias G5 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/g5/), [Instâncias G6 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/g6/) e [Instâncias G6e do Amazon EC2](https://aws.amazon.com/ec2/instance-types/g6e/).
| Tipo de instância | GPUs | Memória da GPU (GiB) | vCPUs | Memória (GiB) |
| --- | --- | --- | --- | --- |
| p3.2xlarge | 1 | 16 | 8 | 61 |
| p3.8xlarge | 4 | 64 | 32 | 244 |
| p3.16xlarge | 8 | 128 | 64 | 488 |
| p3dn.24xlarge | 8 | 256 | 96 | 768 |
| p4d.24xlarge | 8 | 320 | 96 | 1152 |
| p5.48xlarge | 8 | 640 | 192 | 2048 |
| g3s.xlarge | 1 | 8 | 4 | 30.5 |
| g3.4xlarge | 1 | 8 | 16 | 122 |
| g3.8xlarge | 2 | 16 | 32 | 244 |
| g3.16xlarge | 4 | 32 | 64 | 488 |
| g4dn.xlarge | 1 | 16 | 4 | 16 |
| g4dn.2xlarge | 1 | 16 | 8 | 32 |
| g4dn.4xlarge | 1 | 16 | 16 | 64 |
| g4dn.8xlarge | 1 | 16 | 32 | 128 |
| g4dn.12xlarge | 4 | 64 | 48 | 192 |
| g4dn.16xlarge | 1 | 16 | 64 | 256 |
| g5.xlarge | 1 | 24 | 4 | 16 |
| g5.2xlarge | 1 | 24 | 8 | 32 |
| g5.4xlarge | 1 | 24 | 16 | 64 |
| g5.8xlarge | 1 | 24 | 32 | 128 |
| g5.16xlarge | 1 | 24 | 64 | 256 |
| g5.12xlarge | 4 | 96 | 48 | 192 |
| g5.24xlarge | 4 | 96 | 96 | 384 |
| g5.48xlarge | 8 | 192 | 192 | 768 |
| g6.xlarge | 1 | 24 | 4 | 16 |
| g6.2xlarge | 1 | 24 | 8 | 32 |
| g6.4xlarge | 1 | 24 | 16 | 64 |
| g6.8xlarge | 1 | 24 | 32 | 128 |
| g6.16.xlarge | 1 | 24 | 64 | 256 |
| g6.12xlarge | 4 | 96 | 48 | 192 |
| g6.24xlarge | 4 | 96 | 96 | 384 |
| g6.48xlarge | 8 | 192 | 192 | 768 |
| g6.metal | 8 | 192 | 192 | 768 |
| gr6.4xlarge | 1 | 24 | 16 | 128 |
| g6e.xlarge | 1 | 48 | 4 | 32 |
| g6e.2xlarge | 1 | 48 | 8 | 64 |
| g6e.4xlarge | 1 | 48 | 16 | 128 |
| g6e.8xlarge | 1 | 48 | 32 | 256 |
| g6e16.xlarge | 1 | 48 | 64 | 512 |
| g6e12.xlarge | 4 | 192 | 48 | 384 |
| g6e24.xlarge | 4 | 192 | 96 | 768 |
| g6e48.xlarge | 8 | 384 | 192 | 1536 |
| gr6.8xlarge | 1 | 24 | 32 | 256 |
É possível recuperar o ID da imagem de máquina da Amazon (AMI) para AMIs otimizadas para o Amazon ECS consultando a API Parameter Store do AWS Systems Manager. Ao usar esse parâmetro, não será necessário pesquisar manualmente IDs de AMIs otimizadas para o Amazon ECS. Para obter mais informações sobre a API Systems Manager Parameter Store, consulte [GetParameter](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html). O usuário que você usou deve ter a permissão `ssm:GetParameter` do IAM para recuperar os metadados da AMI otimizada para o Amazon ECS.
```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
```
# Usar GPUs com instâncias gerenciadas do Amazon ECS
As instâncias gerenciadas do Amazon ECS oferecem suporte à computação acelerada por GPU para workloads como machine learning, computação de alta performance e processamento de vídeo por meio dos tipos de instância a seguir do Amazon EC2. Para obter mais informações sobre os tipos de instância compatíveis com as instâncias gerenciadas do Amazon ECS, consulte [Tipos de instâncias gerenciadas do Amazon ECS](managed-instances-instance-types.md).
Este é um subconjunto dos tipos de instância baseados em GPU compatíveis com as instâncias gerenciadas do Amazon ECS:
+ `g4dn`: desenvolvido com NVIDIA T4 GPUs, adequado para inferência de machine learning, visão computacional e aplicações com uso intensivo de gráficos.
+ `g5`: desenvolvido com NVIDIA A10G GPUs, oferecendo maior performance para aplicações com uso intensivo de gráficos e workloads de machine learning.
+ `p3`: desenvolvido com NVIDIA V100 GPUs, projetado para computação de alta performance e treinamento em aprendizado profundo.
+ `p4d`: desenvolvido com NVIDIA A100 GPUs, oferecendo a mais alta performance para treinamento em machine learning e computação de alta performance.
Quando você usa tipos de instância habilitados para GPU com instâncias gerenciadas do Amazon ECS, os drivers NVIDIA e o kit de ferramentas CUDA são pré-instalados na instância, facilitando a execução de workloads aceleradas por GPU.
## Seleção de instância habilitada para GPU
Para selecionar tipos de instância habilitados para GPU para suas workloads de instâncias gerenciadas do Amazon ECS, use o objeto `instanceRequirements` no modelo de inicialização do provedor de capacidade. O trecho a seguir mostra os atributos que podem ser usados para selecionar instâncias habilitadas para GPU.
```
{
"instanceRequirements": {
"acceleratorTypes": "gpu",
"acceleratorCount": 1,
"acceleratorManufacturers": ["nvidia"]
}
}
```
O trecho a seguir mostra os atributos que podem ser usados para especificar tipos de instância habilitados para GPU no modelo de inicialização.
```
{
"instanceRequirements": {
"allowedInstanceTypes": ["g4dn.xlarge", "p4de.24xlarge"]
}
}
```
## Imagens de contêiner habilitado para GPU
Para usar GPUs em seus contêineres, você precisa usar imagens de contêiner que tenham as bibliotecas e ferramentas de GPU necessárias. A NVIDIA fornece várias imagens de contêiner pré-criadas que você pode usar como base para suas workloads de GPU, incluindo as seguintes:
+ `nvidia:cuda`: imagens básicas com o kit de ferramentas CUDA para computação em GPU.
+ `tensorflow/tensorflow:latest-gpu`: TensorFlow com suporte de GPU.
+ `pytorch/pytorch:latest-cuda`: PyTorch com suporte de GPU.
Para obter um exemplo de definição de tarefa para o Amazon ECS em instâncias gerenciadas do Amazon ECS que envolve o uso de GPUs, consulte [Especificar GPUs em uma definição de tarefa do Amazon ECS](ecs-gpu-specifying.md).
## Considerações
**nota**
O suporte para o tipo de família de instâncias g2 foi descontinuado.
Há suporte para o tipo da família de instâncias p2 somente em versões anteriores à `20230912` da AMI otimizada para GPU do Amazon ECS. Se você precisar continuar usando instâncias p2, consulte [O que fazer se você precisar de uma instância P2](#p2-instance).
As atualizações locais dos drivers NVIDIA/CUDA nesses dois tipos de família de instâncias causarão possíveis falhas na workload da GPU.
Convém considerar as observações a seguir antes de iniciar o trabalho com GPUs no Amazon ECS.
+ Seus clusters podem conter uma combinação de instâncias de contêiner de GPU e não GPU.
+ É possível executar workloads de GPU em instâncias externas. Ao registrar uma instância externa no cluster, certifique-se de que o sinalizador `--enable-gpu` esteja incluído no script de instalação. Para obter mais informações, consulte [Registro de uma instância externa para um cluster do Amazon ECS](ecs-anywhere-registration.md).
+ É necessário definir `ECS_ENABLE_GPU_SUPPORT` como `true` no seu arquivo de configuração do agente. Para obter mais informações, consulte [Configuração do agente de contêiner do Amazon ECS](ecs-agent-config.md).
+ Ao executar uma tarefa ou criar um serviço, você pode usar atributos de tipo de instância ao configurar restrições de posicionamento de tarefas para determinar em quais instâncias de contêiner a tarefa deve ser inicada. Ao fazer isso, você pode usar seus recursos com mais eficiência. Para obter mais informações, consulte [Como o Amazon ECS posiciona tarefas em instâncias de contêineres](task-placement.md).
O exemplo a seguir executa uma tarefa em uma instância de contêiner `g4dn.xlarge` em seu cluster padrão.
```
aws ecs run-task --cluster default --task-definition ecs-gpu-task-def \
--placement-constraints type=memberOf,expression="attribute:ecs.instance-type == g4dn.xlarge" --region us-east-2
```
+ Para cada contêiner que tenha um requisito de recurso de GPU especificado na definição do contêiner, o Amazon ECS define o runtime do contêiner como o runtime do contêiner NVIDIA.
+ O runtime do contêiner NVIDIA requer que algumas variáveis de ambiente sejam definidas no contêiner para funcionar corretamente. Para obter uma lista dessas variáveis de ambiente, consulte [Specialized Configurations with Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html?highlight=environment%20variable). O Amazon ECS define o valor da variável de ambiente `NVIDIA_VISIBLE_DEVICES` como uma lista dos IDs de dispositivo de GPU que o Amazon ECS atribui ao contêiner. O Amazon ECS não define as outras variáveis de ambiente necessárias. Por isso, certifique-se de que a imagem de contêiner as defina ou que elas sejam especificadas na definição de contêiner.
+ A família de tipos de instância p5 tem suporte na versão `20230929` e posterior da AMI otimizada para GPU do Amazon ECS.
+ A família de tipos de instância g4 tem suporte na versão `20230913` e posterior da AMI otimizada para GPU do Amazon ECS. Para obter mais informações, consulte [AMIs do Linux otimizadas para o Amazon ECS](ecs-optimized_AMI.md). Ela é compatível com o fluxo de trabalho Create Cluster (Criar cluster) no console do Amazon ECS. Para usar esses tipos de instância, é necessário usar o console do Amazon EC2, a AWS CLI ou a API e registrar manualmente as instâncias no cluster.
+ O tipo de instância p4d.24xlarge só funciona com CUDA 11 ou posterior.
+ A AMI otimizada para GPU do Amazon ECS tem IPv6 habilitado, o que causa problemas ao usar `yum`. Isso pode ser resolvido configurando `yum` para usar o IPv4 com o seguinte comando.
```
echo "ip_resolve=4" >> /etc/yum.conf
```
+ Quando você criar uma imagem de contêiner que não usa as imagens de base NVIDIA/CUDA, deverá definir a variável do runtime do contêiner `NVIDIA_DRIVER_CAPABILITIES` em um dos seguintes valores:
+ `utility,compute`
+ `all`
Para obter informações sobre como definir a variável, consulte [Controlar o runtime do contêiner NVIDIA](https://sarus.readthedocs.io/en/stable/user/custom-cuda-images.html#controlling-the-nvidia-container-runtime) no site da NVIDIA.
+ Não há suporte para GPUs em contêineres do Windows.
# Iniciar uma instância de contêiner de GPU para o Amazon ECS
Para usar uma instância de GPU no Amazon ECS no Amazon EC2, você precisa criar um modelo de inicialização, um arquivo de dados do usuário e inicializar a instância.
Em seguida, você pode executar uma tarefa que usa uma definição de tarefa configurada para GPU.
## Usar um modelo de execução
Você pode criar um modelo de execução.
+ Crie um modelo de execução que use o ID da AMI de GPU otimizada para o Amazon ECS para a AMI. Para obter informações sobre como criar um modelo de inicialização, consulte [Criar um novo modelo de inicialização usando parâmetros definidos por você](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#create-launch-template-define-parameters) no *Manual do usuário do Amazon EC2*.
Use o ID da AMI da etapa anterior na **Imagem da máquina da Amazon**. Para obter informações sobre como especificar o ID da AMI com o parâmetro do Systems Manager, consulte [Especificar um parâmetro do Systems Manager em um modelo de inicialização](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#use-an-ssm-parameter-instead-of-an-ami-id) no *Manual do usuário do Amazon EC2*.
Adicione os itens a seguir aos **Dados do usuário** no modelo de execução. Substitua *cluster-name* pelo nome do seu cluster.
```
#!/bin/bash
echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
```
## Usar a AWS CLI
É possível executar uma instância de contêiner usando a AWS CLI.
1. Crie um arquivo chamado `userdata.toml`. Esse arquivo será usado para dados do usuário da instância. Substitua *cluster-name* pelo nome do seu cluster.
```
#!/bin/bash
echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
```
1. Execute o comando a seguir para obter o ID da AMI de GPU. Você usará isso na etapa a seguir.
```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
```
1. Execute o comando a seguir para executar a instância de GPU. Lembre-se de substituir os parâmetros a seguir:
+ Substitua *sub-rede* pelo ID da sub-rede pública ou privada na qual sua instância será iniciada.
+ Substitua *gpu\$1ami* pelo ID da AMI da etapa anterior.
+ Substitua *t3.large* pelo tipo de instância que você deseja usar.
+ Substitua *região* pelo código da região.
```
aws ec2 run-instances --key-name ecs-gpu-example \
--subnet-id subnet \
--image-id gpu_ami \
--instance-type t3.large \
--region region \
--tag-specifications 'ResourceType=instance,Tags=[{Key=GPU,Value=example}]' \
--user-data file://userdata.toml \
--iam-instance-profile Name=ecsInstanceRole
```
1. Execute o comando a seguir para verificar se a instância de contêiner está registrada no cluster. Ao executar esse comando, lembre-se de substituir os parâmetros a seguir:
+ Substitua *cluster* pelo nome do seu cluster.
+ Substitua *região* pelo código da sua região.
```
aws ecs list-container-instances --cluster cluster-name --region region
```
# Especificar GPUs em uma definição de tarefa do Amazon ECS
Para usar as GPUs em uma instância de contêiner e o runtime da GPU do Docker, certifique-se de designar, na definição de tarefa, o número de GPUs que o seu contêiner requer. O agente de contêiner do Amazon ECS atribui o número desejado de GPUs físicas ao contêiner adequado conforme os contêineres compatíveis com GPU são posicionados. O número de GPUs reservadas para todos os contêineres em uma tarefa não deve exceder o número de GPUs disponíveis na instância de contêiner na qual a tarefa é executada. Para obter mais informações, consulte [Criar uma definição de tarefa do Amazon ECS usando o console](create-task-definition.md).
**Importante**
Se seus requisitos de GPU não forem especificados na definição de tarefa, a tarefa usará o runtime padrão do Docker.
Veja a seguir o formato JSON para os requisitos de GPU em uma definição de tarefa.
```
{
"containerDefinitions": [
{
...
"resourceRequirements" : [
{
"type" : "GPU",
"value" : "2"
}
],
},
...
}
```
O exemplo a seguir demonstra a sintaxe para um contêiner do Docker que especifica um requisito de GPU. Esse contêiner usa duas GPUs, executa o utilitário `nvidia-smi` e, em seguida, é encerrado.
```
{
"containerDefinitions": [
{
"memory": 80,
"essential": true,
"name": "gpu",
"image": "nvidia/cuda:11.0.3-base",
"resourceRequirements": [
{
"type":"GPU",
"value": "2"
}
],
"command": [
"sh",
"-c",
"nvidia-smi"
],
"cpu": 100
}
],
"family": "example-ecs-gpu"
}
```
O exemplo de definição de tarefa a seguir mostra um contêiner TensorFlow que imprime o número de GPUs disponíveis. A tarefa é executada em instâncias gerenciadas do Amazon ECS, exige uma GPU e usa uma instância `g4dn.xlarge`.
```
{
"family": "tensorflow-gpu",
"networkMode": "awsvpc",
"executionRoleArn": "arn:aws:iam::account-id:role/ecsTaskExecutionRole",
"containerDefinitions": [
{
"name": "tensorflow",
"image": "tensorflow/tensorflow:latest-gpu",
"essential": true,
"command": [
"python",
"-c",
"import tensorflow as tf; print('Num GPUs Available: ', len(tf.config.list_physical_devices('GPU')))"
],
"resourceRequirements": [
{
"type": "GPU",
"value": "1"
}
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/tensorflow-gpu",
"awslogs-region": "region",
"awslogs-stream-prefix": "ecs"
}
}
}
],
"requiresCompatibilities": [
"MANAGED_INSTANCES"
],
"cpu": "4096",
"memory": "8192",
}
```
## Compartilhar GPUs
Para compartilhar GPUs, você precisará configurar as opções a seguir.
1. Remova os requisitos de recursos de GPU das suas definições de tarefas para que o Amazon ECS não reserve nenhuma GPU que deveria ser compartilhada.
1. Adicione os dados de usuário a seguir às suas instâncias quando desejar compartilhar GPUs. Isso tornará nvidia o runtime padrão do contêiner do Docker na instância do contêiner para que todos os contêineres do Amazon ECS possam usar as GPUs. Para obter mais informações, consulte [Executar comandos ao executar uma instância do EC2 com entrada de dados do usuário](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) no *Guia do usuário do Amazon EC2*.
```
const userData = ec2.UserData.forLinux();
userData.addCommands(
'sudo rm /etc/sysconfig/docker',
'echo DAEMON_MAXFILES=1048576 | sudo tee -a /etc/sysconfig/docker',
'echo OPTIONS="--default-ulimit nofile=32768:65536 --default-runtime nvidia" | sudo tee -a /etc/sysconfig/docker',
'echo DAEMON_PIDFILE_TIMEOUT=10 | sudo tee -a /etc/sysconfig/docker',
'sudo systemctl restart docker',
);
```
1. Defina a variável de ambiente `NVIDIA_VISIBLE_DEVICES` em seu contêiner. Você pode fazer isso especificando a variável de ambiente na definição da sua tarefa. Para obter informações sobre os valores válidos, consulte [Enumeração de GPUs](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html#gpu-enumeration) no site de documentação da NVIDIA.
## O que fazer se você precisar de uma instância P2
Se você precisar usar a instância P2, poderá usar uma das opções a seguir para continuar usando as instâncias.
Será preciso modificar os dados do usuário da instância para ambas as opções. Para obter mais informações, consulte [Executar comandos ao executar uma instância do EC2 com entrada de dados do usuário](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) no *Guia do usuário do Amazon EC2*.
**Use a última AMI otimizada para GPU com suporte**
É possível usar a versão `20230906` da AMI otimizada para GPU e adicionar o seguinte aos dados do usuário da instância.
Substitua cluster-name pelo nome do seu cluster.
```
#!/bin/bash
echo "exclude=*nvidia* *cuda*" >> /etc/yum.conf
echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
```
**Use a AMI otimizada para GPU mais recente e atualize os dados do usuário**
É possível adicionar o seguinte aos dados do usuário da instância. Isso desinstala os drivers Nvidia 535/Cuda12.2 e, em seguida, instala os drivers Nvidia 470/Cuda11.4 e corrige a versão.
```
#!/bin/bash
yum remove -y cuda-toolkit* nvidia-driver-latest-dkms*
tmpfile=$(mktemp)
cat >$tmpfile <> /etc/yum.conf
nvidia-smi
```
**Criar sua própria AMI otimizada para GPU compatível com P2**
É possível criar sua própria AMI personalizada otimizada para GPU do Amazon ECS que seja compatível com instâncias P2 e, em seguida, executar instâncias P2 usando a AMI.
1. Execute o comando a seguir para clonar a `amazon-ecs-ami repo`.
```
git clone https://github.com/aws/amazon-ecs-ami
```
1. Defina o agente do Amazon ECS necessário e as versões de origem do Amazon Linux AMI em `release.auto.pkrvars.hcl` ou `overrides.auto.pkrvars.hcl`.
1. Execute o comando a seguir para criar uma AMI do EC2 privada compatível com P2.
Substitua região pela Região com a instância Região.
```
REGION=region make al2keplergpu
```
1. Use a AMI com os dados de usuário da instância a seguir para se conectar ao cluster do Amazon ECS.
Substitua cluster-name pelo nome do seu cluster.
```
#!/bin/bash
echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
```