As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Introdução ao Fargate AWS Batch e ao Fargate usando o AWS CLI
Este tutorial demonstra como configurar AWS Batch com AWS Fargate orquestração e executar uma tarefa simples “Hello World” usando o AWS Command Line Interface ().AWS CLI Você aprenderá como criar ambientes computacionais, filas de trabalho, definições de trabalhos e enviar trabalhos para o AWS Batch.
**Topics**
+ [Pré-requisitos](#prerequisites)
+ [Criar um perfil de execução do IAM](#tutorial-fargate-using-the-aws-cli-create-an-iam-execution-role)
+ [Crie um ambiente de computação](#create-a-compute-environment)
+ [Crie uma fila de trabalhos](#cli-create-a-job-queue)
+ [Crie uma definição de trabalho](#cli-create-a-job-definition)
+ [Enviar e monitorar um trabalho](#cli-submit-and-monitor-a-job)
+ [Ver a saída de trabalho](#cli-view-job-output)
+ [Limpar os recursos](#cli-clean-up-resources)
+ [Transição para o ambiente de produção](#cli-going-to-production)
+ [Próximas etapas](#cli-next-steps)
## Pré-requisitos
Antes de iniciar este tutorial, certifique-se de ter o seguinte.
1. AWS CLI A. Caso ainda seja necessário instalá-la, consulte o [guia de instalação da AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html). Você também pode [usar AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html), o que inclui AWS CLI o.
1. Configurei seu AWS CLI com as credenciais apropriadas. Caso ainda não tenha realizado a configuração das credenciais, execute o comando `aws configure`.
1. Familiaridade básica com interfaces de linha de comando e conceitos de conteinerização.
1. [Como AWS Batch funciona com o IAM](security_iam_service-with-iam.md)para criar e gerenciar AWS Batch recursos, funções do IAM e recursos de VPC em seu. Conta da AWS
1. Um ID de sub-rede e um ID de grupo de segurança de uma VPC em seu. Conta da AWS Caso não tenha uma VPC, você pode [criar uma](https://docs.aws.amazon.com/vpc/latest/userguide/create-vpc.html). *Para obter mais informações sobre como usar o AWS CLI para recuperar esses recursos IDs, consulte [describe-subnets](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-subnets.html) e na Referência de Comandos. [describe-security-groups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/ec2/describe-security-groups.html)AWS CLI *
**Tempo necessário**: aproximadamente 15 a 20 minutos para concluir este tutorial.
**Custo**: este tutorial usa os recursos computacionais do Fargate. O custo estimado para concluir este tutorial é inferior a 0,01 USD, supondo que você siga as instruções de limpeza para excluir recursos imediatamente após a conclusão. O preço do Fargate é baseado nos recursos de vCPU e memória consumidos, cobrados por segundo com um mínimo de 1 minuto. Para obter informações atuais sobre a definição de preço, consulte [Preços do AWS Fargate](https://aws.amazon.com/fargate/pricing/).
## Criar um perfil de execução do IAM
AWS Batch requer uma função de execução que permita que agentes do Amazon Elastic Container Service (Amazon ECS) AWS façam chamadas de API em seu nome. Essa função é necessária para que as tarefas do Fargate extraiam imagens de contêineres e gravem registros na Amazon. CloudWatch
**Criar um documento de política de confiança**
Primeiro, crie uma política de confiança para permitir que o serviço de tarefas do Amazon ECS assuma o perfil.
```
cat > batch-execution-role-trust-policy.json << EOF
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "ecs-tasks.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
EOF
```
**Crie a função de execução**
O comando a seguir cria um perfil do IAM chamado `BatchEcsTaskExecutionRoleTutorial` usando a política de confiança que você acabou de criar.
```
aws iam create-role \
--role-name BatchEcsTaskExecutionRoleTutorial \
--assume-role-policy-document file://batch-execution-role-trust-policy.json
```
**Anexe a política necessária**
Anexe a política AWS gerenciada que fornece as permissões necessárias para a execução de tarefas do Amazon ECS.
```
aws iam attach-role-policy \
--role-name BatchEcsTaskExecutionRoleTutorial \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
```
A função agora está pronta para ser usada na execução de AWS Batch tarefas do Fargate.
## Crie um ambiente de computação
Um ambiente computacional define os recursos computacionais nos quais seus trabalhos em lotes serão executados. Neste tutorial, você criará um ambiente computacional Fargate gerenciado que provisiona e dimensiona automaticamente os recursos com base nos requisitos do trabalho.
**Criar o ambiente de computação**
O comando a seguir cria um ambiente computacional Fargate. Substitua o exemplo de sub-rede e grupo de segurança pelo seu próprio, de acordo IDs com o. [Pré-requisitos](#prerequisites)
```
aws batch create-compute-environment \
--compute-environment-name my-fargate-compute-env \
--type MANAGED \
--state ENABLED \
--compute-resources type=FARGATE,maxvCpus=128,subnets={{subnet-a123456b}},securityGroupIds={{sg-a12b3456}}
```
O exemplo a seguir mostra a aparência da saída quando o comando é executado com sucesso.
```
{
"computeEnvironmentName": "my-fargate-compute-env",
"computeEnvironmentArn": "arn:aws:batch:us-west-2:123456789012:compute-environment/my-fargate-compute-env"
}
```
**Aguarde até que o ambiente computacional esteja pronto**
Verifique o status do seu ambiente computacional para garantir que ele esteja pronto antes de continuar.
```
aws batch describe-compute-environments \
--compute-environments my-fargate-compute-env \
--query 'computeEnvironments[0].status'
```
```
"VALID"
```
Quando o status é exibido como `VALID`, seu ambiente computacional está pronto para aceitar trabalhos.
## Crie uma fila de trabalhos
Uma fila de trabalhos armazena os trabalhos enviados até que o AWS Batch agendador os execute em recursos em seu ambiente computacional. Os trabalhos são processados em ordem de prioridade na fila.
**Criar a fila de trabalhos**
O comando a seguir cria uma fila de trabalhos com prioridade 900 que usa seu ambiente computacional Fargate.
```
aws batch create-job-queue \
--job-queue-name my-fargate-job-queue \
--state ENABLED \
--priority 900 \
--compute-environment-order order=1,computeEnvironment=my-fargate-compute-env
```
O exemplo a seguir mostra a aparência da saída quando o comando é executado com sucesso.
```
{
"jobQueueName": "my-fargate-job-queue",
"jobQueueArn": "arn:aws:batch:us-west-2:123456789012:job-queue/my-fargate-job-queue"
}
```
**Verificar se a fila de trabalhos está pronta**
Verifique se sua fila de trabalhos está no estado `ENABLED` e pronta para aceitar trabalhos.
```
aws batch describe-job-queues \
--job-queues my-fargate-job-queue \
--query 'jobQueues[0].state' "ENABLED"
```
## Crie uma definição de trabalho
As definições de trabalhos especificam como os trabalhos devem ser executados, incluindo a imagem do Docker a ser usada, requisitos de recursos e outros parâmetros. Para o Fargate, você usará os requisitos de recursos em vez dos parâmetros tradicionais de vCPU e memória.
**Criar a definição de trabalho**
O comando a seguir cria uma definição de trabalho que executa um comando simples “hello world” usando a imagem do contêiner busybox. `123456789012`Substitua pelo seu Conta da AWS ID real e substitua o exemplo Região da AWS pelo seu.
```
aws batch register-job-definition \
--job-definition-name my-fargate-job-def \
--type container \
--platform-capabilities FARGATE \
--container-properties '{
"image": "busybox",
"resourceRequirements": [
{"type": "VCPU", "value": "0.25"},
{"type": "MEMORY", "value": "512"}
],
"command": ["echo", "hello world"],
"networkConfiguration": {
"assignPublicIp": "ENABLED"
},
"executionRoleArn": "arn:aws:iam::{{123456789012}}:role/BatchEcsTaskExecutionRoleTutorial"
},
{
"jobDefinitionName": "my-fargate-job-def",
"jobDefinitionArn": "arn:aws:batch:{{us-west-2}}:{{123456789012}}:job-definition/my-fargate-job-def:1",
"revision": 1
}'
```
A definição do trabalho especifica 0.25 vCPU e 512 MB de memória, que são os recursos mínimos para uma tarefa do Fargate. A configuração `assignPublicIp` está ativada para que o contêiner possa extrair a imagem do busybox do Docker Hub.
## Enviar e monitorar um trabalho
Agora que você tem todos os componentes necessários, você pode enviar um trabalho para a fila e monitorar seu progresso.
**Envie um trabalho**
O comando a seguir envia um trabalho para sua fila usando a definição de trabalho que você criou.
```
aws batch submit-job \
--job-name my-hello-world-job \
--job-queue my-fargate-job-queue \
--job-definition my-fargate-job-def
```
O exemplo a seguir mostra a aparência da saída quando o comando é executado com sucesso.
```
{
"jobArn": "arn:aws:batch:us-west-2:123456789012:job/my-hello-world-job",
"jobName": "my-hello-world-job",
"jobId": "1509xmpl-4224-4da6-9ba9-1d1acc96431a"
}
```
Anote o `jobId` que retornou na resposta, pois você o usará para monitorar o progresso do trabalho.
**Monitorar o status do trabalho**
Use o ID do trabalho para verificar o status do trabalho. O trabalho progredirá em vários estados: `SUBMITTED`, `PENDING`, `RUNNABLE`, `STARTING`, `RUNNING` e, finalmente, `SUCCEEDED` ou `FAILED`.
```
aws batch describe-jobs --jobs 1509xmpl-4224-4da6-9ba9-1d1acc96431a
```
O exemplo a seguir mostra a aparência da saída quando o comando é executado com sucesso.
```
{
"jobs": [
{
"jobArn": "arn:aws:batch:{{us-west-2}}:{{123456789012}}:job/my-hello-world-job",
"jobName": "my-hello-world-job",
"jobId": "1509xmpl-4224-4da6-9ba9-1d1acc96431a",
"jobQueue": "arn:aws:batch:{{us-west-2}}:{{123456789012}}:job-queue/my-fargate-job-queue",
"status": "SUCCEEDED",
"createdAt": 1705161908000,
"jobDefinition": "arn:aws:batch:{{us-west-2}}:{{123456789012}}:job-definition/my-fargate-job-def:1"
}
]
}
```
Quando o status for exibido como `SUCCEEDED`, seu trabalho foi concluído com sucesso.
## Ver a saída de trabalho
Depois que seu trabalho for concluído, você poderá visualizar sua saída no Amazon CloudWatch Logs.
**Obter o nome do fluxo de logs**
Primeiro, recupere o nome do fluxo de log a partir dos detalhes do trabalho. Substitua o ID de trabalho de exemplo por seu próprio.
```
aws batch describe-jobs --jobs {{1509xmpl-4224-4da6-9ba9-1d1acc96431a}} \
--query 'jobs[0].attempts[0].containers[0].logStreamName' \
--output text
```
```
my-fargate-job-def/default/1509xmpl-4224-4da6-9ba9-1d1acc96431a
```
**Ver os logs de trabalho**
Use o nome do fluxo de registros para recuperar a saída do trabalho em CloudWatch Logs.
```
aws logs get-log-events \
--log-group-name /aws/batch/job \
--log-stream-name my-fargate-job-def/default/{{1509xmpl-4224-4da6-9ba9-1d1acc96431a}} \
--query 'events[*].message' \
--output text
```
A saída mostra “hello world”, confirmando que seu trabalho foi executado com sucesso.
## Limpar os recursos
Para evitar cobranças contínuas, limpe os recursos que você criou neste tutorial. Você deve excluir os recursos na ordem correta devido às dependências.
**Desativar e excluir a fila de trabalhos**
Primeiro, desative a fila de trabalhos e, em seguida, exclua-a.
```
aws batch update-job-queue \
--job-queue my-fargate-job-queue \
--state DISABLED
```
```
aws batch delete-job-queue \
--job-queue my-fargate-job-queue
```
**Desativar e excluir o ambiente computacional**
Depois que a fila de trabalhos for excluída, desative e exclua o ambiente computacional.
```
aws batch update-compute-environment \
--compute-environment my-fargate-compute-env \
--state DISABLED
```
```
aws batch delete-compute-environment \
--compute-environment my-fargate-compute-env
```
**Limpar o perfil do IAM**
Remova o anexo da política e exclua a perfil do IAM.
```
aws iam detach-role-policy \
--role-name BatchEcsTaskExecutionRoleTutorial \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
```
```
aws iam delete-role \
--role-name BatchEcsTaskExecutionRoleTutorial
```
**Remover arquivos temporários**
Exclua o arquivo de política de confiança que você criou.
```
rm batch-execution-role-trust-policy.json
```
Todos os recursos foram limpos com sucesso.
## Transição para o ambiente de produção
Este tutorial foi desenvolvido para ajudar você a entender como AWS Batch funciona com o Fargate. Em implantações de produção, considere os seguintes requisitos adicionais:
**Considerações sobre segurança:**
+ Criar grupos de segurança dedicados com o mínimo de acesso necessário em vez de usar grupos de segurança padrão
+ Usar sub-redes privadas com o NAT Gateway em vez da atribuição de IP público para contêineres
+ Armazenar imagens de contêiner no Amazon ECR em vez de usar repositórios públicos
+ Implemente endpoints VPC para comunicação de AWS serviços a fim de evitar tráfego na Internet
**Considerações sobre a arquitetura:**
+ Implementar em várias zonas de disponibilidade para alta disponibilidade
+ Implementar estratégias de repetição de trabalhos e filas de mensagens não entregues para lidar com erros
+ Usar várias filas de trabalhos com prioridades diferentes para o gerenciamento do workload
+ Configurar políticas de ajuste de escala automático com base na profundidade da fila e na utilização de recursos
+ Implementar monitoramento e alertas sobre falhas no trabalho e utilização de recursos
**Considerações operacionais:**
+ Configure CloudWatch painéis e alarmes para monitoramento
+ Implementar trilhas de auditoria e registro em log adequadas
+ Use CloudFormation ou AWS CDK para infraestrutura como código
+ Estabelecer procedimentos de backup e recuperação de desastres
Para obter uma orientação abrangente sobre arquiteturas prontas para produção, consulte a [Estrutura bem-arquitetada AWS](https://aws.amazon.com/architecture/well-architected/) e as [Práticas recomendadas de segurança AWS](https://aws.amazon.com/architecture/security-identity-compliance/).
## Próximas etapas
Agora que você concluiu este tutorial, você pode explorar AWS Batch recursos mais avançados:
+ [Filas de tarefas](job_queues.md) — Saiba mais sobre agendamento de filas de trabalhos e gerenciamento de prioridades
+ [Definições de trabalho](job_definitions.md) — Explore configurações avançadas de definição de trabalhos, incluindo variáveis de ambiente, volumes e estratégias de repetição
+ [Ambientes computacionais para AWS Batch](compute_environments.md) — Entenda os diferentes tipos de ambientes computacionais e opções de escalabilidade
+ [Multi-node trabalhos paralelos](multi-node-parallel-jobs.md) — Execute trabalhos que abrangem vários nós de computação
+ [Trabalhos de matriz](array_jobs.md) — Envie um grande número de trabalhos similares de forma eficiente
+ [Melhores práticas para AWS Batch](best-practices.md) — Aprenda técnicas de otimização para workloads de produção