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 aos AWS Batch clusters privados do Amazon EKS
<a name="getting-started-eks-privateclusters"></a>

AWS Batch é um serviço gerenciado que orquestra cargas de trabalho em lotes em seus clusters do Amazon Elastic Kubernetes Service (Amazon EKS). Isso inclui enfileiramento, monitoramento de dependências, tentativas e prioridades gerenciadas de tarefas, gerenciamento de pods e nós em escala. Esse recurso conecta seu cluster privado existente do Amazon EKS AWS Batch para executar seus trabalhos em grande escala. Você pode usar [https://eksctl.io/usage/eks-private-cluster/](https://eksctl.io/usage/eks-private-cluster/)(uma interface de linha de comando para o Amazon EKS), o AWS console ou o [AWS Command Line Interface](https://aws.amazon.com/cli/)para criar um cluster privado do Amazon EKS com todos os outros recursos necessários. 

Por padrão, os [clusters privados do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/cluster-endpoint.html#private-access) não têm acesso à inbound/outbound Internet, e você só pode acessar o servidor de API de dentro da sua VPC ou de uma rede conectada. Endpoints da VPC Amazon são usados para permitir o acesso privado a outros serviços da AWS . O `eksctl` oferece suporte à criação de clusters totalmente privados usando uma Amazon VPC e sub-redes pré-existentes. O `eksctl` também cria endpoints da Amazon VPC na Amazon VPC fornecida e modifica as tabelas de rotas para as sub-redes fornecidas.

Cada sub-rede deve ter uma tabela de rotas explícita associada a ela, pois o `eksctl` não modifica a tabela de rotas principal. O [cluster](#getting-started-eks-privateclusters) deve extrair imagens de um registro de contêiner que esteja na Amazon VPC. Você também pode criar um Amazon Elastic Container Registry na Amazon VPC e copiar para ele as imagens de contêiner para que os nós as extrai dali. Para obter mais informações, consulte [Copiar uma imagem de contêiner de um repositório para outro](https://docs.aws.amazon.com/eks/latest/userguide/copy-image-to-repository.html). Para começar a usar repositórios privados do Amazon ECR, consulte [Repositórios privados do Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Repositories.html).

Opcionalmente, é possível criar uma [regra de cache de pullthrough](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache.html) com o Amazon ECR. Depois que uma regra de cache de pullthrough é criada para um registro público externo, é possível extrair uma imagem desse registro público externo usando seu URI (Identificador de recursos uriformes) de registro privado do Amazon ECR. Em seguida, o Amazon ECR cria um repositório e armazena a imagem no cache. Quando uma imagem em cache é extraída usando o URI de registro privado do Amazon ECR, o Amazon ECR verifica o registro remoto para ver se há uma nova versão da imagem e atualiza seu registro privado até uma vez a cada 24 horas.

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

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

Este tutorial demonstra como configurar AWS Batch com um Amazon EKS privado usando o AWS CloudShell, `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:  
+ Usar o Amazon Elastic Container Registry (Amazon ECR) para armazenar imagens de contêiner 
+ 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 40 a 50 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-privateclusters.html)

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

Este tutorial usa AWS CloudShell um shell pré-autenticado baseado em navegador que você inicia diretamente do. Console de gerenciamento da AWS Isso permite o acesso ao cluster quando ele não tem mais acesso público à Internet. O AWS CLI,`kubectl`, e `eksctl` pode já estar instalado como parte do AWS CloudShell. Para obter mais informações sobre AWS CloudShell, consulte o [https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html). Uma alternativa AWS CloudShell é conectar-se à VPC do seu cluster ou a uma [rede conectada](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/introduction.html).

Para executar comandos kubectl, você precisará de acesso privado ao cluster do Amazon EKS. Isso significa que todo o tráfego para o servidor de API do cluster deve vir da VPC do cluster ou de uma rede conectada.
+ **AWS CLI**— Uma ferramenta de linha de comando para trabalhar com AWS serviços, 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://eksctl.io/installation/) no **Guia do usuário do Amazon EKS**.
+ **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 `eks:DescribeCluster` operação da `eks:ListClusters` API. Você pode anexar a política [AWSBatchFullAccess](batch_managed_policies.md)gerenciada à sua conta de usuário seguindo as instruções Como [adicionar e remover permissões de identidade do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) no *Guia do usuário do IAM*. 
+ **InstanceRole**— Você precisa criar um `InstanceRole` para seus nós do Amazon EKS que tenha as `AmazonEC2ContainerRegistryPullOnly` políticas `AmazonEKSWorkerNodePolicy` e. Para obter instruções sobre como criar o `InstanceRole`, consulte [Criar o perfil do IAM do nó Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html#create-worker-node-role). Você precisará do ARN do `InstanceRole`.
+ **Conta da AWS ID** — Você precisa saber sua Conta da AWS identidade. Siga as instruções em [Visualizar seu Conta da AWS ID](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.md#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 EKS para AWS Batch
<a name="getting-started-eks-privateclusters-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.

Recomendamos que você use `eksctl` e o seguinte arquivo de configuração para criar seu cluster. Para configurar manualmente seu cluster, siga as instruções em [Implantar clusters privados com acesso limitado à Internet](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) no *Guia do usuário do Amazon EKS*.

1. Abra o [Console AWS CloudShell](https://console.aws.amazon.com/cloudshell/home) e defina a região como `us-east-1`. Para o resto do tutorial, certifique-se de usar o `us-east-1`.

1. Crie um cluster EKS privado na região `us-east-1` usando o arquivo de configuração de amostra `eksctl`. Salve o arquivo yaml em seu AWS CloudShell ambiente e dê um nome a ele`clusterConfig.yaml`. Você pode alterar *my-test-cluster* com o nome que deseja usar para seu cluster. 

   ```
   kind: ClusterConfig 
   apiVersion: eksctl.io/v1alpha5
   metadata:
       name: my-test-cluster 
       region: us-east-1
   availabilityZones: 
       - us-east-1a 
       - us-east-1b 
       - us-east-1c
   managedNodeGroups:
       - name: ng-1
         privateNetworking: true 
   privateCluster: 
       enabled: true 
       skipEndpointCreation: false
   ```

1. Crie seus recursos usando o comando:`eksctl create cluster -f clusterConfig.yaml`. A criação do cluster pode levar de 10 a 15 minutos.

1. Depois que o cluster terminar de ser criado, você deverá adicionar seu endereço AWS CloudShell IP à lista de permissões. Para encontrar seu endereço AWS CloudShell IP, execute o seguinte comando:

   ```
   curl http://checkip.amazonaws.com
   ```

   Quando tiver o endereço IP público, você precisará criar uma regra de lista de permissões:

   ```
   aws eks update-cluster-config \
     --name my-test-cluster \
     --region us-east-1 \
     --resources-vpc-config endpointPublicAccess=true,endpointPrivateAccess=true,publicAccessCidrs=["<Public IP>/32"]
   ```

   Em seguida, aplique a atualização no arquivo de configuração kubectl:

   ```
   aws eks update-kubeconfig --name my-test-cluster --region us-east-1
   ```

1. Para testar se você tem acesso aos nós, execute o seguinte comando:

   ```
   kubectl get nodes
   ```

   A saída do comandos é:

   ```
   NAME                              STATUS   ROLES    AGE     VERSION
   ip-192-168-107-235.ec2.internal   Ready    none     1h   v1.32.3-eks-473151a
   ip-192-168-165-40.ec2.internal    Ready    none     1h   v1.32.3-eks-473151a
   ip-192-168-98-54.ec2.internal     Ready    none     1h   v1.32.1-eks-5d632ec
   ```

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

Todas as etapas são obrigatórias e devem ser executadas em AWS CloudShell.

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 o `kubectl` para criar uma função do Kubernetes para o cluster do AWS Batch para permitir observar nós e pods e vincular a função. Você deve fazer isso uma vez para cada cluster do Amazon 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
   ```

   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
   ```

   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 

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

   Saída:

   ```
   2022-10-25 20:19:57 [ℹ]  adding identity "arn:aws:iam::<your-account-ID>: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-privateclusters-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-test-cluster` 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-test-cluster \
      --query cluster.resourcesVpcConfig.clusterSecurityGroupId
  ```
+ Use o ARN do `instanceRole` que você criou nos Pré-requisitos.

```
$ cat <<EOF > ./batch-eks-compute-environment.json
{
  "computeEnvironmentName": "My-Eks-CE1",
  "type": "MANAGED",
  "state": "ENABLED",
  "eksConfiguration": {
    "eksClusterArn": "arn:aws:eks:us-east-1:<your-account-ID>:cluster/my-test-cluster",
    "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-the-image-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 [Segurança no Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/security.html).

## Etapa 4: criar uma fila de trabalhos e conectar o ambiente computacional
<a name="getting-started-eks-privateclusters-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 um Amazon ECR com cache pull through
<a name="getting-started-eks-privateclusters-step-ecr"></a>

Como o cluster não tem acesso público à Internet, você precisa criar um Amazon ECR para imagens de contêineres. As instruções a seguir criam um Amazon ECR com uma regra de cache pull-through para armazenar a imagem.

1. O comando a seguir cria a regra de cache pull-through. Você pode *tutorial-prefix* substituir por um prefixo diferente.

   ```
   aws ecr create-pull-through-cache-rule \
       --ecr-repository-prefix "my-prefix" \
       --upstream-registry-url "public.ecr.aws" \
       --region us-east-1
   ```

1. Autentique com o ECR público.

   ```
   aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com
   ```

   Agora você pode puxar uma imagem.

   ```
   docker pull <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/amazonlinux/amazonlinux:2
   ```

1. Você pode verificar o repositório e a imagem executando os seguintes comandos:

   ```
   aws ecr describe-repositories
   ```

   ```
   aws ecr describe-images --repository-name my-prefix/amazonlinux/amazonlinux
   ```

1. A string de imagem a ser usada para puxar o contêiner está no seguinte formato:

   ```
   <your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/amazonlinux/amazonlinux:2
   ```

## Etapa 6: registrar uma definição de trabalho
<a name="getting-started-eks-privateclusters-step-4"></a>

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

No campo de imagem da definição do trabalho, em vez de fornecer um link para a imagem em um repositório do ECR público, forneça o link para a imagem armazenada no nosso repositório do ECR privado. Veja o exemplo de definição de trabalho a seguir:

```
$ cat <<EOF > ./batch-eks-job-definition.json
{
  "jobDefinitionName": "MyJobOnEks_Sleep",
  "type": "container",
  "eksProperties": {
    "podProperties": {
      "hostNetwork": true,
      "containers": [
        {
          "image": "<your-account-ID>.dkr.ecr.us-east-1.amazonaws.com/my-prefix/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 7: enviar um trabalho para execução
<a name="getting-started-eks-privateclusters-step-5"></a>

Execute o AWS CLI comando a seguir AWS CloudShell para enviar um novo Job e retornar o JobID exclusivo.

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

**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 8: ver a saída do trabalho
<a name="getting-started-eks-privateclusters-step-7"></a>

Para verificar o status de um trabalho:

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

`startedAt` e `stoppedAt` devem ter um minuto de diferença. 

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

Esse trabalho substitui o comando passado para o contêiner.

```
$ 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).

## Etapa 10: limpar os recursos do tutorial
<a name="getting-started-eks-privateclusters-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. Em **Ações**, escolha **Desativar**. 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** em **Ações**. 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).

## Solução de problemas
<a name="getting-started-eks-privateclusters-troubleshooting"></a>

Se os nós lançados por AWS Batch não tiverem acesso ao repositório Amazon ECR (ou a qualquer outro repositório) que armazena sua imagem, seus trabalhos poderão permanecer no estado STARTING. Isso ocorre porque o pod não conseguirá baixar a imagem e executar seu AWS Batch trabalho. Se você clicar no nome do pod lançado por AWS Batch , poderá ver a mensagem de erro e confirmar o problema. A mensagem de erro deve ser semelhante à seguinte:

```
Failed to pull image "public.ecr.aws/amazonlinux/amazonlinux:2": rpc error: code =
Unknown desc = failed to pull and unpack image
"public.ecr.aws/amazonlinux/amazonlinux:2": failed to resolve reference
"public.ecr.aws/amazonlinux/amazonlinux:2": failed to do request: Head
"https://public.ecr.aws/v2/amazonlinux/amazonlinux/manifests/2": dial tcp: i/o timeout
```

Para outros cenários comuns de solução de problemas, consulte [Solução de problemas com o AWS Batch](https://docs.aws.amazon.com/batch/latest/userguide/batch-eks-troubleshooting.html). Para solução de problemas com base no status do pod, consulte [https://repost.aws/knowledge-center/eks-pod-status-troubleshooting](https://repost.aws/knowledge-center/eks-pod-status-troubleshooting).