

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.

# Einen Testlauf in Device Farm erstellen
<a name="how-to-create-test-run"></a>

Sie können die Device Farm Farm-Konsole oder die Device Farm Farm-API verwenden AWS CLI, um einen Testlauf zu erstellen. Sie können auch ein unterstütztes Plugin verwenden, z. B. die Jenkins- oder Gradle-Plugins für Device Farm. Weitere Informationen zu den Plugins finden Sie unter [Tools und Plugins](aws-device-farm-tools-plugins.md). Weitere Informationen zu Testläufen finden Sie unter [Ausführungen](test-runs.md).

**Topics**
+ [Voraussetzungen](#how-to-create-test-run-prerequisites)
+ [Erstellen Sie einen Testlauf (Konsole)](#how-to-create-test-run-console)
+ [Erstellen Sie einen Testlauf (AWS CLI)](#how-to-create-test-run-cli)
+ [Erstellen Sie einen Testlauf (API)](#how-to-create-test-run-api)
+ [Nächste Schritte](#how-to-create-test-run-console-next-steps)

## Voraussetzungen
<a name="how-to-create-test-run-prerequisites"></a>

Sie müssen ein Projekt in Device Farm haben. Befolgen Sie die Anweisungen unter [Ein Projekt in AWS Device Farm erstellen](how-to-create-project.md), und kehren Sie dann zu dieser Seite zurück.

## Erstellen Sie einen Testlauf (Konsole)
<a name="how-to-create-test-run-console"></a>

1. Melden Sie sich bei der Device Farm Farm-Konsole unter [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm) an.

1. **Wählen Sie im Navigationsbereich **Mobile Device Testing** und dann Projects aus.**

1. Wenn Sie bereits über ein Projekt verfügen, können Sie Ihre Tests in das Projekt hochladen. Wählen Sie andernfalls **Neues Projekt** aus, geben Sie einen **Projektnamen** ein und wählen Sie dann **Erstellen** aus.

1. Öffnen Sie Ihr Projekt und wählen Sie dann **Create run aus**.

1. (Optional) Geben **Sie unter Run-Einstellungen** im Abschnitt **Runname** einen Namen für Ihren Run ein. Wenn kein Name angegeben wird, benennt die Device Farm-Konsole Ihren Lauf standardmäßig „My Device Farm run“.

1. (Optional) Unter **Ausführungseinstellungen** können Sie im Abschnitt **Job-Timeout** das Ausführungstimeout für Ihren Testlauf angeben. **Wenn Sie eine unbegrenzte Anzahl von Testslots verwenden, vergewissern Sie sich, dass unter Abrechnungsmethode die Option **Unmetered** ausgewählt ist.**

1. Wählen **Sie unter Laufeinstellungen** im Abschnitt **Ausführungstyp** Ihren Ausführungstyp aus. Wählen Sie **Android-App** aus, wenn Sie noch keine App zum Testen bereit haben oder wenn Sie eine Android-App (.apk) testen. Wählen Sie **iOS-App**, wenn Sie eine iOS-App (.ipa) testen. Wählen Sie **Web-App** aus, wenn Sie Webanwendungen testen möchten.

1. **Wählen Sie unter App auswählen** im Abschnitt **App-Auswahloptionen** die Option **Von Device Farm bereitgestellte Beispiel-App auswählen aus**, wenn Sie keine App zum Testen zur Verfügung haben. Wenn Sie Ihre eigene App mitbringen, wählen Sie **Eigene App hochladen** und wählen Sie Ihre Anwendungsdatei aus. Wenn Sie eine iOS-App hochladen, müssen Sie darauf achten, **iOS device (iOS-Gerät)** auszuwählen, und keinen Simulator.

1. Wählen **Sie unter Test konfigurieren** eines der verfügbaren Test-Frameworks aus.
**Anmerkung**  
Wenn Sie keine Tests verfügbar haben, wählen Sie **Built-in: Fuzz (Integriert: Fuzz)** zum Starten einer integrierten Standard-Testreihe. Wenn Sie **Built-in: Fuzz (Integriert: Fuzz)** wählen und die Felder **Event count (Ereignisanzahl)**, **Event throttle (Ereignisdrosselung)** und **Randomizer seed (Randomisierungs-Seed)** angezeigt werden, können Sie die Werte ändern oder beibehalten. 

   Weitere Informationen zu den verfügbaren Testreihen finden Sie unter [Test-Frameworks und integrierte Tests in AWS Device Farm](test-types.md).

1. Wenn Sie **Built-In: Fuzz** nicht ausgewählt haben, wählen Sie unter **Testpaket **auswählen die Option Datei** auswählen aus**. Suchen Sie die Datei, die Ihre Tests enthält, und wählen Sie sie aus.

1. Wählen Sie für Ihre Testumgebung die Option **Test in unserer Standardumgebung** **ausführen oder Test in einer benutzerdefinierten Umgebung** ausführen aus. Weitere Informationen finden Sie unter [Testumgebungen in AWS Device Farm](test-environments.md).

1. Wenn Sie eine benutzerdefinierte Testumgebung verwenden, können Sie optional Folgendes tun:
   + Wenn Sie die Standard-Testspezifikation in einer benutzerdefinierten Testumgebung bearbeiten möchten, wählen Sie **Edit (Bearbeiten)**, um die Standard-YAML-Spezifikation zu aktualisieren.
   + Wenn Sie die Testspezifikation geändert haben, wählen Sie **Als neu speichern**, um sie zu aktualisieren.
   + Sie können Umgebungsvariablen konfigurieren. Die hier angegebenen Variablen haben Vorrang vor allen Variablen, die im übergeordneten Projekt konfiguriert werden können.

1. Führen **Sie unter Geräte auswählen** einen der folgenden Schritte aus:
   + Um einen integrierten Gerätepool zu wählen, für den die Tests ausgeführt werden sollen, wählen Sie für **Device pool (Gerätepool)** die Option **Top Devices (Top-Geräte)**. 
   + Um einen eigenen Gerätepool zu erstellen, für den die Tests ausgeführt werden sollen, befolgen Sie die Anweisungen in [Einen Gerätepool erstellen](how-to-create-device-pool.md) und kehren dann zu dieser Seite zurück.
   + Wenn Sie zuvor bereits einen eigenen Gerätepool erstellt haben, wählen Sie für **Device pool (Gerätepool)** diesen Gerätepool aus. 
   + Wählen Sie **Geräte manuell auswählen** und wählen Sie die gewünschten Geräte aus, für die Sie den Betrieb ausführen möchten. Diese Konfiguration wird nicht gespeichert.

   Weitere Informationen finden Sie unter [Geräteunterstützung in AWS Device FarmGeräte](devices.md).

1. (Optional) Um eine zusätzliche Konfiguration hinzuzufügen, öffnen Sie das **Drop-down-Menü Zusätzliche Konfiguration**. In diesem Abschnitt können Sie einen der folgenden Schritte ausführen:
   + Verwenden Sie das ARN-Feld Ausführungsrolle, um einen ARN für die Ausführungsrolle bereitzustellen oder einen im übergeordneten Projekt konfigurierten zu überschreiben.
   + Um weitere Daten bereitzustellen, die Device Farm während der Ausführung verwenden kann, wählen **Sie neben Zusätzliche Daten hinzufügen** die Option **Datei auswählen aus**, und suchen Sie dann die ZIP-Datei, die die Daten enthält, und wählen Sie sie aus.
   + Um eine zusätzliche App für Device Farm zu installieren, die während der Ausführung verwendet werden soll, wählen **Sie neben Andere Apps installieren** die Option **Datei auswählen aus**. Suchen Sie dann nach der APK- oder IPA-Datei, die die App enthält, und wählen Sie sie aus. Wiederholen Sie diesen Vorgang für alle anderen Apps, die Sie installieren möchten. Sie können die Installationsreihenfolge der Apps per Drag & Drop ändern, nachdem Sie diese hochgeladen haben. 
   + Um anzugeben, ob bei der Ausführung Wi-Fi, Bluetooth, GPS oder NFC aktiviert sein wird, markieren Sie neben **Set radio states (Funkstati einstellen)** die jeweiligen Felder.
   + Geben Sie zur Voreinstellung von Gerätebreite und -länge für den Testlauf neben **Device location (Gerätestandort)** die Koordinaten ein.
   + Um das Geräte-Gebietsschema für die Ausführung voreinzustellen, wählen Sie unter **Gerätegebietsschema das Gebietsschema** aus.
   + Wählen Sie **Videoaufnahme aktivieren** aus, um während des Tests Videos aufzunehmen.
   + Wählen Sie **Erfassung von App-Leistungsdaten aktivieren** aus, um Leistungsdaten vom Gerät zu erfassen.
**Anmerkung**  
Das Einstellen des Funkstatus und des Gebietsschemas des Geräts sind derzeit nur für native Android-Tests verfügbar.
**Anmerkung**  
Wenn Sie private Geräte haben, wird auch die für private Geräte spezifische Konfiguration angezeigt.

1. Wählen Sie unten auf der Seite „**Lauf erstellen**“ aus, um den Lauf zu planen.

Device Farm startet den Lauf, sobald Geräte verfügbar sind, normalerweise innerhalb weniger Minuten. Während Ihres Testlaufs zeigt die Device Farm Farm-Konsole ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/de_de/devicefarm/latest/developerguide/images/df-run-calendar.png) in der Ausführungstabelle ein ausstehendes Symbol an. Jedes Gerät, das gerade ausgeführt wird, beginnt ebenfalls mit dem Symbol „Ausstehend“ und wechselt dann zu Beginn des Tests zum Symbol „![\[Device Farm progress indicator.\]](http://docs.aws.amazon.com/de_de/devicefarm/latest/developerguide/images/df-run-progress.png)Wird ausgeführt“. Nach Abschluss jedes Tests wird neben dem Gerätenamen ein Testergebnissymbol angezeigt. Wenn alle Tests abgeschlossen sind, ändert sich das Symbol für ausstehende Tests neben dem Testlauf in ein Testergebnissymbol.

Informationen zum Beenden des Testlaufs finden Sie unter[Stoppen eines Laufs in AWS Device Farm](how-to-stop-test-runs.md).

## Erstellen Sie einen Testlauf (AWS CLI)
<a name="how-to-create-test-run-cli"></a>

Sie können den verwenden AWS CLI , um einen Testlauf zu erstellen.

**Topics**
+ [Schritt 1: Wählen Sie ein Projekt](#how-to-create-test-run-cli-step1)
+ [Schritt 2: Wählen Sie einen Gerätepool](#how-to-create-test-run-cli-step2)
+ [Schritt 3: Laden Sie Ihre Anwendungsdatei hoch](#how-to-create-test-run-cli-step3)
+ [Schritt 4: Laden Sie Ihr Testskript-Paket hoch](#how-to-create-test-run-cli-step4)
+ [Schritt 5: (Optional) Laden Sie Ihre benutzerdefinierte Testspezifikation hoch](#how-to-create-test-run-cli-step5)
+ [Schritt 6: Einen Testlauf planen](#how-to-create-test-run-cli-step6)

### Schritt 1: Wählen Sie ein Projekt
<a name="how-to-create-test-run-cli-step1"></a>

Sie müssen Ihren Testlauf einem Device Farm Farm-Projekt zuordnen.

1. Führen Sie den Befehl aus, um Ihre Device Farm Farm-Projekte aufzulisten**list-projects**. Wenn Sie über kein Projekt verfügen, finden Sie weitere Informationen unter [Ein Projekt in AWS Device Farm erstellen](how-to-create-project.md).

   Beispiel:

   ```
   aws devicefarm list-projects
   ```

   Die Antwort enthält eine Liste Ihrer Device Farm Farm-Projekte.

   ```
   {
       "projects": [
           {
               "name": "MyProject",
               "arn": "arn:aws:devicefarm:us-west-2:123456789101:project:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
               "created": 1503612890.057
           }
       ]
   }
   ```

1. Wählen Sie ein Projekt aus, das mit dem Testlauf verknüpft werden soll, und notieren Sie sich den zugehörigen Amazon-Ressourcennamen (ARN).

### Schritt 2: Wählen Sie einen Gerätepool
<a name="how-to-create-test-run-cli-step2"></a>

Sie müssen einen Gerätepool auswählen, der mit Ihrem Testlauf verknüpft werden soll.

1. Um Ihre Gerätepools anzuzeigen, führen Sie **list-device-pools** unter Angabe Ihres Projekt-ARN aus.

   Beispiel:

   ```
   aws devicefarm list-device-pools --arn arn:MyProjectARN
   ```

   Die Antwort umfasst die integrierten Gerätefarm-Gerätepools wie**Top Devices**, und alle Gerätepools, die zuvor für dieses Projekt erstellt wurden:

   ```
   {
       "devicePools": [
           {
               "rules": [
                   {
                       "attribute": "ARN",
                       "operator": "IN",
                       "value": "[\"arn:aws:devicefarm:us-west-2::device:example1\",\"arn:aws:devicefarm:us-west-2::device:example2\",\"arn:aws:devicefarm:us-west-2::device:example3\"]"
                   }
               ],
               "type": "CURATED",
               "name": "Top Devices",
               "arn": "arn:aws:devicefarm:us-west-2::devicepool:example",
               "description": "Top devices"
           },
           {
               "rules": [
                   {
                       "attribute": "PLATFORM",
                       "operator": "EQUALS",
                       "value": "\"ANDROID\""
                   }
               ],
               "type": "PRIVATE",
               "name": "MyAndroidDevices",
               "arn": "arn:aws:devicefarm:us-west-2:605403973111:devicepool:example2"
           }
       ]
   }
   ```

1. Wählen Sie einen Gerätepool aus und notieren Sie sich den zugehörigen ARN.

   Sie können auch einen Gerätepool erstellen und dann zu diesem Schritt zurückkehren. Weitere Informationen finden Sie unter [Erstellen Sie einen Gerätepool (AWS CLI)](how-to-create-device-pool.md#how-to-create-device-pool-cli).

### Schritt 3: Laden Sie Ihre Anwendungsdatei hoch
<a name="how-to-create-test-run-cli-step3"></a>

Um Ihre Upload-Anfrage zu erstellen und eine vorsignierte Upload-URL für Amazon Simple Storage Service (Amazon S3) zu erhalten, benötigen Sie:
+ Ihren Projekt-ARN.
+ Name Ihrer App-Datei.
+ Typ des Uploads.

Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/create-upload.html).

1. Führen Sie zum Hochladen einer Datei **create-upload** mit den Parametern `–-project-arn`, `--name` und `--type` aus.

   Das folgende Beispiel erstellt einen Upload für eine Android-App:

   ```
   aws devicefarm create-upload -–project-arn arn:MyProjectArn -–name MyAndroid.apk -–type ANDROID_APP
   ```

   Die Antwort enthält Ihren App-Upload-ARN und eine vorsignierte URL.

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "name": "MyAndroid.apk",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
           "type": "ANDROID_APP",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }
   }
   ```

1. Notieren Sie sich den App-Upload-ARN und die vorsignierte URL.

1. Laden Sie Ihre App-Datei mit der vorsignierten Amazon S3 S3-URL hoch. Dieses Beispiel verwendet **curl** zum Hochladen einer Android-.apk-Datei:

   ```
   curl -T MyAndroid.apk "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

   Weitere Informationen finden Sie unter [Hochladen von Objekten mithilfe von Presigned URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html) im *Amazon Simple Storage Service-Benutzerhandbuch*.

1. Um den Status Ihres App-Uploads zu überprüfen, führen Sie **get-upload** unter Angabe des ARN des App-Uploads aus.

   ```
   aws devicefarm get-upload –-arn arn:MyAppUploadARN
   ```

   Warten Sie, bis der Status in der Antwort **SUCCEEDED** lautet, bevor Sie Ihr Testskript-Paket hochladen.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyAndroid.apk",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "ANDROID_APP",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

### Schritt 4: Laden Sie Ihr Testskript-Paket hoch
<a name="how-to-create-test-run-cli-step4"></a>

Als Nächstes laden Sie Ihr Testskript-Paket hoch.

1. Um Ihre Upload-Anfrage zu erstellen und eine vorsignierte Amazon S3 S3-Upload-URL zu erhalten, führen Sie den **create-upload** Befehl mit den `--type` Parametern `–-project-arn``--name`, und aus.

   Dieses Beispiel erstellt einen Appium Java TestNG-Testpaket-Upload:

   ```
   aws devicefarm create-upload –-project-arn arn:MyProjectARN -–name MyTests.zip –-type APPIUM_JAVA_TESTNG_TEST_PACKAGE
   ```

   Die Antwort enthält Ihren Testpaket-Upload-ARN und eine vorsignierte URL.

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "name": "MyTests.zip",
           "created": 1535738627.195,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL",
           "type": "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }    
   }
   ```

1. Notieren Sie sich den ARN des Testpaket-Uploads und die vorsignierte URL.

1. Laden Sie Ihre Testskript-Paketdatei mit der vorsignierten Amazon S3 S3-URL hoch. Dieses Beispiel verwendet **curl** zum Hochladen einer Appium TestNG-Skript-ZIP-Datei:

   ```
   curl -T MyTests.zip "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

1. Um den Status Ihres Testskript-Paket-Uploads zu überprüfen, führen Sie **get-upload** unter Angabe des ARN des Testpaket-Uploads aus Schritt 1 aus.

   ```
   aws devicefarm get-upload –-arn arn:MyTestsUploadARN
   ```

   Warten Sie, bis der Status in der Antwort **SUCCEEDED** lautet, bevor Sie mit dem nächsten, optionalen Schritt fortfahren.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyTests.zip",
           "created": 1535738627.195,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_PACKAGE",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

### Schritt 5: (Optional) Laden Sie Ihre benutzerdefinierte Testspezifikation hoch
<a name="how-to-create-test-run-cli-step5"></a>

Wenn Sie Ihre Tests in einer Standard-Testumgebung ausführen, können Sie diesen Schritt überspringen.

Device Farm verwaltet eine Standardtestspezifikationsdatei für jeden unterstützten Testtyp. Als Nächstes laden Sie Ihre Standard-Testspezifikation herunter und verwenden sie zum Erstellen eines benutzerdefinierten Testspezifikation-Upload für die Ausführung Ihrer Tests in einer benutzerdefinierten Testumgebung. Weitere Informationen finden Sie unter [Testumgebungen in AWS Device Farm](test-environments.md).

1. Um den Upload-ARN für Ihre Standard-Testspezifikation zu finden, führen Sie **list-uploads** unter Angabe Ihres Projekt-ARN aus.

   ```
   aws devicefarm list-uploads --arn arn:MyProjectARN
   ```

   Die Antwort enthält einen Eintrag für jede Standard-Testspezifikation:

   ```
   {
       "uploads": [
           {
   
               {
                   "status": "SUCCEEDED",
                   "name": "Default TestSpec for Android Appium Java TestNG",
                   "created": 1529498177.474,
                   "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
                   "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
                   "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
               }
           }
       ]
   }
   ```

1. Wählen Sie Ihre Standard-Testspezifikation aus der Liste aus. Notieren Sie deren Upload-ARN.

1. Um Ihre Standard-Spezifikation herunterzuladen, führen Sie **get-upload** unter Angabe des Upload-ARN aus.

   Beispiel:

   ```
   aws devicefarm get-upload –-arn arn:MyDefaultTestSpecARN
   ```

   Die Antwort enthält eine vorsignierte URL zu dem Speicherort, von dem Sie Ihre Standard-Testspezifikation herunterladen können.

1. Dieses Beispiel verwendet **curl**, um die Standard-Testspezifikation herunterzuladen und als Datei unter dem Namen `MyTestSpec.yml` zu speichern:

   ```
   curl "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL" > MyTestSpec.yml
   ```

1. Sie können die Standard-Testspezifikation entsprechend Ihrer Testanforderungen bearbeiten und die abgewandelte Testspezifikation dann in zukünftigen Testläufen verwenden. Überspringen Sie diesen Schritt, um die Standard-Testspezifikation unverändert in einer benutzerdefinierten Testumgebung zu verwenden. 

1. Um einen Upload Ihrer benutzerdefinierten Testspezifikation zu erstellen, führen Sie **create-upload** unter Angabe des Namens und Typs Ihrer Testspezifikation und des Projekt-ARN aus.

   Dieses Beispiel erstellt einen Upload für eine benutzerdefinierte Appium Java TestNG-Testspezifikation:

   ```
   aws devicefarm create-upload --name MyTestSpec.yml --type APPIUM_JAVA_TESTNG_TEST_SPEC --project-arn arn:MyProjectARN
   ```

   Die Antwort enthält den Testspezifikations-Upload-ARN und und die vorsignierte URL:

   ```
   {
       "upload": {
           "status": "INITIALIZED",
           "category": "PRIVATE",
           "name": "MyTestSpec.yml",
           "created": 1535751101.221,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE"
       }
   }
   ```

1. Notieren Sie sich den ARN des Testspezifikations-Uploads und die vorsignierte URL.

1. Laden Sie Ihre Testspezifikationsdatei mit der vorsignierten Amazon S3 S3-URL hoch. In diesem Beispiel wird **curl** eine Appium JavaTest NG-Testspezifikation hochgeladen:

   ```
   curl -T MyTestSpec.yml "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL"
   ```

1. Um den Status Ihres Testspezifikations-Uploads zu überprüfen, führen Sie **get-upload** unter Angabe des ARN des Uploads aus.

   ```
   aws devicefarm get-upload –-arn arn:MyTestSpecUploadARN
   ```

   Warten Sie, bis der Status in der Antwort **SUCCEEDED** lautet, bevor Sie Ihren Testlauf planen.

   ```
   {
       "upload": {
           "status": "SUCCEEDED",
           "name": "MyTestSpec.yml",
           "created": 1535732625.964,
           "url": "https://prod-us-west-2-uploads.s3-us-west-2.amazonaws.com/ExampleURL", 
           "type": "APPIUM_JAVA_TESTNG_TEST_SPEC",
           "arn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345EXAMPLE",
           "metadata": "{"valid": true}"
       }
   }
   ```

   Um Ihre benutzerdefinierte Testspezifikation zu aktualisieren, führen Sie **update-upload** unter Angabe des Upload-ARN für die Testspezifikation aus. Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/update-upload.html).

### Schritt 6: Einen Testlauf planen
<a name="how-to-create-test-run-cli-step6"></a>

Um einen Testlauf mit dem AWS CLI, run, zu planen**schedule-run**, geben Sie Folgendes an:
+ Projekt-ARN von [Schritt 1](#how-to-create-test-run-cli-step1).
+ Gerätepool-ARN von [Schritt 2](#how-to-create-test-run-cli-step2).
+ App-Upload-ARN von [Schritt 3](#how-to-create-test-run-cli-step3).
+ Testpaket-Upload-ARN von [Schritt 4](#how-to-create-test-run-cli-step4).

 Wenn Sie Tests in einer benutzerdefinierten Umgebung ausführen, benötigen Sie außerdem Ihren Testspezifikation-ARN von [Schritt 5](#how-to-create-test-run-cli-step5).

**So planen Sie einen Testlauf in einer Standard-Testumgebung**
+ Führen Sie **schedule-run** unter Angabe von Projekt-ARN, Gerätepool-ARN, Anwendungs-Upload-ARN und Testpaketinformationen aus.

  Beispiel:

  ```
  aws devicefarm schedule-run --project-arn arn:MyProjectARN --app-arn arn:MyAppUploadARN --device-pool-arn arn:MyDevicePoolARN --name MyTestRun --test type=APPIUM_JAVA_TESTNG,testPackageArn=arn:MyTestPackageARN
  ```

  Die Antwort enthält einen Testlauf-ARN, mittels dem Sie den Status Ihres Testlaufs überprüfen können.

  ```
  {
      "run": {
          "status": "SCHEDULING",
          "appUpload": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345appEXAMPLE",
          "name": "MyTestRun",
          "radios": {
              "gps": true,
              "wifi": true,
              "nfc": true,
              "bluetooth": true
          },
          "created": 1535756712.946,
          "totalJobs": 179,
          "completedJobs": 0,
          "platform": "ANDROID_APP",
          "result": "PENDING",
          "devicePoolArn": "arn:aws:devicefarm:us-west-2:123456789101:devicepool:5e01a8c7-c861-4c0a-b1d5-12345devicepoolEXAMPLE",
          "jobTimeoutMinutes": 150,
          "billingMethod": "METERED",
          "type": "APPIUM_JAVA_TESTNG",
          "testSpecArn": "arn:aws:devicefarm:us-west-2:123456789101:upload:5e01a8c7-c861-4c0a-b1d5-12345specEXAMPLE",
          "arn": "arn:aws:devicefarm:us-west-2:123456789101:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE",
          "counters": {
              "skipped": 0,
              "warned": 0,
              "failed": 0,
              "stopped": 0,
              "passed": 0,
              "errored": 0,
              "total": 0
          }
      }
  }
  ```

  Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/schedule-run.html).

**So planen Sie einen Testlauf in einer benutzerdefinierten Testumgebung**
+ Die Schritte sind fast identisch mit denen für die Standard-Testumgebung mit einem zusätzlichen `testSpecArn`-Attribut im Parameter `--test`.

  Beispiel:

  ```
  aws devicefarm schedule-run --project-arn arn:MyProjectARN --app-arn arn:MyAppUploadARN --device-pool-arn arn:MyDevicePoolARN --name MyTestRun --test testSpecArn=arn:MyTestSpecUploadARN,type=APPIUM_JAVA_TESTNG,testPackageArn=arn:MyTestPackageARN
  ```

**So überprüfen Sie den Status Ihres Testlaufs**
+ Verwenden Sie den Befehl **get-run** und geben Sie den Testlauf-ARN an:

  ```
  aws devicefarm get-run --arn arn:aws:devicefarm:us-west-2:111122223333:run:5e01a8c7-c861-4c0a-b1d5-12345runEXAMPLE
  ```

Weitere Informationen finden Sie unter [https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html](https://docs.aws.amazon.com/cli/latest/reference/devicefarm/get-run.html). Informationen zur Verwendung von Device Farm mit dem AWS CLI finden Sie unter[AWS CLI Referenz](cli-ref.md).

## Erstellen Sie einen Testlauf (API)
<a name="how-to-create-test-run-api"></a>

Die Schritte sind dieselben wie im AWS CLI Abschnitt beschrieben. Siehe [Erstellen Sie einen Testlauf (AWS CLI)](#how-to-create-test-run-cli).

Sie benötigen folgende Informationen zum Aufrufen der [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_ScheduleRun.html) API:
+ Projekt-ARN. Siehe [Erstellen Sie ein Projekt (API)](how-to-create-project.md#how-to-create-project-api) und [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateProject.html).
+ App-Upload-ARN. Siehe [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ Testpaket Upload-ARN. Siehe [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).
+ Gerätepool-ARN. Siehe [Einen Gerätepool erstellen](how-to-create-device-pool.md) und [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateDevicePool.html).

**Anmerkung**  
Wenn Sie Tests in einer benutzerdefinierten Testumgebung ausführen, benötigen Sie außerdem Ihren Testspezifikation-Upload-ARN. Weitere Informationen erhalten Sie unter [Schritt 5: (Optional) Laden Sie Ihre benutzerdefinierte Testspezifikation hoch](#how-to-create-test-run-cli-step5) und [https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html](https://docs.aws.amazon.com/devicefarm/latest/APIReference/API_CreateUpload.html).

Hinweise zur Verwendung der Device Farm API finden Sie unter[Device Farm automatisieren](api-ref.md).

## Nächste Schritte
<a name="how-to-create-test-run-console-next-steps"></a>

In der Device Farm Farm-Konsole ![\[Device Farm scheduled a job.\]](http://docs.aws.amazon.com/de_de/devicefarm/latest/developerguide/images/df-run-calendar.png) ändert sich das Uhrsymbol in ein Ergebnissymbol, wie z. B. Erfolg![\[The test succeeded.\]](http://docs.aws.amazon.com/de_de/devicefarm/latest/developerguide/images/df-run-success.png), wenn die Ausführung abgeschlossen ist. Sobald die Tests abgeschlossen sind, wird ein Bericht für den Testlauf angezeigt. Weitere Informationen finden Sie unter [Berichte in AWS Device FarmBerichte](reports.md).

Befolgen Sie zur Nutzung des Berichts die Anweisungen unter [Testberichte in Device Farm anzeigen](how-to-use-reports.md).