

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.

# Erstellen oder Ausführen einer Hadoop-Anwendung
<a name="emr-hadoop-application"></a>

**Topics**
+ [

# Erstellen von Binärdateien mit Amazon EMR
](emr-build-binaries.md)
+ [

# Daten per Streaming verarbeiten
](UseCase_Streaming.md)
+ [

# Daten mit einer benutzerdefinierten JAR-Datei verarbeiten
](UseCase_CustomJar.md)

# Erstellen von Binärdateien mit Amazon EMR
<a name="emr-build-binaries"></a>

Sie können Amazon EMR als Build-Umgebung zum Kompilieren von Programmen für die Verwendung in Ihrem Cluster nutzen. Programme, die Sie mit Amazon EMR verwenden, müssen auf einem System kompiliert werden, das dieselbe Linux-Version wie Amazon EMR verwendet. Bei einer 32 Bit-Version sollten Sie die Kompilierung auf einem 32 Bit-Computer oder mit aktivierter 32 Bit-Cross-Compilation-Option durchgeführt haben. Bei einer 64 Bit-Version müssen Sie die Kompilierung auf einem 64 Bit-Computer oder mit aktivierter 64 Bit-Cross-Compilation-Option durchgeführt haben. Weitere Informationen zu EC2-Instance-Versionen finden Sie unter [Planen und Konfigurieren von EC2-Instances](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-ec2-instances.html) im *Verwaltungshandbuch für Amazon EMR*. Unterstützte Programmiersprachen sind unter anderem C\$1\$1, Python und C \$1. 

In der folgenden Tabelle werden die Schritte für das Erstellen und Testen Ihrer Anwendung mit Amazon EMR aufgeführt.


**Prozess zum Erstellen eines Moduls**  

|  |  | 
| --- |--- |
|  1 |  Stellen Sie eine Verbindung mit dem Master-Knoten Ihres Clusters her. | 
|  2  |  Kopieren Sie Quelldateien auf den Master-Knoten. | 
|  3  |  Erstellen Sie Binärdateien mit den erforderlichen Optimierungen. | 
|  4 |  Kopieren Sie die Binärdateien vom Hauptknoten zu Amazon S3. | 

Die Einzelheiten für jeden dieser Schritte finden Sie in den folgenden Abschnitten. 

**So verbinden Sie sich mit dem Master-Knoten des Clusters**
+ Befolgen Sie die Anweisungen unter [Verbindung mit dem Hauptknoten mit SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) im *Verwaltungshandbuch für Amazon EMR*.

**So kopieren Sie Quelldateien auf den Master-Knoten**

1. Platzieren Sie Ihre Quelldateien in einem Amazon-S3-Bucket. Weitere Informationen zum Erstellen von Buckets und zum Verschieben von Daten nach Amazon S3 finden Sie im [Benutzerhandbuch für den Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonS3/latest/userguide/).

1. Erstellen Sie einen Ordner für Ihre Quelldateien auf Ihrem Hadoop-Cluster, indem Sie einen Befehl wie den folgenden eingeben:

   ```
   mkdir SourceFiles
   ```

1. Kopieren Sie Ihre Quelldateien von Amazon S3, auf den Hauptknoten, indem Sie einen Befehl wie den folgenden eingeben:

   ```
   hadoop fs -get s3://amzn-s3-demo-bucket/SourceFiles SourceFiles
   ```

**Erstellen von Binärdateien mit den erforderlichen Optimierungen**  
Die Erstellung Ihrer Binärdateien hängt von vielen Faktoren ab. Befolgen Sie beim Einrichten und Konfigurieren Ihrer Umgebung die Anweisungen zu Ihren Build-Tools. Sie können Hadoop-System-Specification-Befehle nutzen, um Cluster-Informationen zur Definition der Installation Ihrer Build-Umgebung abzurufen.

