Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisez l'index des tâches matriciel pour contrôler la différenciation des tâches
<a name="array_index_example"></a>

Ce didacticiel explique comment utiliser la variable d'`AWS_BATCH_JOB_ARRAY_INDEX`environnement pour différencier les emplois pour enfants. Chaque tâche enfant est affectée à cette variable. L'exemple utilise le numéro d'index de la tâche enfant pour lire une ligne spécifique dans un fichier. Ensuite, il remplace le paramètre associé à ce numéro de ligne par une commande dans le conteneur de la tâche. Le résultat est que vous pouvez avoir plusieurs AWS Batch tâches qui exécutent la même image Docker et les mêmes arguments de commande. Cependant, les résultats sont différents car l'index des tâches du tableau est utilisé comme modificateur.

Dans ce didacticiel, vous créez un fichier texte qui contient toutes les couleurs de l'arc-en-ciel, chacune sur sa propre ligne. Vous créez ensuite un script de point d'entrée pour un conteneur Docker qui convertit l'index en une valeur pouvant être utilisée comme numéro de ligne dans le fichier couleur. L'indice commence à zéro, mais les numéros de ligne commencent à un. Créez un Dockerfile qui copie les fichiers de couleur et d'index sur l'image du conteneur et définit `ENTRYPOINT` l'image dans le script du point d'entrée. Le Dockerfile et les ressources sont créés à partir d'une image Docker transmise à Amazon ECR. Vous enregistrez ensuite une définition de tâche qui utilise votre nouvelle image de conteneur, vous soumettez une tâche AWS Batch matricielle avec cette définition de tâche et vous visualisez les résultats.

