

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

# Usar o índice de trabalho de matriz para controle de diferenciação de trabalhos
<a name="array_index_example"></a>

Este tutorial descreve instruções de uso da variável de ambiente `AWS_BATCH_JOB_ARRAY_INDEX` para diferenciar os trabalhos filho. Cada trabalho filho é atribuído a essa variável. O exemplo utiliza o número de índice do trabalho filho para ler uma linha específica em um arquivo. Em seguida, ele substitui o parâmetro associado a esse número de linha por um comando dentro do contêiner do trabalho. O resultado é que você pode ter vários AWS Batch trabalhos que executam a mesma imagem do Docker e argumentos de comando. No entanto, os resultados serão diferentes porque o índice de trabalho da matriz é usado como um modificador.

Neste tutorial, um arquivo de texto é criado com todas as cores do arco-íris, cada uma em sua própria linha. Em seguida, você cria um script de ponto de entrada para um contêiner do Docker que converte o índice em um valor, que pode ser usado para um número de linha no campo do arquivo de cores. O índice inicia em zero, mas os números da linha iniciam em um. Crie um Dockerfile que copie os arquivos de cores e índice na imagem de contêiner, e defina o `ENTRYPOINT` da imagem como o script de ponto de entrada. O Dockerfile e os recursos são incorporados em uma imagem do Docker, que é enviada para o Amazon ECR. Em seguida, você registra uma definição de tarefa que usa sua nova imagem de contêiner, envia uma tarefa de AWS Batch matriz com essa definição de tarefa e visualiza os resultados.