**So ermitteln Sie Systemspezifikationen**
+ Verwenden Sie die folgenden Befehle, um die zum Erstellen Ihrer Binärdateien verwendete Architektur abzurufen.

  1. Um die Debian-Version abzurufen, geben Sie den folgenden Befehl ein:

     ```
     master$ cat /etc/issue
     ```

     Die Ausgabe sieht folgendermaßen oder ähnlich aus.

     ```
     Debian GNU/Linux 5.0
     ```

  1. Um den öffentlichen DNS-Namen und die Prozessorgröße abzurufen, geben Sie den folgenden Befehl ein:

     ```
     master$ uname -a
     ```

     Die Ausgabe sieht folgendermaßen oder ähnlich aus.

     ```
     Linux domU-12-31-39-17-29-39.compute-1.internal 2.6.21.7-2.fc8xen #1 SMP Fri Feb 15 12:34:28 EST 2008 x86_64 GNU/Linux
     ```

  1. Um die Prozessorgeschwindigkeit abzurufen, geben Sie den folgenden Befehl ein:

     ```
     master$ cat /proc/cpuinfo
     ```

     Die Ausgabe sieht folgendermaßen oder ähnlich aus.

     ```
     processor : 0
     vendor_id : GenuineIntel
     model name : Intel(R) Xeon(R) CPU E5430 @ 2.66GHz
     flags : fpu tsc msr pae mce cx8 apic mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm constant_tsc pni monitor ds_cpl vmx est tm2 ssse3 cx16 xtpr cda lahf_lm
     ...
     ```

Sobald Ihre Binärdateien erstellt sind, können Sie die Dateien in Amazon S3 kopieren.

**So kopieren Sie die Binärdateien vom Hauptknoten zu Amazon S3**
+ Geben Sie den folgenden Befehl ein, um die Binärdateien in Ihren Amazon-S3-Bucket zu kopieren:

  ```
  hadoop fs -put BinaryFiles s3://amzn-s3-demo-bucket/BinaryDestination
  ```

# Daten per Streaming verarbeiten
<a name="UseCase_Streaming"></a>

Hadoop-Streaming ist ein im Lieferumfang von Hadoop integriertes Hilfsprogramm, mit dem Sie MapReduce ausführbare Dateien in anderen Sprachen als Java entwickeln können. Streaming wird als JAR-Datei implementiert. Somit können Sie die Datei wie jede andere JAR-Datei über die Amazon-EMR-API oder die Befehlszeile ausführen. 

In diesem Abschnitt wird die Verwendung von Streaming mit Amazon EMR beschrieben. 

