Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizza l'array job index per controllare la differenziazione dei job
<a name="array_index_example"></a>

Questo tutorial descrive come utilizzare la variabile di `AWS_BATCH_JOB_ARRAY_INDEX` ambiente per differenziare i lavori dei bambini. Ogni lavoro secondario viene assegnato a questa variabile. L'esempio utilizza il numero di indice del lavoro secondario per leggere una riga specifica in un file. Quindi, sostituisce il parametro associato a quel numero di riga con un comando all'interno del contenitore del lavoro. Il risultato è che puoi avere più AWS Batch job che eseguono la stessa immagine Docker e gli stessi argomenti di comando. Tuttavia, i risultati sono diversi perché l'array job index viene utilizzato come modificatore.

In questo tutorial creerai un file di testo contenente tutti i colori dell'arcobaleno, ciascuno su una riga. Quindi, si crea uno script di ingresso per un contenitore Docker che converte l'indice in un valore che può essere utilizzato per un numero di riga nel file a colori. L'indice inizia da zero, ma i numeri di riga iniziano da uno. Crea un Dockerfile che copia i file di colore e indice nell'immagine del contenitore e imposta `ENTRYPOINT` l'immagine nello script di ingresso. Il Dockerfile e le risorse sono creati su un'immagine Docker che viene inviata ad Amazon ECR. Quindi registri una definizione di processo che utilizzi la tua nuova immagine del contenitore, invii un AWS Batch array job con quella definizione di processo e visualizzi i risultati.

