

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso del índice de trabajo de matriz para controlar la diferenciación de trabajos
<a name="array_index_example"></a>

En este tutorial se describe cómo utilizar la variable de entorno de `AWS_BATCH_JOB_ARRAY_INDEX` para diferenciar los trabajos secundarios. Cada trabajo secundario se asigna a esta variable. El ejemplo utiliza el número de índice del trabajo secundario para leer una línea específica de un archivo. A continuación, sustituye el parámetro asociado a ese número de línea por un comando incluido en el contenedor del trabajo. El resultado es que puede tener varios AWS Batch trabajos que ejecuten la misma imagen de Docker y los mismos argumentos de comando. Sin embargo, los resultados son diferentes porque el índice de trabajos de la matriz se usa como modificador.

En este tutorial, creará un archivo de texto que tiene todos los colores del arco iris, cada uno en su propia línea. A continuación, creará un script de punto de entrada para un contenedor de Docker que convierte el índice en un valor que se puede utilizar como número de línea en el archivo de colores. El índice comienza en cero, pero los números de línea comienzan en uno. Creará un Dockerfile que copia los archivos de colores y de índice en la imagen del contenedor y establece el valor `ENTRYPOINT` de la imagen en el script de punto de entrada. El Dockerfile y los recursos se compilarán en una imagen de Docker que se enviará a Amazon ECR. A continuación, registras una definición de trabajo que usa tu nueva imagen de contenedor, envías un trabajo de AWS Batch matriz con esa definición de trabajo y ves los resultados.