**Anmerkung**  
Apache Hadoop Streaming ist ein unabhängiges Tool. Daher werden seine Funktionen und Parameter hier nicht beschrieben. [Weitere Informationen zum Hadoop-Streaming finden Sie unter http://hadoop.apache. org/docs/stable/hadoop-streaming/HadoopStreaming](http://hadoop.apache.org/docs/stable/hadoop-streaming/HadoopStreaming.html).html.

## Verwenden des Hadoop-Streaming-Dienstprogramms
<a name="HadoopStreamCommands"></a>

In diesem Abschnitt wird die Verwendung des Hadoop-Streaming-Dienstprogramms beschrieben.


**Hadoop-Prozess**  

|  |  | 
| --- |--- |
| 1 |  Schreiben Sie Ihre ausführbare Mapper- und Reducer-Datei in der Programmiersprache Ihrer Wahl. Folgen Sie den Anweisungen in der Dokumentation zu Hadoop, um die ausführbaren Dateien zu schreiben. Die Programme sollten ihre Eingaben über die Standardeingabe lesen und die Daten über die Standardausgabedaten ausgeben. Standardmäßig stellt jede Zeile der Eingabe/Ausgabe einen Datensatz dar. Der erste Tabulator jeder Zeile dient als Trennzeichen zwischen Schlüssel und Wert.  | 
| 2 |  Testen Sie Ihre ausführbaren Dateien lokal und laden Sie sie in Amazon S3 hoch.  | 
| 3 |  Verwenden Sie die Amazon EMR oder die Amazon-EMR-Konsole, um Ihre Anwendung auszuführen.  | 

Jedes Mapper-Skript startet als separater Prozess im Cluster. Jede ausführbare Reducer-Datei wandelt die Ausgabe der ausführbaren Mapper-Datei in die Datenausgabe des Auftragverlaufs um.

Die Parameter `input`, `output`, `mapper` und `reducer` sind für die meisten Streaming-Anwendungen erforderlich. Die folgende Tabelle beschreibt diese und andere (optionale) Parameter.


| Parameter | Description | Erforderlich | 
| --- | --- | --- | 
| -input |  Speicherort der Eingabedaten in Amazon S3. Typ: Zeichenfolge Standard: keiner Beschränkung: URI. Wenn kein Protokoll angegeben wurde, wird das Standarddateisystem des Clusters verwendet.   | Ja | 
| -output |  Speicherort in Amazon S3, in dem Amazon EMR die verarbeiteten Daten hochlädt. Typ: Zeichenfolge Standard: keiner Beschränkung: URI Standard: Wenn kein Speicherort angegeben ist, werden die Daten von Amazon EMR in den von `input` angegebenen Speicherort hochgeladen.  | Ja | 
| -mapper |  Name der ausführbaren Mapper-Datei. Typ: Zeichenfolge Standard: keiner  | Ja | 
| -reducer |  Name der ausführbaren Reducer-Datei. Typ: Zeichenfolge Standard: keiner  | Ja | 
| -cacheFile |  Ein Amazon-S3-Speicherort mit Dateien, die Hadoop in Ihr lokales Arbeitsverzeichnis kopieren soll (in erster Linie zur Verbesserung der Leistung). Typ: Zeichenfolge Standard: keiner Beschränkungen: [URI]\$1[symlink-Name zur Erstellung im Arbeitsverzeichnis]   | Nein | 
| -cacheArchive |  JAR-Datei, die in das Arbeitsverzeichnis extrahiert werden soll Typ: Zeichenfolge Standard: keiner Beschränkungen: [URI]\$1[symlink-Verzeichnisname zur Erstellung im Arbeitsverzeichnis   | Nein | 
| -combiner |  Kombiniert Ergebnisse Typ: Zeichenfolge Standard: keiner Einschränkungen: Java-Klassenname  | Nein | 

Das folgende Codebeispiel ist eine ausführbare Mapper-Datei, die in Python geschrieben ist. Dieses Skript ist Teil der WordCount Beispielanwendung.

```
 1. #!/usr/bin/python
 2. import sys
 3. 
 4. def main(argv):
 5.   line = sys.stdin.readline()
 6.   try:
 7.     while line:
 8.       line = line.rstrip()
 9.       words = line.split()
10.       for word in words:
11.         print "LongValueSum:" + word + "\t" + "1"
12.       line = sys.stdin.readline()
13.   except "end of file":
14.     return None
15. if __name__ == "__main__":
16.   main(sys.argv)
```

# Einen Streaming-Schritt übermitteln
<a name="CLI_CreateStreaming"></a>

In diesem Abschnitt werden die Grundlagen der Übermittlung eines Streaming-Schritts an einen Cluster behandelt. Eine Streaming-Anwendung liest Eingaben aus der Standardeingabe und führt dann ein Skript oder eine ausführbare Datei (der Mapper) für den Eingang aus. Das Ergebnis aus den Eingaben wird lokal gespeichert, in der Regel auf einer Hadoop Distributed File System (HDFS)-Partition. Nachdem alle Eingaben vom Mapper verarbeitet wurden, verarbeitet ein zweites Skript oder eine ausführbare Datei (der Reducer) die Ergebnisse des Mappers. Die Ergebnisse aus dem Reducer werden an die Standardausgabe gesendet. Sie können eine Reihe von Streaming-Schritten verketten, wobei die Ausgaben eines Schritts zur Eingabe eines weiteren Schritts werden. 

Der Mapper und der Reducer können als Datei oder als Java-Klasse referenziert werden. Sie können Mapper und Reducer in einer der unterstützten Sprachen implementieren (zum Beispiel Ruby, Perl, Python, PHP oder Bash).

## Einen Streaming-Schritt mithilfe der Konsole übermitteln
<a name="emr-dev-create-stream-console"></a>

In diesem Beispiel wird beschrieben, wie Sie mithilfe der Amazon-EMR-Konsole einen Streaming-Schritt an einen Cluster übermitteln, der ausgeführt wird.

**So übermitteln Sie einen Streaming-Schritt**

1. Öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr/).

1. Wählen Sie unter **Cluster List (Clusterliste)** den Namen des Clusters aus.

1. Scrollen Sie zum Abschnitt **Steps (Schritte)** und erweitern Sie ihn. Wählen Sie anschließend **Add step (Schritt hinzufügen)** aus.

1. Gehen Sie im Dialogfeld **Add Step** folgendermaßen vor:
   + Wählen Sie unter **Step type (Schritttyp)** die Option **Streaming program (Streaming-Programm)** aus.
   + Übernehmen Sie unter **Name** den Standardnamen (Streaming program) oder geben Sie einen neuen Namen ein.
   + Geben Sie für **Mapper** den Speicherort Ihrer Mapper-Klasse in Hadoop oder einen S3-Bucket ein, in dem sich die ausführbare Mapper-Datei (z. B. ein Python-Programm) befindet. Der Pfadwert muss das Format*BucketName*//haben. *path* *MapperExecutable*
   + Geben Sie für **Reducer** den Speicherort Ihrer Reducer-Klasse in Hadoop oder einen S3-Bucket ein, in dem sich die ausführbare Reducer-Datei (z. B. ein Python-Programm) befindet. Der Pfadwert muss das Format*BucketName*/*path*/haben*MapperExecutable*. Amazon EMR unterstützt das spezielle Schlüsselwort *aggregate*. Weitere Informationen finden Sie in der Aggregate-Bibliothek von Hadoop.
   + Geben Sie unter **Input S3 location (S3-Eingabespeicherort)** den Speicherort Ihrer Eingabedaten ein oder browsen zum Speicherort der Daten. 
   + Unter **S3-Ausgabespeicherort** geben Sie den Namen Ihres Amazon-S3-Ausgabe-Buckets ein oder navigieren zu dem entsprechenden S3-Bucket.
   + Lassen Sie unter **Arguments (Parameter)** das Feld leer.
   + Übernehmen Sie unter **Action on failure (Aktion bei Fehler)** die Standardeinstellung **Continue (Fortfahren)**.

1. Wählen Sie **Hinzufügen** aus. Der Schritt wird in der Konsole mit dem Status "Pending" angezeigt. 

1. Bei Ausführung des Schritts ändert sich dessen Status von Pending zu Running und Completed. Wählen Sie das Symbol **Refresh** über der Spalte "Actions" aus, um den Status zu aktualisieren. 

## AWS CLI
<a name="emr-dev-create-stream-cli"></a>

Diese Beispiele zeigen, wie Sie mithilfe des AWS CLI einen Cluster erstellen und einen Streaming-Schritt einreichen können. 

**Um einen Cluster zu erstellen und einen Streaming-Schritt einzureichen, verwenden Sie den AWS CLI**
+ Um einen Cluster zu erstellen und einen Streaming-Schritt mit dem zu senden AWS CLI, geben Sie den folgenden Befehl ein und *myKey* ersetzen Sie ihn durch den Namen Ihres EC2-Schlüsselpaars. Beachten Sie, dass Ihr Argument für `--files` der Amazon-S3-Pfad zum Speicherort Ihres Skripts und die Argumente für `-mapper` und `-reducer` die Namen der jeweiligen Skriptdateien sein sollten.

  ```
  aws emr create-cluster --name "Test cluster" --release-label emr-7.12.0 --applications Name=Hue Name=Hive Name=Pig --use-default-roles \
  --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \
  --steps Type=STREAMING,Name="Streaming Program",ActionOnFailure=CONTINUE,Args=[--files,pathtoscripts,-mapper,mapperscript,-reducer,reducerscript,aggregate,-input,pathtoinputdata,-output,pathtooutputbucket]
  ```
**Anmerkung**  
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).

  Wenn Sie die Instance-Anzahl ohne den Parameter `--instance-groups` angeben, wird ein einzelner Master-Knoten gestartet. Die verbleibenden Instances werden als Core-Knoten aufgerufen. Alle Knoten verwenden den im Befehl angegebenen Instance-Typ.
