Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verwenden Sie den Array-Jobindex, um die Jobdifferenzierung zu steuern
<a name="array_index_example"></a>

In diesem Tutorial wird beschrieben, wie Sie die `AWS_BATCH_JOB_ARRAY_INDEX` Umgebungsvariable verwenden, um die untergeordneten Jobs zu unterscheiden. Jeder untergeordnete Job ist dieser Variablen zugewiesen. Das Beispiel verwendet die Indexnummer des untergeordneten Jobs, um eine bestimmte Zeile in einer Datei zu lesen. Dann wird der mit dieser Zeilennummer verknüpfte Parameter durch einen Befehl im Container des Jobs ersetzt. Das Ergebnis ist, dass Sie mehrere AWS Batch Jobs haben können, die dasselbe Docker-Image und dieselben Befehlsargumente ausführen. Die Ergebnisse sind jedoch unterschiedlich, da der Array-Jobindex als Modifikator verwendet wird.

In diesem Tutorial erstellen Sie eine Textdatei, die – jeweils in einer eigenen Zeile stehend – alle Farben des Regenbogens umfasst. Anschließend erstellen Sie ein Einstiegsskript für einen Docker-Container, das den Index in einen Wert konvertiert, der für eine Zeilennummer in der Farbdatei verwendet werden kann. Der Index beginnt bei Null, aber die Zeilennummern beginnen bei Eins. Erstellen Sie ein Dockerfile, das die Farb- und Indexdateien in das Container-Image kopiert und `ENTRYPOINT` für das Bild das Entrypoint-Skript festlegt. Die Docker-Datei und die Ressourcen werden in einem Docker-Image erstellt, das an Amazon ECR übertragen wird. Anschließend registrieren Sie eine Jobdefinition, die Ihr neues Container-Image verwendet, reichen einen AWS Batch Array-Job mit dieser Jobdefinition ein und sehen sich die Ergebnisse an.

