

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.

# Tutorial: Erste Schritte mit Amazon EMR
<a name="emr-gs"></a>

Gehen Sie durch einen Workflow, um schnell einen Amazon EMR-Cluster einzurichten und eine Spark-Anwendung auszuführen.

## Einrichtung Ihres Amazon EMR-Clusters
<a name="emr-getting-started-overview"></a>

Mit Amazon EMR können Sie in nur wenigen Minuten einen Cluster einrichten, um Daten mit Big-Data-Frameworks zu verarbeiten und zu analysieren. Dieses Tutorial zeigt Ihnen, wie Sie einen Beispielcluster mit Spark starten und wie Sie ein einfaches PySpark Skript ausführen, das in einem Amazon S3 S3-Bucket gespeichert ist. Es behandelt wichtige Amazon-EMR-Aufgaben in drei Workflow-Hauptkategorien: Planen und Konfigurieren, Verwalten und Aufräumen.

Während Sie das Tutorial durcharbeiten, finden Sie Links zu detaillierteren Themen und im [Nächste Schritte](#emr-gs-next-steps) Abschnitt Ideen für weitere Schritte. Bei weiteren Fragen oder Problemen können Sie sich an das Amazon-EMR-Team wenden, indem Sie einen Beitrag im [Diskussionsforum](https://forums.aws.amazon.com/forum.jspa?forumID=52) veröffentlichen.

![\[Workflow-Diagramm für Amazon EMR, das die drei wichtigsten Workflow-Kategorien „Planen und Konfigurieren“, „Verwalten“ und „Aufräumen“ beschreibt.\]](http://docs.aws.amazon.com/de_de/emr/latest/ManagementGuide/images/emr-workflow.png)


**Voraussetzungen**
+ Stellen Sie vor dem Starten eines Amazon-EMR-Clusters sicher, dass Sie die Aufgaben unter [Bevor Sie Amazon EMR einrichten](emr-setting-up.md) ausführen.

**Cost (Kosten)**
+ Der erstellte Beispiel-Cluster wird in einer Live-Umgebung ausgeführt. Für den Cluster fallen nur minimale Gebühren an. Stellen Sie sicher, dass Sie die Bereinigungsaufgaben im letzten Schritt dieses Tutorials ausführen, um zusätzliche Kosten zu vermeiden. Gebühren fallen pro Sekunde gemäß den Amazon-EMR-Preisen an. Die Gebühren variieren auch je nach Region. Weitere Informationen finden Sie unter [Amazon-EMR-Preise](https://aws.amazon.com/emr/pricing).
+ Für kleine Dateien, die Sie in Amazon S3 speichern, können geringe Gebühren anfallen. Einige oder alle Gebühren für Amazon S3 können erlassen werden, wenn Sie sich innerhalb der Nutzungsgrenzen des AWS kostenlosen Kontingents befinden. Weitere Informationen finden Sie unter [Amazon-S3-Preise](https://aws.amazon.com/s3/pricing) und [AWS kostenloses Kontingent](https://aws.amazon.com/free/).

## Schritt 1: Datenressourcen konfigurieren und einen Amazon EMR-Cluster starten
<a name="emr-getting-started-plan-and-configure"></a>

### Speicher für Amazon EMR vorbereiten
<a name="emr-getting-started-prepare-storage"></a>

Wenn Sie Amazon EMR verwenden, können Sie aus einer Vielzahl von Dateisystemen wählen, um Eingabedaten, Ausgabedaten und Protokolldateien zu speichern. In diesem Tutorial verwenden Sie EMRFS zum Speichern von Daten in einem S3-Bucket. EMRFS ist eine Implementierung des Hadoop-Dateisystems, mit der Sie reguläre Dateien in Amazon S3 lesen und schreiben können. Weitere Informationen finden Sie unter [Arbeiten mit Speicher- und Dateisystemen mit Amazon EMR](emr-plan-file-systems.md).

Um einen Bucket zu erstellen, befolgen Sie die Anweisungen unter [Wie wird ein S3 Bucket erstellt?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) im *Konsolen-Benutzerhandbuch zu Amazon Simple Storage Service*. Erstellen Sie den Bucket in derselben AWS Region, in der Sie Ihren Amazon EMR-Cluster starten möchten. Zum Beispiel USA West (Oregon) us-west-2. 

Für Buckets und Ordner, die Sie mit Amazon EMR verwenden, gelten die folgenden Einschränkungen:
+ Namen können Kleinbuchstaben, Zahlen, Bindestriche (-) und Punkte (.) enthalten.
+ Namen dürfen nicht mit Zahlen enden.
+ Bucket-Namen müssen in *allen AWS -Konten eindeutig sein.*
+ Ein Ausgabeordner muss leer sein.

### Bereiten Sie eine Anwendung mit Eingabedaten für Amazon EMR vor
<a name="emr-getting-started-prepare-app"></a>

Die gängigste Methode zur Vorbereitung eines Antrags für Amazon EMR besteht darin, den Antrag und seine Eingabedaten in Amazon S3 hochzuladen. Wenn Sie dann Arbeit an Ihren Cluster senden, geben Sie die Amazon-S3-Speicherorte für Ihr Skript und Ihre Daten an.

In diesem Schritt laden Sie ein PySpark Beispielskript in Ihren Amazon S3 S3-Bucket hoch. Wir haben ein PySpark Skript zur Verfügung gestellt, das Sie verwenden können. Das Skript verarbeitet Inspektionsdaten von Lebensmittelbetrieben und gibt eine Ergebnisdatei in Ihrem S3-Bucket zurück. In der Ergebnisdatei sind die zehn Einrichtungen mit den meisten Verstößen vom Typ „Rot“ aufgeführt.

Sie laden auch Beispieleingabedaten in Amazon S3 hoch, damit das PySpark Skript sie verarbeiten kann. Bei den Eingabedaten handelt es sich um eine modifizierte Version der Inspektionsergebnisse des Gesundheitsministeriums in King County, Washington, von 2006 bis 2020. Weitere Informationen finden Sie unter [King County Open Data: Daten zur Inspektion von Lebensmittelbetrieben](https://data.kingcounty.gov/Health-Wellness/Food-Establishment-Inspection-Data/f29f-zza5). Laden Sie die Restaurantdaten für dieses Tutorial nicht direkt von der King County-Website herunter, da es sich um eine sehr große Datei handelt. Im Folgenden stellen wir einen Download mit einer Datei mit weniger Datensätzen zur Verfügung, um das Tutorial zu vervollständigen. Nachfolgend sehen Sie einige Beispielzeilen aus dem Datensatz.

```
name,inspection_result,inspection_closed_business,violation_type,violation_points
100 LB CLAM,Unsatisfactory,FALSE,BLUE,5
100 PERCENT NUTRICION,Unsatisfactory,FALSE,BLUE,5
7-ELEVEN #2361-39423A,Complete,FALSE,,0
```

**Um das PySpark Beispielskript für EMR vorzubereiten**

1. Kopieren Sie den Beispielcode unten mit einem Editor Ihrer Wahl in eine neue Datei.

   ```
   import argparse
   
   from pyspark.sql import SparkSession
   
   def calculate_red_violations(data_source, output_uri):
       """
       Processes sample food establishment inspection data and queries the data to find the top 10 establishments
       with the most Red violations from 2006 to 2020.
   
       :param data_source: The URI of your food establishment data CSV, such as 's3://amzn-s3-demo-bucket/food-establishment-data.csv'.
       :param output_uri: The URI where output is written, such as 's3://amzn-s3-demo-bucket/restaurant_violation_results'.
       """
       with SparkSession.builder.appName("Calculate Red Health Violations").getOrCreate() as spark:
           # Load the restaurant violation CSV data
           if data_source is not None:
               restaurants_df = spark.read.option("header", "true").csv(data_source)
   
           # Create an in-memory DataFrame to query
           restaurants_df.createOrReplaceTempView("restaurant_violations")
   
           # Create a DataFrame of the top 10 restaurants with the most Red violations
           top_red_violation_restaurants = spark.sql("""SELECT name, count(*) AS total_red_violations 
             FROM restaurant_violations 
             WHERE violation_type = 'RED' 
             GROUP BY name 
             ORDER BY total_red_violations DESC LIMIT 10""")
   
           # Write the results to the specified output URI
           top_red_violation_restaurants.write.option("header", "true").mode("overwrite").csv(output_uri)
   
   if __name__ == "__main__":
       parser = argparse.ArgumentParser()
       parser.add_argument(
           '--data_source', help="The URI for you CSV restaurant data, like an S3 bucket location.")
       parser.add_argument(
           '--output_uri', help="The URI where output is saved, like an S3 bucket location.")
       args = parser.parse_args()
   
       calculate_red_violations(args.data_source, args.output_uri)
   ```

1. Speichern Sie die Datei als `health_violations.py`.

1. Laden Sie Ihre `health_violations.py` in Amazon S3 in den Bucket hoch, den Sie als Voraussetzung für dieses Tutorial erstellt haben. Anweisungen finden Sie unter [Hochladen eines Objekts in Ihren Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket) im *Handbuch „Erste Schritte“ für Amazon Simple Storage Service*.

**Um die Probeneingabedaten für EMR vorzubereiten**

1. Laden Sie die ZIP-Datei [food\$1establishment\$1data.zip](samples/food_establishment_data.zip) herunter.

1. Entpacken und speichern Sie `food_establishment_data.zip` als `food_establishment_data.csv` auf Ihrem Computer.

1. Laden Sie die CSV-Datei in den S3-Bucket hoch, den Sie für dieses Tutorial erstellt haben. Anweisungen finden Sie unter [Hochladen eines Objekts in Ihren Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket) im *Handbuch „Erste Schritte“ für Amazon Simple Storage Service*.

Weitere Informationen zum Einrichten von Daten für EMR finden Sie unter [Eingabedaten für die Verarbeitung mit Amazon EMR vorbereiten](emr-plan-input.md).

### Starten eines Amazon-EMR-Clusters
<a name="emr-getting-started-launch-sample-cluster"></a>

Nachdem Sie einen Speicherort und Ihre Anwendung vorbereitet haben, können Sie einen Amazon-EMR-Beispielcluster starten. In diesem Schritt starten Sie einen Apache-Spark-Cluster mit der neuesten [Amazon-EMR-Version](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-components.html).

------
#### [ Console ]

**Um einen Cluster zu starten, auf dem Spark zusammen mit der Konsole installiert ist**

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr).

1. Wählen Sie im linken Navigationsbereich unter **EMR in EC2** die Option **Cluster** und dann **Cluster erstellen** aus.

1. Notieren Sie sich auf der Seite **Cluster erstellen** die Standardwerte für **Version**, **Instance-Typ**, **Anzahl der Instances** und **Berechtigungen**. Diese Felder werden automatisch mit Werten aufgefüllt, die für Allzweck-Cluster geeignet sind.

1. Geben Sie im Feld **Clustername** einen eindeutigen Clusternamen ein, der Ihnen bei der Identifizierung Ihres Clusters hilft, z. B. *My first cluster* Ihr Clustername darf die Zeichen <, >, \$1, \$1 oder `(Backtick) nicht enthalten.

1. Wählen Sie unter **Anwendungen** die **Spark-Option**, um Spark auf Ihrem Cluster zu installieren.
**Anmerkung**  
Wählen Sie die Anwendungen aus, die Sie in Ihrem Amazon-EMR-Cluster haben möchten, bevor Sie den Cluster starten. Sie können nach dem Start keine Anwendungen zu einem Cluster hinzufügen oder daraus entfernen.

1. Aktivieren Sie unter **Cluster-Protokolle** das Kontrollkästchen Cluster-spezifische Protokolle in Amazon S3 veröffentlichen. Ersetzen Sie den **Amazon-S3-Standortwert** durch den Amazon-S3-Bucket, den Sie erstellt haben, gefolgt von **/logs**. Beispiel, **s3://amzn-s3-demo-bucket/logs**. Durch das Hinzufügen von **/logs** wird ein neuer Ordner namens „logs“ in Ihrem Bucket erstellt, in den Amazon EMR die Protokolldateien Ihres Clusters kopieren kann.

1. Wählen Sie unter **Sicherheitskonfiguration und Berechtigungen** Ihr **EC2-Schlüsselpaar** aus. **Wählen Sie im selben Abschnitt das Dropdownmenü **Servicerolle für Amazon EMR** aus und wählen Sie EMR\$1 aus. DefaultRole** **Wählen Sie dann das Dropdownmenü „**IAM-Rolle für das Instanzprofil**“ und dann „EMR\$1 \$1“ aus. EC2 DefaultRole** 

1. Wählen Sie **Cluster erstellen** aus, um den Cluster zu starten und die Cluster-Detailseite zu öffnen.

1. **Suchen Sie den Cluster-Status neben dem Clusternamen.** Der Status ändert sich von **Starten** zu **Läuft** zu **Wartend**, wenn Amazon EMR den Cluster bereitstellt. Möglicherweise müssen Sie das Aktualisierungs-Symbol auf der rechten Seite betätigen oder Ihren Browser aktualisieren, um Updates zu sehen.

Ihr Clusterstatus ändert sich in **Wartend**, wenn der Cluster betriebsbereit ist, läuft und bereit ist, Arbeit anzunehmen. Weitere Informationen zum Lesen der Cluster-Zusammenfassung finden Sie unter [Status und Details des Amazon EMR-Clusters anzeigen](emr-manage-view-clusters.md). Weitere Informationen zu Cluster-Status finden Sie unter [Verstehen des Cluster-Lebenszyklus](emr-overview.md#emr-overview-cluster-lifecycle).

------
#### [ CLI ]

**Um einen Cluster zu starten, auf dem Spark mit dem installiert ist AWS CLI**

1. Erstellen Sie IAM-Standardrollen, die Sie dann verwenden können, um Ihren Cluster zu erstellen, indem Sie den folgenden Befehl verwenden.

   ```
   aws emr create-default-roles
   ```

   Weitere Informationen zu `create-default-roles` finden Sie in der [AWS CLI -Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/emr/create-default-roles.html).

1. Erstellen Sie einen Spark-Cluster mit dem folgenden Befehl. Geben Sie mit der `--name`-Option einen Namen für Ihren Cluster ein und geben Sie den Namen Ihres EC2-Schlüsselpaars mit der `--ec2-attributes`-Option an.

   ```
   aws emr create-cluster \
   --name "<My First EMR Cluster>" \
   --release-label <emr-5.36.2> \
   --applications Name=Spark \
   --ec2-attributes KeyName=<myEMRKeyPairName> \
   --instance-type m5.xlarge \
   --instance-count 3 \
   --use-default-roles
   ```

   Notieren Sie sich die anderen erforderlichen Werte für `--instance-type`, `--instance-count` und `--use-default-roles`. Diese Werte wurden für Allzweck-Cluster ausgewählt. Weitere Informationen zu `create-cluster` finden Sie in der [AWS CLI -Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/emr/create-cluster.html).
**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 (^).

   Die Ausgabe sollte ungefähr wie die folgende aussehen. Die Ausgabe zeigt `ClusterId` und `ClusterArn` Ihres neuen Clusters. Notieren Sie sich Ihre `ClusterId`. Sie verwenden `ClusterId`, um den Clusterstatus zu überprüfen und Arbeiten einzureichen.

   ```
   {
       "ClusterId": "myClusterId",
       "ClusterArn": "myClusterArn"
   }
   ```

1. Überprüfen Sie Ihren Clusterstatus mit dem folgenden Befehl.

   ```
   aws emr describe-cluster --cluster-id <myClusterId>						
   ```

   Mit dem `Status`-Objekt für Ihren neuen Cluster sollten Sie eine Ausgabe wie die folgende sehen.

   ```
   {
       "Cluster": {
           "Id": "myClusterId",
           "Name": "My First EMR Cluster",
           "Status": {
               "State": "STARTING",
               "StateChangeReason": {
                   "Message": "Configuring cluster software"
               }
           }
        }
   }
   ```

   Der `State`-Wert ändert sich von `STARTING` zu `RUNNING` zu `WAITING`, wenn Amazon EMR den Cluster bereitstellt.

Der Cluster-Status ändert sich zu `WAITING`, in dem ein Cluster betriebsbereit und bereit ist, Arbeit anzunehmen. Weitere Informationen zu Cluster-Status finden Sie unter [Verstehen des Cluster-Lebenszyklus](emr-overview.md#emr-overview-cluster-lifecycle).

------

## Schritt 2: Arbeiten an Ihren Amazon EMR-Cluster einreichen
<a name="emr-getting-started-manage"></a>

### Arbeit einreichen und Ergebnisse ansehen
<a name="emr-getting-started-submit-spark-step"></a>

Nachdem Sie einen Cluster gestartet haben, können Sie Arbeiten an den laufenden Cluster senden, um Daten zu verarbeiten und zu analysieren. In einem *Schritt* reichen Sie Arbeiten an einen Amazon-EMR-Cluster ein. Ein Schritt ist eine Arbeitseinheit, die aus einer oder mehreren Aktionen besteht. Sie könnten beispielsweise einen Schritt zur Berechnung von Werten oder zur Übertragung und Verarbeitung von Daten einreichen. Sie können Schritte beim Erstellen eines Clusters oder an einen laufenden Cluster senden. In diesem Teil des Tutorials übermitteln Sie `health_violations.py` als Schritt an Ihren laufenden Cluster. Weitere Informationen zu Schritten finden Sie unter [Arbeit an einen Amazon EMR-Cluster einreichen](emr-work-with-steps.md).

------
#### [ Console ]

**Um eine Spark-Anwendung als Schritt mit der Konsole einzureichen**

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr).

1. Wählen Sie im linken Navigationsbereich unter **EMR in EC2** die Option **Clusters** aus, und wählen Sie dann den Cluster aus, für den Sie Arbeit einreichen möchten. Der Clusterstatus muss **Wartend** lauten.

1. Wählen Sie **Schritte** und dann **Schritt hinzufügen**.

1. Konfigurieren Sie den Schritt anhand der folgenden Richtlinien:
   + Wählen Sie für **Typ** die Option **Spark-Anwendung** aus. Sie sollten zusätzliche Felder für den **Bereitstellungsmodus**, den **Speicherort der Anwendung** und die Optionen **Spark-Submit sehen.**
   + Geben Sie unter **Name** einen neuen Namen ein. Wenn Sie viele Schritte in einem Cluster haben, hilft Ihnen die Benennung der einzelnen Schritte dabei, den Überblick zu behalten.
   + Behalten **Sie für den Bereitstellungsmodus** den Standardwert **Clustermodus** bei. Weitere Informationen zu Spark-Bereitstellungsmodi finden Sie unter [Übersicht über den Clustermodus](https://spark.apache.org/docs/latest/cluster-overview.html) in der Apache-Spark-Dokumentation.
   + Geben Sie **unter Anwendungsort** den Speicherort Ihres `health_violations.py` Skripts in Amazon S3 ein, z. *s3://amzn-s3-demo-bucket/health\$1violations.py* B.
   + Lassen Sie das Feld mit den **Spark-Submit-Optionen** leer. Weitere Informationen zu den `spark-submit`-Optionen finden Sie unter [Starten von Anwendungen mit spark-submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit). 
   + Geben Sie im Feld **Argumente** die folgenden Argumente und Werte ein:

     ```
     --data_source s3://amzn-s3-demo-bucket/food_establishment_data.csv
     --output_uri s3://amzn-s3-demo-bucket/myOutputFolder
     ```

     *s3://amzn-s3-demo-bucket/food\$1establishment\$1data.csv*Ersetzen Sie es durch die S3-Bucket-URI der Eingabedaten, in denen Sie sie vorbereitet haben[Bereiten Sie eine Anwendung mit Eingabedaten für Amazon EMR vor](#emr-getting-started-prepare-app).

     *amzn-s3-demo-bucket*Ersetzen Sie ihn durch den Namen des Buckets, den Sie für dieses Tutorial erstellt haben, und *myOutputFolder* ersetzen Sie ihn durch einen Namen für Ihren Cluster-Ausgabeordner.
   + Übernehmen Sie unter **Aktion bei Fehler des Schrittes** die Standardeinstellung **Fortfahren**. Auf diese Weise wird der Cluster weiter ausgeführt, wenn der Schritt fehlschlägt.

1. Wählen Sie **Hinzufügen**, um den Schritt zu senden. Der Schritt wird in der Konsole mit dem Status **Ausstehend** angezeigt.

1. Überwachen Sie den Status des Schritts. Der Wert sollte sich von **Ausstehend** zu **Wird ausgeführt** zu **Abgeschlossen** ändern. Um den Status in der Konsole zu aktualisieren, wählen Sie das Aktualisierungssymbol rechts neben dem **Filter** aus. Die Ausführung des Skripts dauert etwa eine Minute. Wenn sich der Status in **Abgeschlossen**, ändert, wurde der Schritt erfolgreich abgeschlossen.

------
#### [ CLI ]

**Um eine Spark-Anwendung als Schritt einzureichen, verwenden Sie AWS CLI**

1. Stellen Sie sicher, dass Sie `ClusterId` des Clusters haben, den Sie in [Starten eines Amazon-EMR-Clusters](#emr-getting-started-launch-sample-cluster) gestartet haben. Sie können Ihre Cluster-ID auch mit dem folgenden Befehl abrufen.

   ```
   aws emr list-clusters --cluster-states WAITING							
   ```

1.  Senden Sie `health_violations.py` als Schritt mit dem `add-steps`-Befehl und Ihrem `ClusterId`.
   + Sie können einen Namen für Ihren Schritt angeben, indem Sie ihn ersetzen*"My Spark Application"*. Ersetzen Sie im `Args` Array *s3://amzn-s3-demo-bucket/health\$1violations.py* durch den Speicherort Ihrer `health_violations.py` Anwendung.
   + *s3://amzn-s3-demo-bucket/food\$1establishment\$1data.csv*Ersetzen Sie es durch den S3-Speicherort Ihres `food_establishment_data.csv` Datensatzes.
   + *s3://amzn-s3-demo-bucket/MyOutputFolder*Ersetzen Sie durch den S3-Pfad Ihres angegebenen Buckets und einen Namen für Ihren Cluster-Ausgabeordner.
   + `ActionOnFailure=CONTINUE` bedeutet, dass der Cluster weiter ausgeführt wird, wenn der Schritt fehlschlägt.

   ```
   aws emr add-steps \
   --cluster-id <myClusterId> \
   --steps Type=Spark,Name="<My Spark Application>",ActionOnFailure=CONTINUE,Args=[<s3://amzn-s3-demo-bucket/health_violations.py>,--data_source,<s3://amzn-s3-demo-bucket/food_establishment_data.csv>,--output_uri,<s3://amzn-s3-demo-bucket/MyOutputFolder>]
   ```

   Weitere Informationen zum Senden von Schritten mithilfe der CLI finden Sie in der [AWS CLI -Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/emr/add-steps.html).

   Nachdem Sie den Schritt eingereicht haben, sollten Sie eine Ausgabe wie die folgende mit einer Liste von `StepIds` sehen. Da Sie einen Schritt eingereicht haben, wird in der Liste nur eine ID angezeigt. Kopieren Sie Ihre Schritt-ID. Sie verwenden Ihre Schritt-ID, um den Status des Schritts zu überprüfen.

   ```
   {
       "StepIds": [
           "s-1XXXXXXXXXXA"
       ]
   }
   ```

1. Fragen Sie den Status Ihres Schritts mit dem `describe-step`-Befehl ab.

   ```
   aws emr describe-step --cluster-id <myClusterId> --step-id <s-1XXXXXXXXXXA>							
   ```

   Die Ausgabe sollte ungefähr wie die folgende aussehen, mit Informationen zu Ihrem Schritt.

   ```
   {
       "Step": {
           "Id": "s-1XXXXXXXXXXA",
           "Name": "My Spark Application",
           "Config": {
               "Jar": "command-runner.jar",
               "Properties": {},
               "Args": [
                   "spark-submit",
                   "s3://amzn-s3-demo-bucket/health_violations.py",
                   "--data_source",
                   "s3://amzn-s3-demo-bucket/food_establishment_data.csv",
                   "--output_uri",
                   "s3://amzn-s3-demo-bucket/myOutputFolder"
               ]
           },
           "ActionOnFailure": "CONTINUE",
           "Status": {
               "State": "COMPLETED"
           }
       }
   }
   ```

   Der `State`-Wert des Schritts ändert sich mit der Ausführung des Schritts von `PENDING` zu `RUNNING` zu `COMPLETED`. Die Ausführung des Schritts dauert etwa eine Minute, sodass Sie den Status möglicherweise einige Male überprüfen müssen.

Sie wissen, dass der Schritt erfolgreich war, wenn sich `State` in `COMPLETED` ändert.

------

Weitere Informationen zum Schrittlebenszyklus finden Sie unter [Ausführen von Schritten zur Verarbeitung von Daten](emr-overview.md#emr-overview-steps).

### Ergebnisse anzeigen
<a name="emr-getting-started-view-results"></a>

Nachdem ein Schritt erfolgreich ausgeführt wurde, können Sie seine Ausgabeergebnisse in Ihrem Amazon-S3-Ausgabeordner anzeigen.

**So sehen Sie die Ergebnisse von `health_violations.py`**

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

1. Wählen Sie den **Bucket-Namen** und dann den Ausgabeordner aus, den Sie beim Absenden des Schritts angegeben haben. Zum Beispiel, *amzn-s3-demo-bucket* und dann*myOutputFolder*. 

1. Stellen Sie sicher, dass die folgenden Elemente in Ihrem Ausgabeordner angezeigt werden:
   + Ein kleines Objekt namens `_SUCCESS`.
   + Eine CSV-Datei, die mit dem Präfix `part-` beginnt, die Ihre Ergebnisse enthält.

1. Wählen Sie das Objekt mit Ihren Ergebnissen aus und klicken Sie dann auf **Herunterladen**, um die Ergebnisse in Ihrem lokalen Dateisystem zu speichern.

1. Öffnen Sie die Ergebnisse in Ihrem Editor Ihrer Wahl. In der Ausgabedatei sind die zehn Lebensmittelbetriebe mit den meisten roten Verstößen aufgeführt. Die Ausgabedatei zeigt auch die Gesamtzahl der roten Verstöße für jeden Betrieb.

   Es folgt ein Beispiel für ein `health_violations.py`-Ergebnis.

   ```
   name, total_red_violations
   SUBWAY, 322
   T-MOBILE PARK, 315
   WHOLE FOODS MARKET, 299
   PCC COMMUNITY MARKETS, 251
   TACO TIME, 240
   MCDONALD'S, 177
   THAI GINGER, 153
   SAFEWAY INC #1508, 143
   TAQUERIA EL RINCONSITO, 134
   HIMITSU TERIYAKI, 128
   ```

Weitere Informationen zur Amazon-EMR-Clusterausgabe finden Sie unter [Einen Speicherort für die Amazon EMR-Clusterausgabe konfigurieren](emr-plan-output.md).

### (Optional) Stellen Sie eine Verbindung zu Ihrem laufenden Amazon-EMR-Cluster her
<a name="emr-getting-started-connect-to-cluster"></a>

Wenn Sie Amazon EMR verwenden, möchten Sie möglicherweise eine Verbindung zu einem laufenden Cluster herstellen, um Protokolldateien zu lesen, den Cluster zu debuggen oder CLI-Tools wie die Spark-Shell zu verwenden. Mit Amazon EMR können Sie mithilfe des Secure Shell (SSH)-Protokolls eine Verbindung zu einem Cluster herstellen. In diesem Abschnitt erfahren Sie, wie Sie SSH konfigurieren, eine Verbindung zu Ihrem Cluster herstellen und Protokolldateien für Spark anzeigen. Weitere Informationen zum Herstellen einer Verbindung mit einem Cluster finden Sie unter [Authentifizieren von Amazon-EMR-Cluster-Knoten](emr-authenticate-cluster-connections.md).

#### Autorisieren von SSH-Verbindungen zu Ihrem Cluster
<a name="emr-getting-started-restrict-ssh"></a>

Bevor Sie eine Verbindung zu Ihrem Cluster herstellen, müssen Sie Ihre Cluster-Sicherheitsgruppen ändern, um eingehende SSH-Verbindungen zu autorisieren. Amazon-EC2-Sicherheitsgruppen fungieren als virtuelle Firewalls für Ihre Instances zur Steuerung des ein- und ausgehenden Datenverkehrs zu Ihrem Cluster. Als Sie Ihren Cluster für dieses Tutorial erstellt haben, hat Amazon EMR in Ihrem Namen die folgenden Sicherheitsgruppen erstellt:

**ElasticMapReduce-Meister**  
Die standardmäßige verwaltete Amazon-EMR-Sicherheitsgruppe, die mit dem Primärknoten verknüpft ist. In einem Amazon-EMR-Cluster ist der Primärknoten eine Amazon-EC2-Instance, die den Cluster verwaltet.

**ElasticMapReduce-Sklave**  
Die Standardsicherheitsgruppe, die Core- und Aufgabenknoten zugeordnet ist.

------
#### [ Console ]

**Um SSH-Zugriff für vertrauenswürdige Quellen für die primäre Sicherheitsgruppe mit der Konsole zu ermöglichen**

Um Ihre Sicherheitsgruppen zu bearbeiten, benötigen Sie die Berechtigung, Sicherheitsgruppen für die VPC zu verwalten, in der sich der Cluster befindet. Weitere Informationen finden Sie im *IAM-Benutzerhandbuch* unter [Ändern von Benutzerberechtigungen](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html) und unter [Beispielrichtlinie](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_examples_ec2_securitygroups-vpc.html), die die Verwaltung von EC2-Sicherheitsgruppen ermöglicht.

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr).

1. Wählen Sie im linken Navigationsbereich unter **EMR in EC2** die Option **Cluster** und dann den Cluster aus, den Sie aktualisieren möchten. Dadurch wird die Cluster-Detailseite geöffnet. Die Registerkarte **Eigenschaften** auf dieser Seite sollte vorausgewählt sein.

1. Wählen Sie auf der Registerkarte **Eigenschaften** unter **Netzwerk** den Pfeil neben **EC2-Sicherheitsgruppen (Firewall) aus, um diesen Abschnitt** zu erweitern. Wählen Sie unter **Primärknoten** den Link zur Sicherheitsgruppe aus. Wenn Sie die folgenden Schritte abgeschlossen haben, können Sie optional zu diesem Schritt zurückkehren, **Core- und Aufgabenknoten** auswählen und die folgenden Schritte wiederholen, um dem SSH-Client Zugriff auf Core- und Aufgabenknoten zu gewähren.

1. Daraufhin wird die EC2-Konsole geöffnet. Wählen Sie die Registerkarte **Eingehende Regeln** und anschließend **Eingehende Regeln bearbeiten** aus.

1. Suchen Sie mit den folgenden Einstellungen nach einer Regel für eingehenden Datenverkehr, die öffentlichen Zugriff ermöglicht. Falls sie existiert, wählen Sie **Löschen**, um sie zu entfernen.
   + **Typ**

     SSH
   + **Port**

     22
   + **Quelle**

     Benutzerdefiniert 0.0.0.0/0
**Warnung**  
Vor Dezember 2020 verfügte die Sicherheitsgruppe ElasticMapReduce -master über eine vorkonfigurierte Regel, die eingehenden Datenverkehr auf Port 22 aus allen Quellen zuließ. Diese Regel wurde erstellt, um die ersten SSH-Verbindungen zum Hauptknoten zu vereinfachen. Wir empfehlen Ihnen dringend, diese Eingangsregel zu entfernen und den Datenverkehr auf vertrauenswürdige Quellen zu beschränken.

1. Scrollen Sie zum Ende der Regelliste und wählen Sie **Regel hinzufügen**.

1. Wählen Sie für **Type (Typ)** **SSH** aus. Wenn Sie SSH auswählen, wird automatisch **TCP** für **Protokoll** und **22** für **Portbereich** eingegeben.

1. Wählen Sie als Quelle **Meine IP** aus, um Ihre IP-Adresse automatisch als Quelladresse hinzuzufügen. Sie können auch einen Bereich **benutzerdefinierter** vertrauenswürdiger Client-IP-Adressen hinzufügen oder zusätzliche Regeln für andere Clients erstellen. In vielen Netzwerkumgebungen werden IP-Adressen dynamisch zugewiesen, sodass Sie in Zukunft möglicherweise Ihre IP-Adressen für vertrauenswürdige Clients aktualisieren müssen.

1. Wählen Sie **Speichern**.

1. Wählen Sie optional **Core- und Aufgabenknoten** aus der Liste aus und wiederholen Sie die obigen Schritte, um dem SSH-Client Zugriff auf Core- und Aufgabenknoten zu gewähren.

------

#### Connect zu Ihrem Cluster her, indem Sie AWS CLI
<a name="emr-getting-started-connect-ssh"></a>

Unabhängig von Ihrem Betriebssystem können Sie mit dem AWS CLI eine SSH-Verbindung zu Ihrem Cluster herstellen.

**Um eine Verbindung zu Ihrem Cluster herzustellen und Protokolldateien anzuzeigen, verwenden Sie AWS CLI**

1. Stellen Sie mit dem folgenden Befehl eine SSH-Verbindung zu Ihrem Cluster her. *<mykeypair.key>*Ersetzen Sie durch den vollständigen Pfad und Dateinamen Ihrer Schlüsselpaardatei. Beispiel, `C:\Users\<username>\.ssh\mykeypair.pem`.

   ```
   aws emr ssh --cluster-id <j-2AL4XXXXXX5T9> --key-pair-file <~/mykeypair.key>						
   ```

1. Navigieren Sie zu `/mnt/var/log/spark`, um auf die Spark-Protokolle auf dem Hauptknoten Ihres Clusters zuzugreifen. Sehen Sie sich dann die Dateien an diesem Speicherort an. Eine Liste zusätzlicher Protokolldateien auf dem Hauptknoten finden Sie unter [Protokolldateien auf dem Primärknoten anzeigen](emr-manage-view-web-log-files.md#emr-manage-view-web-log-files-master-node).

   ```
   cd /mnt/var/log/spark
   ls
   ```

### Verwenden Sie Amazon SageMaker AI Unified Studio, um Ihren Amazon EMR-Cluster zu verwalten
<a name="emr-getting-started-connect-to-cluster-sagemaker"></a>

 Amazon EMR on EC2 ist auch ein unterstützter Berechnungstyp für Amazon SageMaker AI Unified Studio. Informationen zur Verwendung und [Verwaltung von EMR auf EC2-Ressourcen in Unified Studio finden Sie unter Amazon](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/managing-emr-on-ec2.html) EMR auf EC2 verwalten. Amazon SageMaker AI 

## Schritt 3: Ihre Amazon-EMR-Ressourcen bereinigen
<a name="emr-getting-started-clean-up"></a>

### So beenden Sie Ihren Cluster
<a name="emr-getting-started-stop-cluster"></a>

Nachdem Sie Arbeiten an Ihren Cluster übermittelt und die Ergebnisse Ihrer PySpark Bewerbung eingesehen haben, können Sie den Cluster beenden. Durch das Beenden eines Clusters werden alle mit dem Cluster verbundenen Amazon-EMR-Gebühren und Amazon-EC2-Instances gestoppt.

Wenn Sie einen Cluster kündigen, speichert Amazon EMR Metadaten über den Cluster zwei Monate lang kostenlos. Archivierte Metadaten helfen Ihnen dabei, [den Cluster für einen neuen Auftrag zu klonen](clone-console.md) oder die Cluster-Konfiguration zu Referenzzwecken wiederaufzugreifen. Zu den Metadaten gehören *keine* Daten, die der Cluster in S3 schreibt, oder Daten, die in HDFS auf dem Cluster gespeichert sind. 

**Anmerkung**  
Mit der Amazon-EMR-Konsole können Sie nach dem Beenden des Clusters keinen Cluster aus der Listenansicht löschen. Ein beendeter Cluster verschwindet von der Konsole, wenn Amazon EMR seine Metadaten löscht. 

------
#### [ Console ]

**Um den Cluster mit der Konsole zu beenden**

1. Melden Sie sich bei der AWS-Managementkonsole an und öffnen Sie die Amazon EMR-Konsole unter [https://console.aws.amazon.com/emr](https://console.aws.amazon.com/emr).

1. Wählen Sie **Clusters** und dann den Cluster aus, den Sie beenden möchten.

1. Wählen Sie im Dropdownmenü **Aktionen** die Option **Cluster beenden** aus.

1. Wählen Sie im Dialogfenster **Beenden**. Je nach Clusterkonfiguration kann die Kündigung 5 bis 10 Minuten dauern. Weitere Informationen zum Amazon-EMR-Cluster finden Sie unter [Beenden Sie einen Amazon EMR-Cluster im Status „Start“, „Wird ausgeführt“ oder „Wartend“](UsingEMR_TerminateJobFlow.md).

------
#### [ CLI ]

**Um den Cluster zu beenden mit AWS CLI**

1. Initiieren Sie den Vorgang zur Clusterbeendigung mit dem folgenden Befehl. *<myClusterId>*Ersetzen Sie durch die ID Ihres Beispiel-Clusters. Der Befehl gibt keine Ausgabe zurück.

   ```
   aws emr terminate-clusters --cluster-ids <myClusterId>
   ```

1. Um zu überprüfen, ob der Clusterbeendigungsprozess im Gange ist, überprüfen Sie den Clusterstatus mit dem folgenden Befehl.

   ```
   aws emr describe-cluster --cluster-id <myClusterId>									
   ```

   Im Folgenden finden Sie eine Beispielausgabe im JSON-Format. Der Cluster `Status` sollte sich von **`TERMINATING`** zu **`TERMINATED`** ändern. Die Beendigung kann je nach Clusterkonfiguration 5 bis 10 Minuten dauern. Weitere Informationen zum Beenden eines Amazon-EMR-Clusters finden Sie unter [Beenden Sie einen Amazon EMR-Cluster im Status „Start“, „Wird ausgeführt“ oder „Wartend“](UsingEMR_TerminateJobFlow.md).

   ```
   {
       "Cluster": {
           "Id": "j-xxxxxxxxxxxxx",
           "Name": "My Cluster Name",
           "Status": {
               "State": "TERMINATED",
               "StateChangeReason": {
                   "Code": "USER_REQUEST",
                   "Message": "Terminated by user request"
               }
           }
       }
   }
   ```

------

### Löschen von S3-Ressourcen
<a name="emr-getting-started-delete-bucket"></a>

Um zusätzliche Gebühren zu vermeiden, sollten Sie Ihren Amazon-S3-Bucket löschen. Durch das Löschen des Buckets werden alle Amazon-S3-Ressourcen für dieses Tutorial entfernt. Ihr Bucket sollte Folgendes enthalten:
+ Das PySpark Skript
+ Der Eingabedatensatz
+ Ihr Ordner mit den Ausgabeergebnissen
+ Ihr Ordner für Protokolldateien

Möglicherweise müssen Sie zusätzliche Schritte unternehmen, um gespeicherte Dateien zu löschen, wenn Sie PySpark das Skript oder die Ausgabe an einem anderen Ort gespeichert haben.

**Anmerkung**  
Ihr Cluster muss beendet werden, bevor Sie Ihren Bucket löschen können. Andernfalls dürfen Sie den Bucket möglicherweise nicht leeren.

Um Ihren Bucket zu löschen, befolgen Sie die Anweisungen unter [Wie lösche ich einen S3-Bucket?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) im *Benutzerhandbuch zu Amazon Simple Storage Service.*

## Nächste Schritte
<a name="emr-gs-next-steps"></a>

Sie haben jetzt Ihren ersten Amazon-EMR-Cluster von Anfang bis Ende gestartet. Sie haben auch wichtige EMR-Aufgaben wie das Vorbereiten und Einreichen von Big-Data-Anwendungen, das Anzeigen von Ergebnissen und das Beenden eines Clusters erledigt. 

Verwenden Sie die folgenden Themen, um mehr über zu erfahren, wie Sie Ihren Amazon-EMR-Workflow anpassen können.

### Erkunden Sie Big-Data-Anwendungen für Amazon EMR
<a name="emr-gs-next-explore-apps"></a>

Entdecken und vergleichen Sie die Big-Data-Anwendungen, die Sie auf einem Cluster installieren können, im [Amazon-EMR-Versionshandbuch](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-components.html). Der Versionshandbuch beschreibt jede EMR-Version und enthält Tipps zur Verwendung von Frameworks wie Spark und Hadoop auf Amazon EMR.

### Planen Sie Cluster-Hardware, Netzwerke und Sicherheit
<a name="emr-gs-next-plan-clusters"></a>

In diesem Tutorial haben Sie einen einfachen EMR-Cluster erstellt, ohne erweiterte Optionen zu konfigurieren. Mit den erweiterten Optionen können Sie Amazon-EC2-Instance-Typen, Cluster-Netzwerke und Cluster-Sicherheit angeben. Weitere Informationen zur Planung und Einführung eines Clusters, der Ihren Anforderungen entspricht, finden Sie unter [Planung, Konfiguration und Start von Amazon EMR-Clustern](emr-plan.md) und [Sicherheit in Amazon EMR](emr-security.md).

### Verwalten von Clustern
<a name="emr-gs-next-manage-clusters"></a>

Erfahren Sie mehr über die Arbeit mit laufenden Clustern unter [Amazon EMR-Cluster verwalten](emr-manage.md). Um einen Cluster zu verwalten, können Sie eine Verbindung zum Cluster herstellen, Schritte debuggen und die Clusteraktivitäten und den Zustand verfolgen. Mit [EMR-verwalteter Skalierung](emr-managed-scaling.md) können Sie die Clusterressourcen auch an die Workload-Anforderungen anpassen.

### Verwenden Sie eine andere Schnittstelle
<a name="emr-gs-next-interfaces"></a>

Zusätzlich zur Amazon EMR-Konsole können Sie Amazon EMR mithilfe der AWS Command Line Interface, der Webservice-API oder einer der vielen unterstützten verwalten. AWS SDKs Weitere Informationen finden Sie unter [Verwaltungsschnittstellen](emr-overview-benefits.md#emr-what-tools).

Sie können auch auf vielfältige Weise mit Anwendungen interagieren, die auf Amazon-EMR-Clustern installiert sind. Einige Anwendungen wie Apache Hadoop veröffentlichen Weboberflächen, die Sie sich ansehen können. Weitere Informationen finden Sie unter [Anzeigen von auf Amazon-EMR-Clustern gehosteten Webschnittstellen](emr-web-interfaces.md).

### Stöbern Sie im technischen Blog von EMR
<a name="emr-gs-next-browse-blogs"></a>

Exemplarische Vorgehensweisen und ausführliche technische Diskussionen zu den neuen Amazon-EMR-Features finden Sie im [AWS -Big-Data-Blog](https://aws.amazon.com/blogs/big-data/tag/amazon-emr/).