**Topics**
+ [

# Prerequisiti
](array-tutorial-prereqs.md)
+ [

# Crea un'immagine del contenitore
](build-index-container.md)
+ [

# Invia la tua immagine ad Amazon ECR
](push-array-image.md)
+ [

# Crea e registra una definizione di lavoro
](create-array-job-def.md)
+ [

# Invia un lavoro AWS Batch di array
](submit-array-job.md)
+ [

## Visualizza i log dei lavori dell'array
](#array-tutorial-logs)

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

Questo flusso di lavoro tutorial presenta i seguenti prerequisiti:
+ Un ambiente AWS Batch di calcolo. Per ulteriori informazioni, consulta [Crea un ambiente di elaborazione](create-compute-environment.md).
+ Una coda AWS Batch di lavoro e l'ambiente di elaborazione associato. Per ulteriori informazioni, consulta [Creare una coda di lavoro](create-job-queue.md).
+ È AWS CLI installato sul sistema locale. Per ulteriori informazioni, vedere [>Installazione di AWS Command Line Interface nella](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) *Guida per l'AWS Command Line Interface utente*.
+ Il Docker installato sul sistema locale. Per ulteriori informazioni, consulta la sezione relativa al [Docker CE](https://docs.docker.com/install/) nella documentazione del Docker.

# Crea un'immagine del contenitore
<a name="build-index-container"></a>

È possibile utilizzarlo `AWS_BATCH_JOB_ARRAY_INDEX` in una definizione di processo nel parametro di comando. Tuttavia, si consiglia di creare un'immagine del contenitore che utilizzi invece la variabile in uno script entrypoint. In questa sezione viene descritto come creare un'immagine del container di questo tipo.

**Per creare l'immagine del container Docker**

1. Crea una nuova directory da utilizzare come WorkSpace dell'immagine Docker e aprila.

1. Create un file denominato `colors.txt` nella directory del workspace e incollate quanto segue al suo interno.

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

1. Crea un file denominato `print-color.sh` nella cartella del tuo spazio di lavoro e incolla quanto segue al suo interno.
**Nota**  
La variabile `LINE` è impostata su `AWS_BATCH_JOB_ARRAY_INDEX` \$11 poiché l'indice dell'array inizia da 0, mentre i numeri di riga iniziano da 1. La `COLOR` variabile è impostata sul colore associato al numero di riga. `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. Crea un file denominato `Dockerfile` nella cartella del tuo spazio di lavoro e incolla il seguente contenuto al suo interno. Questo file copia i file precedenti nel container e imposta lo script entrypoint in modo che venga eseguito all'avvio del container.

   ```
   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. Creazione dell'immagine Docker.

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

1. Esegui il test del container utilizzando lo script riportato di seguito. Questo script imposta la `AWS_BATCH_JOB_ARRAY_INDEX` variabile su 0 localmente e poi la incrementa per simulare il funzionamento di un array job con sette figli.

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

   Di seguito è riportato l'output.

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

# Invia la tua immagine ad Amazon ECR
<a name="push-array-image"></a>

Ora che hai creato e testato il tuo contenitore Docker, inseriscilo in un archivio di immagini. Questo esempio utilizza Amazon ECR, ma è possibile utilizzare un altro registro, ad esempio DockerHub.

1. Crea un archivio di immagini Amazon ECR per archiviare l'immagine del contenitore. Questo esempio utilizza solo il AWS CLI, ma puoi anche usare il. Console di gestione AWS Per ulteriori informazioni, consulta [Creating a repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) nella *Amazon Elastic Container Registry User Guide*.

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

1. Etichetta l'`print-color`immagine con l'URI del repository Amazon ECR restituito dal passaggio precedente.

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

1. Accedi al tuo registro Amazon ECR. Per maggiori informazioni, consulta [Autorizzazioni del registro](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) nella *Guida per l'utente di 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. Invia la tua immagine ad Amazon ECR.

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

# Crea e registra una definizione di lavoro
<a name="create-array-job-def"></a>

Ora che l'immagine Docker si trova in un registro di immagini, puoi specificarla in una definizione di AWS Batch lavoro. Quindi, puoi utilizzarlo in un secondo momento per eseguire un processo di array. Questo esempio utilizza solo AWS CLI. Tuttavia, puoi anche usare Console di gestione AWS. Per ulteriori informazioni, consulta [Creare una definizione di processo a nodo singolo](create-job-definition.md).

**Per creare una definizione del processo**

1. Crea un file denominato `print-color-job-def.json` nella cartella del tuo spazio di lavoro e incolla quanto segue al suo interno. Sostituisci l'URI del repository di immagini con l'URI dell'immagine personalizzata.

   ```
   {
     "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. Registra la definizione del lavoro con AWS Batch.

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

# Invia un lavoro AWS Batch di array
<a name="submit-array-job"></a>

Dopo aver registrato la definizione del processo, è possibile inviare un lavoro di AWS Batch array che utilizzi la nuova immagine del contenitore.

**Per inviare un lavoro AWS Batch di array**

1. Crea un file denominato `print-color-job.json` nella cartella del tuo spazio di lavoro e incolla quanto segue al suo interno.
**Nota**  
Questo esempio utilizza la coda dei lavori menzionata nella [Prerequisiti](array-tutorial-prereqs.md) sezione.

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

1. Invia il lavoro alla tua coda di AWS Batch lavoro. Annota l'ID del lavoro restituito nell'output.

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

1. Descrivi lo stato del processo e attendi che il processo venga impostato su `SUCCEEDED`.

## Visualizza i log dei lavori dell'array
<a name="array-tutorial-logs"></a>

Una volta raggiunto `SUCCEEDED` lo stato del lavoro, puoi visualizzare CloudWatch i log dal contenitore del lavoro.

**Per visualizzare i log del lavoro in Logs CloudWatch**

1. Apri la AWS Batch console all'indirizzo. [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/)

1. Nel riquadro di navigazione a sinistra, scegli **Jobs (Processi)**.

1. In **Job queue (Coda di processi)**, seleziona una coda. 

1. Nella sezione **Status (Stato)**, scegli **succeeded (completato)**.

1. Per visualizzare tutti i processi figlio del processo in array, seleziona l'ID processo restituito nella sezione precedente.

1. Per visualizzare i log del container del processo, seleziona uno dei processi figlio e scegli **View logs (Visualizza log)**.  
![\[Array Job Container logs\]](http://docs.aws.amazon.com/it_it/batch/latest/userguide/images/array-logs.png)

1. Visualizza gli altri log del processo figlio. Ciascun job restituisce un colore diverso dell'arcobaleno.