**Topics**
+ [

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

# Erstellen Sie ein Container-Image
](build-index-container.md)
+ [

# Übertragen Sie Ihr Bild auf Amazon ECR
](push-array-image.md)
+ [

# Erstellen und registrieren Sie eine Jobdefinition
](create-array-job-def.md)
+ [

# Reichen Sie einen AWS Batch Array-Job ein
](submit-array-job.md)
+ [

## Zeigen Sie Ihre Array-Jobprotokolle an
](#array-tutorial-logs)

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

Für diesen Tutorial-Workflow gelten die folgenden Voraussetzungen:
+ Eine AWS Batch Rechenumgebung. Weitere Informationen finden Sie unter [Erstellen Sie eine Rechenumgebung](create-compute-environment.md).
+ Eine AWS Batch Jobwarteschlange und eine zugehörige Rechenumgebung. Weitere Informationen finden Sie unter [Eine Job-Warteschlange erstellen](create-job-queue.md).
+ Die AWS CLI ist auf Ihrem lokalen System installiert. Weitere Informationen finden Sie unter [>Installation von AWS Command Line Interface im AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) *Benutzerhandbuch*.
+ Das auf dem lokalen System installierte Docker. Weitere Informationen finden Sie unter [Über Docker CE](https://docs.docker.com/install/) in der Docker-Dokumentation.

# Erstellen Sie ein Container-Image
<a name="build-index-container"></a>

Sie können das `AWS_BATCH_JOB_ARRAY_INDEX` in einer Jobdefinition im Befehlsparameter verwenden. Wir empfehlen jedoch, stattdessen ein Container-Image zu erstellen, das die Variable in einem Entrypoint-Skript verwendet. In diesem Abschnitt wird beschrieben, wie Sie ein solches Container-Image erstellen.

**So erstellen Sie ein Docker-Container-Image:**

1. Erstellen Sie ein neues Verzeichnis zur Verwendung als Docker-Image-Workspace und wechseln Sie dort hin.

1. Erstellen Sie eine Datei mit dem Namen `colors.txt` in Ihrem Workspace-Verzeichnis und fügen Sie Folgendes ein.

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

1. Erstellen Sie eine Datei mit dem Namen `print-color.sh` in Ihrem Workspace-Verzeichnis und fügen Sie Folgendes ein.
**Anmerkung**  
Für die `LINE`-Variable ist `AWS_BATCH_JOB_ARRAY_INDEX` \$1 1 festgelegt, da der Array-Index bei 0 beginnt, die Zeilennummern aber bei 1. Die `COLOR` Variable wird auf die Farbe gesetzt`colors.txt`, die ihrer Zeilennummer zugeordnet ist.

   ```
   #!/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. Erstellen Sie eine Datei mit dem Namen `Dockerfile` in Ihrem Workspace-Verzeichnis und fügen Sie den folgenden Inhalt ein. Diese Docker-Datei kopiert die vorherigen Dateien auf Ihren Container und legt fest, dass das entrypoint-Skript ausgeführt wird, wenn der Container gestartet wird.

   ```
   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. Erstellen Sie das Docker-Image.

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

1. Testen Sie den Container mit dem folgenden Skript. Dieses Skript setzt die `AWS_BATCH_JOB_ARRAY_INDEX` Variable lokal auf 0 und erhöht sie dann, um zu simulieren, was ein Array-Job mit sieben untergeordneten Objekten bewirkt.

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

   Im Folgenden wird die Ausgabe dargestellt.

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

# Übertragen Sie Ihr Bild auf Amazon ECR
<a name="push-array-image"></a>

Nachdem Sie Ihren Docker-Container erstellt und getestet haben, können Sie ihn in ein Image-Repository verschieben. In diesem Beispiel wird Amazon ECR verwendet, Sie können jedoch auch eine andere Registrierung verwenden, z. B. DockerHub

1. Erstellen Sie ein Amazon ECR-Image-Repository, um Ihr Container-Image zu speichern. In diesem Beispiel wird nur der verwendet AWS CLI, Sie können aber auch den AWS-Managementkonsole verwenden. Weitere Informationen finden Sie unter [Creating a Repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) im *Amazon Elastic Container Registry-Benutzerhandbuch*.

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

1. Kennzeichnen Sie Ihr `print-color` Bild mit Ihrer Amazon ECR-Repository-URI, die im vorherigen Schritt zurückgegeben wurde.

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

1. Melden Sie sich bei Ihrer Amazon ECR-Registrierung an. Weitere Informationen finden Sie unter [Registry-Authentifizierung](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) im *Benutzerhandbuch zu 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. Pushen Sie Ihr Bild auf Amazon ECR.

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

# Erstellen und registrieren Sie eine Jobdefinition
<a name="create-array-job-def"></a>

Da sich Ihr Docker-Image nun in einer Image-Registry befindet, können Sie es in einer AWS Batch Jobdefinition angeben. Anschließend können Sie es später verwenden, um einen Array-Job auszuführen. In diesem Beispiel wird nur der verwendet AWS CLI. Sie können jedoch auch die verwenden AWS-Managementkonsole. Weitere Informationen finden Sie unter [Erstellen Sie eine Auftragsdefinition mit einem Knoten](create-job-definition.md).

**So erstellen Sie eine Auftragsdefinition:**

1. Erstellen Sie eine Datei mit dem Namen `print-color-job-def.json` in Ihrem Workspace-Verzeichnis und fügen Sie Folgendes ein. Ersetzen Sie den Image-Repository-URI durch den URI des Bildes.

   ```
   {
     "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. Registrieren Sie die Jobdefinition bei AWS Batch.

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

# Reichen Sie einen AWS Batch Array-Job ein
<a name="submit-array-job"></a>

Nachdem Sie Ihre Jobdefinition registriert haben, können Sie einen AWS Batch Array-Job einreichen, der Ihr neues Container-Image verwendet.

**Um einen AWS Batch Array-Job einzureichen**

1. Erstellen Sie eine Datei mit dem Namen `print-color-job.json` in Ihrem Workspace-Verzeichnis und fügen Sie Folgendes ein.
**Anmerkung**  
In diesem Beispiel wird die im [Voraussetzungen](array-tutorial-prereqs.md) Abschnitt erwähnte Job-Warteschlange verwendet.

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

1. Reichen Sie den Job in Ihre AWS Batch Job-Warteschlange ein. Notieren Sie sich die Job-ID, die in der Ausgabe zurückgegeben wird.

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

1. Beschreiben Sie den Status des Auftrags und warten Sie, bis der Auftrag den Status `SUCCEEDED` erhält.

## Zeigen Sie Ihre Array-Jobprotokolle an
<a name="array-tutorial-logs"></a>

Sobald Ihr Job den `SUCCEEDED` Status erreicht hat, können Sie die CloudWatch Protokolle im Container des Jobs einsehen.

**Um die Logs Ihres Jobs in CloudWatch Logs einzusehen**

1. Öffnen Sie die AWS Batch Konsole unter [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).

1. Wählen Sie im linken Navigationsbereich **Aufträge** aus.

1. Wählen Sie für **Auftragswarteschlange** eine Warteschlange aus. 

1. Wählen Sie im Bereich **Status** die Option **erfolgreich** aus.

1. Zum Anzeigen aller untergeordneten Aufträge für den Array-Auftrag wählen Sie die Auftrags-ID aus, die im vorherigen Abschnitt zurückgegeben wurde.

1. Zum Anzeigen der Protokolle aus dem Container des Auftrags wählen Sie einen der untergeordneten Aufträge und dann die Option **Protokolle anzeigen** aus.  
![\[Protokolle des Array-Job-Containers\]](http://docs.aws.amazon.com/de_de/batch/latest/userguide/images/array-logs.png)

1. Zeigen Sie die Protokolle der anderen untergeordneten Protokolle an. Jeder Auftrag gibt eine andere Farbe des Regenbogens zurück.