**Topics**
+ [Pré-requisitos](array-tutorial-prereqs.md)
+ [Criar uma imagem de contêiner](build-index-container.md)
+ [Enviar sua imagem para o Amazon ECR](push-array-image.md)
+ [Criar e registrar uma definição de trabalho](create-array-job-def.md)
+ [Enviar um trabalho AWS Batch de matriz](submit-array-job.md)
+ [Visualizar seus logs de trabalhos de matriz](#array-tutorial-logs)

# Pré-requisitos
<a name="array-tutorial-prereqs"></a>

Este fluxo de trabalho de tutorial tem os seguintes pré-requisitos:
+ Um ambiente AWS Batch computacional. Para obter mais informações, consulte [Crie um ambiente de computação](create-compute-environment.md).
+ Uma fila AWS Batch de trabalhos e um ambiente computacional associado. Para obter mais informações, consulte [Crie uma fila de trabalhos](create-job-queue.md).
+ O AWS CLI instalado em seu sistema local. Para obter mais informações, consulte [> Instalar a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) no *Guia do usuário da AWS Command Line Interface *.
+ Docker instalado em seu sistema local. Para obter mais informações, consulte [Sobre o Docker CE](https://docs.docker.com/install/) no campo de documentação do Docker.

# Criar uma imagem de contêiner
<a name="build-index-container"></a>

Você pode usar o `AWS_BATCH_JOB_ARRAY_INDEX` em uma definição de trabalho no parâmetro de comando. No entanto, recomendamos criar uma imagem de contêiner que use a variável em um script de ponto de entrada. Esta seção descreve instruções para criação essa imagem de contêiner.

**Para criar sua imagem de contêiner do Docker**

1. Crie novo diretório, a ser usado como seu workspace de imagem do Docker, e navegue até ele.

1. Crie um arquivo de nome `colors.txt` em seu diretório do workspace e cole o conteúdo a seguir.

   ```
   red
   orange
   yellow
   green
   blue
   indigo
   violet
   ```

1. Crie um arquivo de nome `print-color.sh` em seu diretório do workspace e cole o conteúdo a seguir.
**nota**  
A variável `LINE` é definida como `AWS_BATCH_JOB_ARRAY_INDEX` \$11, pois o índice de matriz inicia em 0, mas os números de linha iniciam em com 1. A variável `COLOR` é definida como a cor no `colors.txt` associado ao número de linha.

   ```
   #!/bin/sh
   LINE=$((AWS_BATCH_JOB_ARRAY_INDEX + 1))
   COLOR=$(sed -n ${LINE}p /tmp/colors.txt)
   echo My favorite color of the rainbow is $COLOR.
   ```

1. Crie um arquivo de nome `Dockerfile` em seu diretório do workspace e cole nele o conteúdo a seguir. Esse Dockerfile copia os arquivos anteriores em seu contêiner e define o script de ponto de entrada a ser executado quando o contêiner for iniciado.

   ```
   FROM busybox
   COPY print-color.sh /tmp/print-color.sh
   COPY colors.txt /tmp/colors.txt
   RUN chmod +x /tmp/print-color.sh
   ENTRYPOINT /tmp/print-color.sh
   ```

1. Compile sua imagem do Docker.

   ```
   $ docker build -t print-color .
   ```

1. Teste seu contêiner com o script a seguir. Esse script define a variável `AWS_BATCH_JOB_ARRAY_INDEX` como 0 localmente e, em seguida, a acrescenta, para simular o que um trabalho de matriz com sete filhos faz.

   ```
   $ AWS_BATCH_JOB_ARRAY_INDEX=0
   while [ $AWS_BATCH_JOB_ARRAY_INDEX -le 6 ]
   do
       docker run -e AWS_BATCH_JOB_ARRAY_INDEX=$AWS_BATCH_JOB_ARRAY_INDEX print-color
       AWS_BATCH_JOB_ARRAY_INDEX=$((AWS_BATCH_JOB_ARRAY_INDEX + 1))
   done
   ```

   A saída vem a seguir.

   ```
   My favorite color of the rainbow is red.
   My favorite color of the rainbow is orange.
   My favorite color of the rainbow is yellow.
   My favorite color of the rainbow is green.
   My favorite color of the rainbow is blue.
   My favorite color of the rainbow is indigo.
   My favorite color of the rainbow is violet.
   ```

# Enviar sua imagem para o Amazon ECR
<a name="push-array-image"></a>

Agora que você criou e testou o contêiner do Docker, envie-o para um repositório de imagens. Este exemplo usa o Amazon ECR, mas você pode usar outro registro, como DockerHub.

1. Crie um repositório de imagens do Amazon ECR para armazenar sua imagem de contêiner. Este exemplo usa somente AWS CLI o. mas você também pode usar Console de gerenciamento da AWS o. Para obter mais informações, consulte [Criando um Repositório](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) no campo do *Manual do Usuário do Amazon Elastic Container Registry*.

   ```
   $ aws ecr create-repository --repository-name print-color
   ```

1. Marque sua imagem `print-color` com o URI do repositório do Amazon ECR retornado na etapa anterior.

   ```
   $ docker tag print-color aws_account_id.dkr.ecr.region.amazonaws.com/print-color
   ```

1. Inicie a sessão no seu registro do Amazon ECR. Para obter mais informações, consulte [Autenticação de Registro](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) no campo do *Manual do Usuário do Amazon Elastic Container Registry*.

   ```
   $ aws ecr get-login-password \
       --region region | docker login \
       --username AWS \
       --password-stdin aws_account_id.dkr.ecr.region.amazonaws.com
   ```

1. Envie sua imagem para o Amazon ECR.

   ```
   $ docker push aws_account_id.dkr.ecr.region.amazonaws.com/print-color
   ```

# Criar e registrar uma definição de trabalho
<a name="create-array-job-def"></a>

Agora que sua imagem do Docker está em um registro de imagem, você pode especificá-la em uma definição de AWS Batch tarefa. Assim, você pode usá-la posteriormente para executar um trabalho de matriz. Este exemplo usa apenas o AWS CLI. No entanto, você também pode usar o Console de gerenciamento da AWS. Para obter mais informações, consulte [Criar uma definição de tarefa de nó único](create-job-definition.md).

**Para criar uma definição de trabalho**

1. Crie um arquivo de nome `print-color-job-def.json` em seu diretório do workspace e cole o conteúdo a seguir. Substitua o URI do repositório de imagem pelo seu próprio URI da imagem.

   ```
   {
     "jobDefinitionName": "print-color",
     "type": "container",
     "containerProperties": {
       "image": "aws_account_id.dkr.ecr.region.amazonaws.com/print-color",
       "resourceRequirements": [
           {
               "type": "MEMORY",
               "value": "250"
           },
           {
               "type": "VCPU",
               "value": "1"
           }
       ]
     }
   }
   ```

1. Registre a definição do trabalho com AWS Batch.

   ```
   $ aws batch register-job-definition --cli-input-json file://print-color-job-def.json
   ```

# Enviar um trabalho AWS Batch de matriz
<a name="submit-array-job"></a>

Depois de registrar sua definição de tarefa, você pode enviar uma tarefa de AWS Batch matriz que usa sua nova imagem de contêiner.

**Para enviar um trabalho AWS Batch de matriz**

1. Crie um arquivo de nome `print-color-job.json` em seu diretório do workspace e cole o conteúdo a seguir.
**nota**  
Este exemplo usa a fila de trabalhos mencionada na seção [Pré-requisitos](array-tutorial-prereqs.md).

   ```
   {
     "jobName": "print-color",
     "jobQueue": "existing-job-queue",
     "arrayProperties": {
       "size": 7
     },
     "jobDefinition": "print-color"
   }
   ```

1. Envie o trabalho para sua fila de AWS Batch trabalhos. Anote a ID do trabalho retornado na saída.

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

1. Descreva o status do trabalho e espere até que o trabalho seja movido para `SUCCEEDED`.

## Visualizar seus logs de trabalhos de matriz
<a name="array-tutorial-logs"></a>

Depois que seu trabalho atingir o `SUCCEEDED` status, você poderá visualizar os CloudWatch registros no contêiner do trabalho.

**Para ver os registros do seu trabalho em CloudWatch Registros**

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 à esquerda, escolha **Trabalhos**.

1. Para **Fila de Trabalhos**, selecione uma fila. 

1. Na seção **Status**, escolha **bem-sucedido**.

1. Para exibir todas os trabalhos filho de seu trabalho matriz, selecione a ID do trabalho que foi retornado na seção anterior.

1. Para consultar os logs do contêiner do trabalho, selecione um dos trabalhos filho e escolha **Visualizar Logs**.  
![\[Logs do contêiner de trabalhos de matriz\]](http://docs.aws.amazon.com/pt_br/batch/latest/userguide/images/array-logs.png)

1. Visualize os outros logs de trabalho filho. Cada trabalho retorna uma cor diferente do arco-íris.