**Topics**
+ [Requisitos previos](array-tutorial-prereqs.md)
+ [Creación de una imagen de contenedor](build-index-container.md)
+ [Enviar la imagen a Amazon ECR](push-array-image.md)
+ [Crear y registrar una definición de trabajo](create-array-job-def.md)
+ [Envíe un trabajo AWS Batch de matriz](submit-array-job.md)
+ [Ver los registros del trabajo de matriz](#array-tutorial-logs)

# Requisitos previos
<a name="array-tutorial-prereqs"></a>

Este flujo de trabajo de tutorial tiene los requisitos previos siguientes:
+ Un entorno AWS Batch informático. Para obtener más información, consulte [Creación de un entorno de computación](create-compute-environment.md).
+ Una cola de AWS Batch trabajos y un entorno informático asociado. Para obtener más información, consulte [Creación de una cola de trabajos](create-job-queue.md).
+ Están AWS CLI instalados en su sistema local. Para obtener más información, consulte [ >Instalación de AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) en la *Guía del usuario de AWS Command Line Interface *.
+ Docker debe estar instalado en el sistema local. Para obtener más información, consulte [About Docker CE](https://docs.docker.com/install/) en la documentación de Docker.

# Creación de una imagen de contenedor
<a name="build-index-container"></a>

Puede utilizar el `AWS_BATCH_JOB_ARRAY_INDEX` en una definición de trabajo en el parámetro de comando. Sin embargo, se recomienda crear una imagen contenedor que utilice la variable en un script de punto de entrada en su lugar. En esta sección, se describe cómo crear dicha imagen de contenedor.

**Para compilar la imagen de contenedor de Docker**

1. Cree un directorio nuevo para utilizarlo como espacio de trabajo de la imagen de Docker y desplácese a él.

1. Cree un archivo denominado `colors.txt` en el directorio del espacio de trabajo y pegue en él el contenido siguiente.

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

1. Cree un archivo denominado `print-color.sh` en el directorio del espacio de trabajo y pegue en él el contenido siguiente.
**nota**  
La variable `LINE` se establece en `AWS_BATCH_JOB_ARRAY_INDEX` \$1 1 debido a que el índice de matriz empieza en 0, pero los números de línea empiezan en 1. La variable `COLOR` se establece en el color de `colors.txt` que está asociado a su número de línea.

   ```
   #!/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. Cree un archivo denominado `Dockerfile` en el directorio del espacio de trabajo y pegue en él el contenido siguiente. Este Dockerfile copia los archivos anteriores en el contenedor y configura el script de punto de entrada para que se ejecute al iniciarse el contenedor.

   ```
   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 la imagen de Docker.

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

1. Pruebe el contenedor con el script siguiente. Este script establece la variable `AWS_BATCH_JOB_ARRAY_INDEX` en 0 localmente y, a continuación, incrementa su valor para simular lo que haría un trabajo de matriz con siete elementos secundarios.

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

   Se genera la siguiente salida.

   ```
   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 la imagen a Amazon ECR
<a name="push-array-image"></a>

Ahora que ha compilado y probado el contenedor de Docker, debe enviarlo a un repositorio de imágenes. En este ejemplo se utiliza Amazon ECR, pero puede utilizar otro registro, como DockerHub.

1. Cree un repositorio de imágenes de Amazon ECR para almacenar la imagen de contenedor. En este ejemplo solo se utiliza el AWS CLI, pero también se puede utilizar el Consola de administración de AWS. Para obtener más información, consulte [Creación de un repositorio](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) en la *Guía del usuario de Amazon Elastic Container Registry*.

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

1. Etiquete la imagen `print-color` con el URI del repositorio de Amazon ECR que se obtuvo del paso anterior.

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

1. Inicie sesión en su registro Amazon ECR. Para obtener más información, consulte [Autenticación de registros](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) en la *Guía del usuario de 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. Envíe la imagen a Amazon ECR.

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

# Crear y registrar una definición de trabajo
<a name="create-array-job-def"></a>

Ahora que su imagen de Docker está en un registro de imágenes, puede especificarla en una definición de AWS Batch trabajo. Posteriormente, puede utilizarlo para ejecutar un trabajo de matriz. En este ejemplo se utiliza la API de AWS CLI. Sin embargo, también puede utilizar la Consola de administración de AWS. Para obtener más información, consulte [Creación de una definición de trabajo de un solo nodo](create-job-definition.md).

**Para crear una definición de trabajo**

1. Cree un archivo denominado `print-color-job-def.json` en el directorio del espacio de trabajo y pegue en él el contenido siguiente. Reemplace el URI del repositorio de imágenes por el URI de su propia imagen.

   ```
   {
     "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 la definición del trabajo con AWS Batch.

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

# Envíe un trabajo AWS Batch de matriz
<a name="submit-array-job"></a>

Después de registrar la definición de su trabajo, puede enviar un trabajo de AWS Batch matriz que utilice su nueva imagen de contenedor.

**Para enviar un trabajo AWS Batch de matriz**

1. Cree un archivo denominado `print-color-job.json` en el directorio del espacio de trabajo y pegue en él el contenido siguiente.
**nota**  
En este ejemplo, se utiliza la cola de trabajos mencionada en la sección [Requisitos previos](array-tutorial-prereqs.md).

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

1. Envíe el trabajo a su lista de AWS Batch trabajos. Anote el ID de trabajo que se devuelve como resultado.

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

1. Describa el estado del trabajo y espere a que el trabajo adopte el valor `SUCCEEDED`.

## Ver los registros del trabajo de matriz
<a name="array-tutorial-logs"></a>

Cuando su trabajo alcance el `SUCCEEDED` estado, podrá ver los CloudWatch registros desde el contenedor del trabajo.

**Para ver los registros de su trabajo en CloudWatch Registros**

1. Abre la AWS Batch consola en [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. En el panel de navegación izquierdo, elija **Jobs (Trabajos)**.

1. En **Job queue (Cola de trabajos)**, seleccione una cola. 

1. En la sección **Status (Estado)**, elija **succeeded (realizado correctamente)**.

1. Para mostrar todos los trabajos secundarios del trabajo de matriz, seleccione el ID de trabajo que se ha obtenido en la sección anterior.

1. Para ver los logs del contenedor del trabajo, seleccione uno de los trabajos secundarios y elija **View logs (Ver logs)**.  
![\[Registros del contenedor de trabajos de matriz\]](http://docs.aws.amazon.com/es_es/batch/latest/userguide/images/array-logs.png)

1. Vea los logs del otro trabajo secundario. Cada trabajo devuelve un color diferente del arco iris.