**Topics**
+ [Conditions préalables](array-tutorial-prereqs.md)
+ [Création d'une image de conteneur](build-index-container.md)
+ [Transférez votre image sur Amazon ECR](push-array-image.md)
+ [Création et enregistrement d'une définition de tâche](create-array-job-def.md)
+ [Soumettre une tâche AWS Batch matricielle](submit-array-job.md)
+ [Afficher les journaux des tâches de votre matrice](#array-tutorial-logs)

# Conditions préalables
<a name="array-tutorial-prereqs"></a>

Ce flux de travail didactique comporte les prérequis suivants :
+ Un environnement AWS Batch informatique. Pour de plus amples informations, veuillez consulter [Création d'un environnement informatique](create-compute-environment.md).
+ Une file AWS Batch d'attente de tâches et un environnement informatique associé. Pour de plus amples informations, veuillez consulter [Création d'une file d'attente de tâches](create-job-queue.md).
+ Ils AWS CLI sont installés sur votre système local. Pour plus d'informations, reportez-vous à la section [>Installation du AWS Command Line Interface dans le](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) *guide de l'AWS Command Line Interface utilisateur*.
+ Docker installé sur votre système local. Pour en savoir plus, consultez la section [À propos de Docker CE](https://docs.docker.com/install/) dans la documentation Docker.

# Création d'une image de conteneur
<a name="build-index-container"></a>

Vous pouvez utiliser le `AWS_BATCH_JOB_ARRAY_INDEX` dans une définition de tâche dans le paramètre de commande. Toutefois, nous vous recommandons de créer une image de conteneur qui utilise plutôt la variable dans un script de point d'entrée. Cette section décrit comment créer une image de conteneur de ce type.

**Pour créer votre image de conteneur Docker**

1. Créez un répertoire à utiliser en tant qu'espace de travail de votre image Docker et accédez à celui-ci.

1. Créez un fichier nommé `colors.txt` dans le répertoire de votre espace de travail et collez-y le texte suivant.

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

1. Créez un fichier nommé `print-color.sh` dans le répertoire de votre espace de travail et collez-y le texte suivant.
**Note**  
La variable `LINE` est définie sur le code `AWS_BATCH_JOB_ARRAY_INDEX` \$1 1 car l'index de tableau commence à 0 mais les numéros de ligne commencent à 1. La `COLOR` variable est définie sur la couleur associée à son numéro de ligne. `colors.txt`

   ```
   #!/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. Créez un fichier nommé `Dockerfile` dans le répertoire de votre espace de travail et collez-y le contenu suivant. Ce Dockerfile copie les fichiers précédents vers votre conteneur et définit le script de point d'entrée à exécuter au lancement du conteneur.

   ```
   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. Générez votre image Docker.

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

1. Testez votre conteneur avec le script suivant. Ce script définit la `AWS_BATCH_JOB_ARRAY_INDEX` variable sur 0 localement, puis l'incrémente pour simuler ce que fait une tâche matricielle avec sept enfants.

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

   En voici la sortie.

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

# Transférez votre image sur Amazon ECR
<a name="push-array-image"></a>

Maintenant que vous avez créé et testé votre conteneur Docker, transférez-le vers un référentiel d'images. Cet exemple utilise Amazon ECR, mais vous pouvez utiliser un autre registre, tel que DockerHub.

1. Créez un référentiel d'images Amazon ECR pour stocker l'image de votre conteneur. Cet exemple utilise uniquement le AWS CLI, mais vous pouvez également utiliser le AWS Management Console. Pour plus d'informations, consultez la section [Création d'un référentiel](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) dans le *guide de l'utilisateur d'Amazon Elastic Container Registry*.

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

1. Marquez votre `print-color` image avec l'URI de votre référentiel Amazon ECR renvoyé à l'étape précédente.

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

1. Connectez-vous à votre registre Amazon ECR. Pour plus d'informations, veuillez consulter [Authentification de registre](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) dans le *Guide de l'utilisateur 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. Transférez votre image sur Amazon ECR.

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

# Création et enregistrement d'une définition de tâche
<a name="create-array-job-def"></a>

Maintenant que votre image Docker se trouve dans un registre d'images, vous pouvez la spécifier dans une définition de AWS Batch tâche. Vous pourrez ensuite l'utiliser ultérieurement pour exécuter une tâche matricielle. Cet exemple utilise uniquement le AWS CLI. Cependant, vous pouvez également utiliser le AWS Management Console. Pour de plus amples informations, veuillez consulter [Création d'une définition de tâche à nœud unique](create-job-definition.md).

**Pour créer une définition de tâche**

1. Créez un fichier nommé `print-color-job-def.json` dans le répertoire de votre espace de travail et collez-y le texte suivant. Remplacez l'URI du référentiel d'images par l'URI de votre image.

   ```
   {
     "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. Enregistrez la définition de tâche auprès de AWS Batch.

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

# Soumettre une tâche AWS Batch matricielle
<a name="submit-array-job"></a>

Après avoir enregistré votre définition de tâche, vous pouvez soumettre une tâche AWS Batch matricielle qui utilise votre nouvelle image de conteneur.

**Pour soumettre une tâche AWS Batch matricielle**

1. Créez un fichier nommé `print-color-job.json` dans le répertoire de votre espace de travail et collez-y le texte suivant.
**Note**  
Cet exemple utilise la file d'attente des tâches mentionnée dans la [Conditions préalables](array-tutorial-prereqs.md) section.

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

1. Soumettez le travail à votre AWS Batch file d'attente. Notez l'ID de tâche renvoyé dans la sortie.

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

1. Décrivez l'état de la tâche et attendez que la tâche passe à `SUCCEEDED`.

## Afficher les journaux des tâches de votre matrice
<a name="array-tutorial-logs"></a>

Une fois que votre tâche a atteint le `SUCCEEDED` statut, vous pouvez consulter les CloudWatch journaux depuis le conteneur de la tâche.

**Pour consulter les journaux de votre travail dans CloudWatch Logs**

1. Ouvrez la AWS Batch console à l'adresse [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. Dans le panneau de navigation de gauche, choisissez **Tâches**.

1. Pour **Files d'attente**, sélectionnez une file d'attente. 

1. Dans la section **État**, choisissez **succès**.

1. Pour afficher toutes les tâches enfants de votre tâche de tableau, sélectionnez l'ID de tâche qui a été renvoyé à la section précédente.

1. Pour afficher les journaux du conteneur de la tâche, sélectionnez l'une des tâches enfants et choisissez **Afficher les journaux**.  
![\[Journaux des conteneurs de tâches Array\]](http://docs.aws.amazon.com/fr_fr/batch/latest/userguide/images/array-logs.png)

1. Affichez les journaux des autres tâches enfants. Chaque tâche renvoie une couleur différente de l'arc-en-ciel.