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á.

# Começando a usar AWS Batch no Amazon EKS
<a name="getting-started-eks"></a>

AWS Batch on Amazon EKS é um serviço gerenciado para programar e escalar cargas de trabalho em lotes em clusters existentes do Amazon EKS. AWS Batch não cria, administra nem executa operações de ciclo de vida de seus clusters do Amazon EKS em seu nome. AWS Batch a orquestração aumenta e diminui os nós gerenciados AWS Batch e executa pods nesses nós.

AWS Batch não toca em nós, grupos de nós com escalabilidade automática ou ciclos de vida de pods que não estejam associados a ambientes AWS Batch computacionais em seu cluster Amazon EKS. AWS Batch Para operar de forma eficaz, sua [função vinculada a serviços precisa de permissões de controle de acesso Kubernetes baseado em função](using-service-linked-roles.md) (RBAC) em seu cluster Amazon EKS existente. Para obter mais informações, consulte [Usar autorização RBAC](https://kubernetes.io/docs/reference/access-authn-authz/rbac/) na *documentação do Kubernetes*.

AWS Batch requer um Kubernetes namespace no qual possa incluir pods como AWS Batch trabalhos. Recomendamos um namespace dedicado para isolar os AWS Batch pods das outras cargas de trabalho do cluster.

Depois AWS Batch de receber acesso ao RBAC e estabelecer um namespace, você pode associar esse cluster Amazon EKS a um ambiente AWS Batch computacional usando a operação de API. [CreateComputeEnvironment](https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html) Uma fila de trabalhos pode ser associada a esse novo ambiente computacional do Amazon EKS. AWS Batch os trabalhos são enviados para a fila de trabalhos com base em uma definição de trabalho do Amazon EKS usando a operação de [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)API. AWS Batch em seguida, inicia os nós AWS Batch gerenciados e coloca os trabalhos da fila de trabalhos como Kubernetes pods no cluster EKS associado a um ambiente AWS Batch computacional.

As seções a seguir abordam como se configurar AWS Batch no Amazon EKS.

**Contents**
+ [Visão geral do](#getting-started-eks-context)
+ [Pré-requisitos](#getting-started-eks-prerequisites)
+ [Etapa 1: Crie seu cluster Amazon EKS para AWS Batch](#getting-started-eks-step-0)
+ [Etapa 2: Prepare seu cluster Amazon EKS para AWS Batch](#getting-started-eks-step-1)
+ [Etapa 3: criar um ambiente computacional do Amazon EKS](#getting-started-eks-step-2)
+ [Etapa 4: criar uma fila de trabalhos e conectar o ambiente computacional](#getting-started-eks-step-3)
+ [Etapa 5: criar uma definição de tarefa](#getting-started-eks-step-4)
+ [Etapa 6: enviar um trabalho](#getting-started-eks-step-5)
+ [Etapa 7: ver a saída do trabalho](#getting-started-eks-step-7)
+ [Etapa 8: (Opcional) Enviar um trabalho com substituições](#getting-started-eks-step-6)
+ [Etapa 9: limpar os recursos do tutorial](#getting-started-eks-step-8)
+ [Recursos adicionais do](#getting-started-eks-additional-resources)

## Visão geral do
<a name="getting-started-eks-context"></a>

Este tutorial demonstra como configurar AWS Batch com o Amazon EKS usando o AWS CLI, `kubectl` e. `eksctl` 

**Público-alvo**  
Este tutorial foi desenvolvido para administradores de sistemas e desenvolvedores responsáveis pela configuração, teste e implantação do AWS Batch.

**Características usadas**  
Este tutorial mostra como usar o AWS CLI, para:  
+ Criar e configurar um ambiente computacional do Amazon EKS
+ Crie uma fila de trabalhos.
+ Crie uma definição de trabalho
+ Criar e enviar um trabalho para execução
+ Enviar um trabalho com substituições

**Tempo necessário**  
A conclusão deste tutorial deve levar cerca de 30 a 40 minutos.

**Restrições regionais**  
Não há restrições de país ou regionais associadas ao uso desta solução.

**Custos de uso de recursos**  
Não há cobrança pela criação de uma AWS conta. Contudo, ao implementar essa solução, pode haver alguns ou todos os custos listados na tabela a seguir.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/batch/latest/userguide/getting-started-eks.html)

## Pré-requisitos
<a name="getting-started-eks-prerequisites"></a>

Antes de iniciar este tutorial, você deve instalar e configurar as seguintes ferramentas e recursos necessários para criar e gerenciar tanto os recursos do Amazon EKS AWS Batch quanto os do Amazon EKS.
+ **AWS CLI**: uma ferramenta de linha de comando para trabalhar com os serviços da AWS , incluindo o Amazon EKS. Este guia exige que você use a versão 2.8.6 ou superior, ou a versão 1.26.0 ou superior. Para obter mais informações, consulte [Como instalar, atualizar e desinstalar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) no *Guia do usuário da AWS Command Line Interface *. Depois de instalar o AWS CLI, recomendamos que você também o configure. Para obter mais informações, consulte [Configuração rápida com o `aws configure`](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) no *Manual do usuário do AWS Command Line Interface *.
+ **`kubectl`**: uma ferramenta de linha de comando para trabalhar com clusters do Kubernetes. Este guia requer que você use a versão `1.23` ou superior. Para obter mais informações, consulte [Instalar ou atualizar o `kubectl`](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) no *Guia do usuário do Amazon EKS*.
+ **`eksctl`**: uma ferramenta de linha de comando para trabalhar com clusters do Amazon EKS que automatiza várias tarefas individuais. Este guia requer que você use a versão `0.115.0` ou superior. Para obter mais informações, consulte [Instalar ou atualizar o `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html) no **Guia do usuário do Amazon EKS**.
+ **Permissões de IAM necessárias** — O diretor de segurança do IAM que você está usando deve ter permissões para trabalhar com funções do IAM e funções vinculadas a serviços do Amazon EKS CloudFormation, além de uma VPC e recursos relacionados. Para obter mais informações, consulte [Ações, recursos e chaves de condição do Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html) e [Usar perfis vinculados a serviço](https://docs.aws.amazon.com/IAM/latest/UserGuide/using-service-linked-roles.html), no *Guia do usuário do IAM*. É necessário concluir todas as etapas deste manual como o mesmo usuário.
+ **Permissões** — Os usuários que chamam a operação da [CreateComputeEnvironment](https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html)API para criar um ambiente computacional que usa os recursos do Amazon EKS precisam de permissões para a operação da `eks:DescribeCluster` API. 
+ **Conta da AWS número** — Você precisa saber sua Conta da AWS identidade. Siga as instruções em [Visualizar seu ID da Conta da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html).
+ **(Opcional) CloudWatch** — Para examinar os detalhes de [(Opcional) Enviar um trabalho com substituições](#getting-started-eks-step-6), o registro deve ser configurado. Para obter mais informações, consulte [Use CloudWatch registros para monitorar trabalhos AWS Batch do Amazon EKS](batch-eks-cloudwatch-logs.md).

## Etapa 1: Crie seu cluster Amazon EKS para AWS Batch
<a name="getting-started-eks-step-0"></a>

**Importante**  
Para começar da forma mais simples e rápida possível, este tutorial inclui etapas com configurações padrão. Antes de criar para uso em produção, recomendamos que você se familiarize com todas as configurações e implante com as configurações que atendam aos seus requisitos.

Depois de instalar os pré-requisitos, você precisará criar seu cluster usando o `eksctl`. Criar o cluster pode levar de 10 a 15 minutos. 

```
$  eksctl create cluster --name my-cluster-name --region region-code
```

No comando anterior, substitua:
+ *my-cluster-name*Substitua pelo nome que você deseja usar para seu cluster. 
+ *region-code*Substitua pelo Região da AWS para criar o cluster em, por exemplo`us-west-2`.

O nome e a região do cluster são necessários para um momento posterior deste tutorial.

## Etapa 2: Prepare seu cluster Amazon EKS para AWS Batch
<a name="getting-started-eks-step-1"></a>

Todas as etapas são necessárias.

1. 

**Crie um namespace dedicado para trabalhos AWS Batch**

   Use o `kubectl` para criar um namespace.

   ```
   $ namespace=my-aws-batch-namespace
   ```

   ```
   $ cat - <<EOF | kubectl create -f -
   {
     "apiVersion": "v1",
     "kind": "Namespace",
     "metadata": {
       "name": "${namespace}",
       "labels": {
         "name": "${namespace}"
       }
     }
   }
   EOF
   ```

   Saída:

   ```
   namespace/my-aws-batch-namespace created
   ```

1. 

**Habilite o acesso por meio do controle de acesso com base em perfil (RBAC)**

   Use `kubectl` para criar uma Kubernetes função para o cluster AWS Batch para permitir observar nós e pods e vincular a função. Você deve fazer isso uma vez para cada cluster do EKS.

   ```
   $ cat - <<EOF | kubectl apply -f -
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: aws-batch-cluster-role
   rules:
     - apiGroups: [""]
       resources: ["namespaces"]
       verbs: ["get"]
     - apiGroups: [""]
       resources: ["nodes"]
       verbs: ["get", "list", "watch"]
     - apiGroups: [""]
       resources: ["pods"]
       verbs: ["get", "list", "watch"]
     - apiGroups: [""]
       resources: ["events"]
       verbs: ["list"]
     - apiGroups: [""]
       resources: ["configmaps"]
       verbs: ["get", "list", "watch"]
     - apiGroups: ["apps"]
       resources: ["daemonsets", "deployments", "statefulsets", "replicasets"]
       verbs: ["get", "list", "watch"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["clusterroles", "clusterrolebindings"]
       verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: aws-batch-cluster-role-binding
   subjects:
   - kind: User
     name: aws-batch
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: ClusterRole
     name: aws-batch-cluster-role
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

   Saída:

   ```
   clusterrole.rbac.authorization.k8s.io/aws-batch-cluster-role created
   clusterrolebinding.rbac.authorization.k8s.io/aws-batch-cluster-role-binding created
   ```

1. Crie uma Kubernetes função com escopo de namespace para gerenciar e fazer o ciclo de vida dos AWS Batch pods e vinculá-los. Você deve fazer isso uma vez para cada namespace exclusivo.

   ```
   $ namespace=my-aws-batch-namespace
   ```

   ```
   $ cat - <<EOF | kubectl apply -f - --namespace "${namespace}"
   apiVersion: rbac.authorization.k8s.io/v1
   kind: Role
   metadata:
     name: aws-batch-compute-environment-role
     namespace: ${namespace}
   rules:
     - apiGroups: [""]
       resources: ["pods"]
       verbs: ["create", "get", "list", "watch", "delete", "patch"]
     - apiGroups: [""]
       resources: ["serviceaccounts"]
       verbs: ["get", "list"]
     - apiGroups: ["rbac.authorization.k8s.io"]
       resources: ["roles", "rolebindings"]
       verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: RoleBinding
   metadata:
     name: aws-batch-compute-environment-role-binding
     namespace: ${namespace}
   subjects:
   - kind: User
     name: aws-batch
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: Role
     name: aws-batch-compute-environment-role
     apiGroup: rbac.authorization.k8s.io
   EOF
   ```

   Saída:

   ```
   role.rbac.authorization.k8s.io/aws-batch-compute-environment-role created
   rolebinding.rbac.authorization.k8s.io/aws-batch-compute-environment-role-binding created
   ```

1. Atualize o mapa Kubernetes `aws-auth` de configuração para mapear as permissões anteriores do RBAC para a função vinculada ao serviço. AWS Batch 

   No comando a seguir, substitua:
   + Substituir *<your-account-number>* por seu número de Conta da AWS . 

   ```
   $ eksctl create iamidentitymapping \
       --cluster my-cluster-name \
       --arn "arn:aws:iam::<your-account-number>:role/AWSServiceRoleForBatch" \
       --username aws-batch
   ```

   Saída:

   ```
   2022-10-25 20:19:57 [ℹ]  adding identity "arn:aws:iam::<your-account-number>:role/AWSServiceRoleForBatch" to auth ConfigMap
   ```
**nota**  
O caminho `aws-service-role/batch.amazonaws.com/` foi removido do ARN so perfil vinculado ao serviço. Isso ocorre devido a um problema com o mapa de configuração `aws-auth`. Para obter mais informações, consulte [Perfis com caminhos não funcionam quando o caminho é incluído em seu ARN no aws-authconfigmap](https://github.com/kubernetes-sigs/aws-iam-authenticator/issues/268).

## Etapa 3: criar um ambiente computacional do Amazon EKS
<a name="getting-started-eks-step-2"></a>

AWS Batch ambientes computacionais definem parâmetros de recursos computacionais para atender às suas necessidades de carga de trabalho em lotes. Em um ambiente computacional gerenciado, AWS Batch ajuda você a gerenciar a capacidade e os tipos de instância dos recursos computacionais (Kubernetesnós) dentro do seu cluster Amazon EKS. Isso se baseia na especificação do recurso de computação que você define ao criar o ambiente de computação. Você pode usar instâncias sob demanda do EC2 ou instâncias spot do EC2.

Agora que a função **AWSServiceRoleForBatch**vinculada ao serviço tem acesso ao seu cluster Amazon EKS, você pode criar AWS Batch recursos. Primeiro, crie um ambiente computacional que aponte para seu cluster do Amazon EKS.
+ Para o `subnets` executar `eksctl get cluster my-cluster-name` para obter as sub-redes usadas pelo cluster. 
+ Para o parâmetro `securityGroupIds` você pode usar o mesmo grupo de segurança do cluster do Amazon EKS. Esse comando recupera o ID do grupo de segurança do cluster.

  ```
  $ aws eks describe-cluster \
      --name my-cluster-name \
      --query cluster.resourcesVpcConfig.clusterSecurityGroupId
  ```
+ O `instanceRole` é criado quando você cria o cluster. Para encontrar a lista `instanceRole` de todas as entidades que usam a política `AmazonEKSWorkerNodePolicy`: 

  ```
  $  aws iam list-entities-for-policy --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy
  ```

  O nome do perfil da política contém o nome do cluster que você criou `eksctl-my-cluster-name-nodegroup-example`. 

  Para encontrar o `instanceRole` e executar o comando a seguir:

  ```
  $  aws iam list-instance-profiles-for-role --role-name eksctl-my-cluster-name-nodegroup-example        
  ```

  Saída:

  ```
  INSTANCEPROFILES        arn:aws:iam::<your-account-number>:instance-profile/eks-04cb2200-94b9-c297-8dbe-87f12example
  ```

  Para mais informações, consulte [Criar o perfil do IAM do nó do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html#create-worker-node-role) e [Habilitar o acesso da entidade principal do IAM ao seu cluster](https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html) no *Guia do usuário do Amazon EKS*. Se você estiver usando redes de pods, consulte [Como configurar o plugin CNI da Amazon VPC para o Kubernetes para usar perfis do IAM para contas de serviço](https://docs.aws.amazon.com/eks/latest/userguide/cni-iam-role.html) no **Guia do usuário do Amazon EKS**.

```
$ cat <<EOF > ./batch-eks-compute-environment.json
{
  "computeEnvironmentName": "My-Eks-CE1",
  "type": "MANAGED",
  "state": "ENABLED",
  "eksConfiguration": {
    "eksClusterArn": "arn:aws:eks:region-code:your-account-number:cluster/my-cluster-name",
    "kubernetesNamespace": "my-aws-batch-namespace"
  },
  "computeResources": {
    "type": "EC2",
    "allocationStrategy": "BEST_FIT_PROGRESSIVE",
    "minvCpus": 0,
    "maxvCpus": 128,
    "instanceTypes": [
        "m5"
    ],
    "subnets": [
        "<eks-cluster-subnets-with-access-to-internet-for-image-pull>"
    ],
    "securityGroupIds": [
        "<eks-cluster-sg>"
    ],
    "instanceRole": "<eks-instance-profile>"
  }
}
EOF
```

```
$ aws batch create-compute-environment --cli-input-json file://./batch-eks-compute-environment.json
```

**Observações**
+ A manutenção de um ambiente de computação do Amazon EKS é uma responsabilidade compartilhada. Para obter mais informações, consulte [Responsabilidade compartilhada dos nós Kubernetes](eks-ce-shared-responsibility.md).

## Etapa 4: criar uma fila de trabalhos e conectar o ambiente computacional
<a name="getting-started-eks-step-3"></a>

**Importante**  
É importante confirmar se o ambiente de computação está íntegro antes de continuar. A operação [DescribeComputeEnvironments](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeComputeEnvironments.html)da API pode ser usada para fazer isso.  

```
$ aws batch describe-compute-environments --compute-environments My-Eks-CE1
```
Confirme se o parâmetro `status` não está `INVALID`. Se estiver, veja o parâmetro `statusReason` para saber a causa. Para obter mais informações, consulte [Solução de problemas AWS Batch](troubleshooting.md).

Os trabalhos enviados para essa nova fila de trabalhos são executados como pods em nós AWS Batch gerenciados que se juntaram ao cluster Amazon EKS associado ao seu ambiente computacional.

```
$ cat <<EOF > ./batch-eks-job-queue.json
 {
    "jobQueueName": "My-Eks-JQ1",
    "priority": 10,
    "computeEnvironmentOrder": [
      {
        "order": 1,
        "computeEnvironment": "My-Eks-CE1"
      }
    ]
  }
EOF
```

```
$ aws batch create-job-queue --cli-input-json file://./batch-eks-job-queue.json
```

## Etapa 5: criar uma definição de tarefa
<a name="getting-started-eks-step-4"></a>

A definição de trabalho a seguir instrui o pod a dormir por 60 segundos.

```
$ cat <<EOF > ./batch-eks-job-definition.json
{
  "jobDefinitionName": "MyJobOnEks_Sleep",
  "type": "container",
  "eksProperties": {
    "podProperties": {
      "hostNetwork": true,
      "containers": [
        {
          "image": "public.ecr.aws/amazonlinux/amazonlinux:2",
          "command": [
            "sleep",
            "60"
          ],
          "resources": {
            "limits": {
              "cpu": "1",
              "memory": "1024Mi"
            }
          }
        }
      ],
      "metadata": {
        "labels": {
          "environment": "test"
        }
      }
    }
  }
}
EOF
```

```
$ aws batch register-job-definition --cli-input-json file://./batch-eks-job-definition.json
```

**Observações**
+ Há considerações sobre os parâmetros `cpu` e `memory`. Para obter mais informações, consulte [Considerações sobre memória e vCPU para AWS Batch no Amazon EKS](memory-cpu-batch-eks.md).

## Etapa 6: enviar um trabalho
<a name="getting-started-eks-step-5"></a>

Execute o AWS CLI comando a seguir para enviar um novo Job.

```
$ aws batch submit-job --job-queue My-Eks-JQ1 \
    --job-definition MyJobOnEks_Sleep --job-name My-Eks-Job1
```

Para verificar o status de um trabalho:

```
$ aws batch describe-jobs --job <jobId-from-submit-response>
```

**Observações**
+ Para obter mais informações sobre como executar trabalhos em recursos do Amazon EKS, consulte [Trabalhos do Amazon EKS](eks-jobs.md).

## Etapa 7: ver a saída do trabalho
<a name="getting-started-eks-step-7"></a>

Para ver o resultado do trabalho, faça o seguinte:

1. Abra o AWS Batch console em [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. No painel de navegação, escolha **Trabalhos**. 

1. No menu suspenso **Fila de trabalhos**, escolha a fila de trabalhos que você criou para o tutorial.

1. A tabela de **Trabalhos** lista todos os seus trabalhos e qual é o status atual deles. Quando o **Status** do Job for **Succeeded**, escolha o **Nome** do Job,*My-Eks-JQ1*, para ver os detalhes do Job. 

1. No painel **Detalhes**, os horários **Iniciado em** e **Concluído em** devem ter um minuto de intervalo. 

## Etapa 8: (Opcional) Enviar um trabalho com substituições
<a name="getting-started-eks-step-6"></a>

Esse trabalho substitui o comando passado para o contêiner. AWS Batch limpa agressivamente os frutos após a conclusão dos trabalhos para reduzir a carga para. Kubernetes Para examinar os detalhes de um trabalho, o log deve ser configurado. Para obter mais informações, consulte [Use CloudWatch registros para monitorar trabalhos AWS Batch do Amazon EKS](batch-eks-cloudwatch-logs.md).

```
$ cat <<EOF > ./submit-job-override.json
{
  "jobName": "EksWithOverrides",
  "jobQueue": "My-Eks-JQ1",
  "jobDefinition": "MyJobOnEks_Sleep",
  "eksPropertiesOverride": {
    "podProperties": {
      "containers": [
        {
          "command": [
            "/bin/sh"
          ],
          "args": [
            "-c",
            "echo hello world"
          ]
        }
      ]
    }
  }
}
EOF
```

```
$ aws batch submit-job --cli-input-json file://./submit-job-override.json
```

**Observações**
+ Para melhorar a visibilidade dos detalhes das operações, ative o log do ambiente de gerenciamento Amazon EKS. Para obter mais informações, consulte [Logs do ambiente de gerenciamento do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/control-plane-logs.html) no *Guia do usuário do Amazon EKS*.
+ A sobrecarga de Daemonsets e kubelets afeta os recursos de vCPU e memória disponíveis, especificamente a escalabilidade e o posicionamento do trabalho. Para obter mais informações, consulte [Considerações sobre memória e vCPU para AWS Batch no Amazon EKS](memory-cpu-batch-eks.md).

Para ver o resultado do trabalho, faça o seguinte:

1. Abra o AWS Batch console em [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. No painel de navegação, escolha **Trabalhos**. 

1. No menu suspenso **Fila de trabalhos**, escolha a fila de trabalhos que você criou para o tutorial.

1. A tabela de **Trabalhos** lista todos os seus trabalhos e qual é o status atual deles. Depois que o **Status** do trabalho for **Bem-sucedido**, escolha o **Nome** do trabalho para ver os detalhes do trabalho. 

1. No painel **Detalhes**, escolha **Nome do fluxo de log**. O CloudWatch console do Job será aberto e deverá haver um evento com a **Mensagem** de `hello world` ou sua mensagem personalizada.

## Etapa 9: limpar os recursos do tutorial
<a name="getting-started-eks-step-8"></a>

Você será cobrado pela instância do Amazon EC2 enquanto ela estiver ativada. É possível excluir a instância para não incorrer mais em cobranças.

Para excluir os recursos criados, faça o seguinte:

1. Abra o AWS Batch console em [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. No painel de navegação, escolha **Filas de trabalhos**. 

1. Na tabela **Fila de trabalhos**, escolha a fila de trabalhos que você criou para o tutorial.

1. Escolha **Disable**. Depois que o **Estado** da fila de trabalhos estiver desativado, você poderá escolher **Excluir**.

1. Depois que a fila de trabalhos for excluída, no painel de navegação, escolha **Ambientes de computação**.

1. Escolha o ambiente computacional que você criou para este tutorial e, em seguida, escolha **Desativar**. Pode levar de 1 a 2 minutos para que o ambiente computacional seja desativado.

1. Quando o **Estado** do ambiente computacional estiver desativado, escolha **Excluir**. Pode levar de 1 a 2 minutos para que o ambiente computacional seja excluído.

## Recursos adicionais do
<a name="getting-started-eks-additional-resources"></a>

Depois de concluir o tutorial, você pode querer explorar os seguintes tópicos:
+ Saiba mais sobre as [Práticas recomendadas](best-practices.md).
+ Explore os componentes AWS Batch principais. Para obter mais informações, consulte [Componentes do AWS Batch](batch_components.md).
+ Saiba mais sobre os diferentes [Ambientes de computação](compute_environments.md) disponíveis no AWS Batch.
+ Saiba mais sobre as [Filas de trabalhos](job_queues.md) e suas diferentes opções de agendamento.
+ Saiba mais sobre as [Definições de trabalho](job_definitions.md) e suas diferentes opções de configuração.
+ Saiba mais sobre os diferentes tipos de [Trabalho](jobs.md).