**Anmerkung**  
Wenn Sie zuvor nicht die standardmäßige Amazon-EMR-Servicerolle und das EC2-Instance-Profil erstellt haben, geben Sie aws `emr create-default-roles` ein, um sie zu erstellen, bevor Sie den Unterbefehl `create-cluster` eingeben.

  Weitere Informationen zur Verwendung von Amazon EMR-Befehlen finden Sie AWS CLI unter[https://docs.aws.amazon.com/cli/latest/reference/emr](https://docs.aws.amazon.com/cli/latest/reference/emr).

# Daten mit einer benutzerdefinierten JAR-Datei verarbeiten
<a name="UseCase_CustomJar"></a>

Eine benutzerdefinierte JAR-Datei führt ein kompiliertes Java-Programm aus, das Sie in Amazon S3 hochladen. Sie sollten das Programm mit der Hadoop-Version kompilieren, die Sie starten möchten, und senden Sie einen `CUSTOM_JAR`-Schritt an Ihren Amazon-EMR-Cluster. Weitere Informationen zum Kompilieren einer JAR-Datei finden Sie unter [Erstellen von Binärdateien mit Amazon EMR](emr-build-binaries.md).

Weitere Informationen zum Erstellen einer MapReduce Hadoop-Anwendung finden Sie im [MapReduce Tutorial](http://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html) in der Apache Hadoop-Dokumentation.

**Topics**
+ [

# Einen benutzerdefinierten JAR-Schritt übermitteln
](emr-launch-custom-jar-cli.md)

# Einen benutzerdefinierten JAR-Schritt übermitteln
<a name="emr-launch-custom-jar-cli"></a>

Eine benutzerdefinierte JAR-Datei führt ein kompiliertes Java-Programm aus, das Sie in Amazon S3 hochladen. Sie sollten das Programm mit der Hadoop-Version kompilieren, die Sie starten möchten, und senden Sie einen `CUSTOM_JAR`-Schritt an Ihren Amazon-EMR-Cluster. Weitere Informationen zum Kompilieren einer JAR-Datei finden Sie unter [Erstellen von Binärdateien mit Amazon EMR](emr-build-binaries.md).

Weitere Informationen zum Erstellen einer MapReduce Hadoop-Anwendung finden Sie im [MapReduce Tutorial](http://hadoop.apache.org/docs/stable/hadoop-mapreduce-client/hadoop-mapreduce-client-core/MapReduceTutorial.html) in der Apache Hadoop-Dokumentation.

In diesem Abschnitt werden die Grundlagen der Übermittlung eines benutzerdefinierten JAR-Schritts in Amazon EMR behandelt. Wenn Sie einen benutzerdefinierten JAR-Schritt übermitteln, können Sie mit der Java-Programmiersprache ein Skript schreiben, das Ihre Daten verarbeitet. 

## Einen benutzerdefinierten JAR-Schritt mithilfe der Konsole übermitteln
<a name="ConsoleCreatingaCustomJARJob"></a>

In diesem Beispiel wird beschrieben, wie Sie mithilfe der Amazon-EMR-Konsole einen benutzerdefinierten JAR-Schritt an einen aktiven Cluster senden.

**So übermitteln Sie einen benutzerdefinierten JAR-Schritt mithilfe der Konsole**

1. Öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr/).

1. Wählen Sie unter **Cluster List (Clusterliste)** den Namen des Clusters aus.

1. Scrollen Sie zum Abschnitt **Steps (Schritte)** und erweitern Sie ihn. Wählen Sie anschließend **Add step (Schritt hinzufügen)** aus.

1. Gehen Sie im Dialogfeld **Schritt hinzufügen** folgendermaßen vor:
   + Wählen Sie **Custom JAR (Benutzerdefiniertes JAR)** als **Step type (Schritttyp)** aus.
   + Übernehmen Sie unter **Name** den Standardnamen (Custom JAR) oder geben Sie einen neuen Namen ein.
   + Geben Sie unter **JAR S3 location (JAR S3-Speicherort)** den Speicherort Ihrer JAR-Datei ein oder navigieren Sie dorthin. Der JAR-Speicherort kann ein Pfad in S3 oder eine voll qualifizierte Java-Klasse im Klassenpfad sein. 
   + Geben Sie unter **Arguments (Argumente)** Ihre Argumente als durch Leerzeichen getrennte Zeichenfolgen ein oder lassen Sie das Feld leer.
   + Übernehmen Sie unter **Action on failure (Aktion bei Fehler)** die Standardeinstellung **Continue (Fortfahren)**.

1. Wählen Sie **Hinzufügen** aus. Der Schritt wird in der Konsole mit dem Status "Pending" angezeigt. 

1. Bei Ausführung des Schritts ändert sich dessen Status von Pending zu Running und Completed. Wählen Sie das Symbol **Refresh** über der Spalte "Actions" aus, um den Status zu aktualisieren. 

## Starten eines Clusters und Einreichen eines benutzerdefinierten JAR-Schritts mit dem AWS CLI
<a name="emr-dev-create-jar-cli"></a>

**Um einen Cluster zu starten und einen benutzerdefinierten JAR-Schritt einzureichen, verwenden Sie AWS CLI**

Um einen Cluster zu starten und einen benutzerdefinierten JAR-Schritt mit dem zu senden AWS CLI, geben Sie den `create-cluster` Unterbefehl mit dem `--steps` Parameter ein.
+ Um einen Cluster zu starten und einen benutzerdefinierten JAR-Schritt einzureichen, geben Sie den folgenden Befehl ein, *myKey* ersetzen Sie ihn durch den Namen Ihres EC2-Schlüsselpaars und *amzn-s3-demo-bucket* ersetzen Sie ihn durch Ihren Bucket-Namen.

  ```
  aws emr create-cluster --name "Test cluster" --release-label emr-7.12.0 \
  --applications Name=Hue Name=Hive Name=Pig --use-default-roles \
  --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \
  --steps Type=CUSTOM_JAR,Name="Custom JAR Step",ActionOnFailure=CONTINUE,Jar=pathtojarfile,Args=["pathtoinputdata","pathtooutputbucket","arg1","arg2"]
  ```
**Anmerkung**  
Linux-Zeilenfortsetzungszeichen (\$1) sind aus Gründen der Lesbarkeit enthalten. Sie können entfernt oder in Linux-Befehlen verwendet werden. Entfernen Sie sie unter Windows oder ersetzen Sie sie durch ein Caret-Zeichen (^).

  Wenn Sie die Instance-Anzahl ohne den `--instance-groups`-Parameter angeben, wird ein einzelner Primärknoten gestartet. Die verbleibenden Instances werden dabei als Core-Knoten gestartet. Alle Knoten verwenden den im Befehl angegebenen Instance-Typ.
**Anmerkung**  
Wenn Sie zuvor nicht die standardmäßige Amazon-EMR-Servicerolle und das EC2-Instance-Profil erstellt haben, geben Sie `aws emr create-default-roles` ein, um sie zu erstellen, bevor Sie den Unterbefehl `create-cluster` eingeben.

  Weitere Informationen zur Verwendung von Amazon EMR-Befehlen finden Sie AWS CLI unter[https://docs.aws.amazon.com/cli/latest/reference/emr](https://docs.aws.amazon.com/cli/latest/reference/emr).

## Abhängigkeiten von Drittanbietern
<a name="emr-custom-jar-dependency"></a>

Manchmal kann es notwendig sein, es in den MapReduce Klassenpfad aufzunehmen, damit es mit Ihrem Programm JARs verwendet werden kann. Sie haben dafür zwei Möglichkeiten:
+ Fügen Sie `--libjars s3://URI_to_JAR` in den Schrittoptionen für die Vorgehensweise in [Starten eines Clusters und Einreichen eines benutzerdefinierten JAR-Schritts mit dem AWS CLI](#emr-dev-create-jar-cli) ein.
+ Starten Sie den Cluster mit einer geänderten `mapreduce.application.classpath`-Einstellung in `mapred-site.xml`. Verwenden Sie die `mapred-site`-Konfigurationsklassifizierung. Um den Cluster mit dem Schritt using zu erstellen AWS CLI, würde das wie folgt aussehen:

  ```
  aws emr create-cluster --release-label emr-7.12.0 \
  --applications Name=Hue Name=Hive Name=Pig --use-default-roles \
  --instance-type m5.xlarge --instance-count 2  --ec2-attributes KeyName=myKey \
  --steps Type=CUSTOM_JAR,Name="Custom JAR Step",ActionOnFailure=CONTINUE,Jar=pathtojarfile,Args=["pathtoinputdata","pathtooutputbucket","arg1","arg2"] \
  --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json
  ```

  `myConfig.json`:

  ```
  [
      {
        "Classification": "mapred-site",
        "Properties": {
          "mapreduce.application.classpath": "path1,path2"
        }
      }
    ]
  ```

  Die durch Kommas getrennte Liste der Pfade sollte jedem JVM-Klassenpfad für die Aufgabe angehängt werden.