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.

# Einrichten von Cluster-Zugriffsberechtigungen mit IAM-Rollen für Servicekonten (IRSA)
<a name="spark-operator-security-irsa"></a>

In diesem Abschnitt wird anhand eines Beispiels veranschaulicht, wie ein Kubernetes-Dienstkonto so konfiguriert wird, dass es eine AWS Identity and Access Management Rolle übernimmt. Pods, die das Dienstkonto verwenden, können dann auf jeden AWS Dienst zugreifen, für den die Rolle Zugriffsberechtigungen besitzt.

Im folgenden Beispiel wird eine Spark-Anwendung ausgeführt, um die Wörter aus einer Datei in Amazon S3 zu zählen. Zu diesem Zweck können Sie IAM-Rollen für Servicekonten (IRSA) einrichten, um Kubernetes-Servicekonten zu authentifizieren und zu autorisieren.

**Anmerkung**  
In diesem Beispiel wird der Namespace „spark-operator“ für den Spark-Operator und für den Namespace verwendet, in den Sie die Spark-Anwendung einreichen.

## Voraussetzungen
<a name="spark-operator-security-irsa-prereqs"></a>

Führen Sie die folgenden Voraussetzungen aus, bevor Sie das Beispiel auf dieser Seite ausführen:
+ [Richten Sie den Spark-Operator ein]().
+ [Den Spark-Operator installieren](spark-operator-gs.md#spark-operator-install).
+ [Erstellen Sie einen Amazon-S3-Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html).
+ Speichern Sie Ihr Lieblingsgedicht in einer Textdatei mit dem Namen `poem.txt` und laden Sie die Datei in Ihren S3-Bucket hoch. Die Spark-Anwendung, die Sie auf dieser Seite erstellen, liest den Inhalt der Textdatei. Weiter Anleitungen zum Hinzufügen von Dateien in S3 finden Sie unter [Upload eines Objekts zu Ihrem Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) im *Benutzerhandbuch zu Amazon Simple Storage Service*.

## Ein Kubernetes-Servicekonto zur Übernahme einer IAM-Rolle konfigurieren
<a name="spark-operator-security-irsa-config"></a>

Gehen Sie wie folgt vor, um ein Kubernetes-Dienstkonto so zu konfigurieren, dass es eine IAM-Rolle annimmt, mit der Pods auf AWS Dienste zugreifen können, für die die Rolle über Zugriffsberechtigungen verfügt.

1. Verwenden Sie nach Abschluss des die[Voraussetzungen](#spark-operator-security-irsa-prereqs), AWS Command Line Interface um eine `example-policy.json` Datei zu erstellen, die nur Lesezugriff auf die Datei ermöglicht, die Sie auf Amazon S3 hochgeladen haben:

   ```
   cat >example-policy.json <<EOF
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "s3:GetObject",
                   "s3:ListBucket"
               ],
               "Resource": [
                   "arn:aws:s3:::my-pod-bucket",
                   "arn:aws:s3:::my-pod-bucket/*"
               ]
           }
       ]
   }
   EOF
   ```

1. Dann erstellen Sie eine IAM-Richtlinie `example-policy`:

   ```
   aws iam create-policy --policy-name example-policy --policy-document file://example-policy.json
   ```

1. Erstellen Sie als Nächstes eine IAM-Rolle `example-role` und verknüpfen Sie sie mit einem Kubernetes-Servicekonto für den Spark-Treiber:

   ```
   eksctl create iamserviceaccount --name driver-account-sa --namespace spark-operator \
   --cluster my-cluster --role-name "example-role" \
   --attach-policy-arn arn:aws:iam::111122223333:policy/example-policy --approve
   ```

1. Erstellen Sie eine Yaml-Datei mit den Cluster-Rollenbindungen, die für das Spark-Treiberservicekonto erforderlich sind:

   ```
   cat >spark-rbac.yaml <<EOF
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     name: driver-account-sa
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: spark-role
   roleRef:
     apiGroup: rbac.authorization.k8s.io
     kind: ClusterRole
     name: edit
   subjects:
     - kind: ServiceAccount
       name: driver-account-sa
       namespace: spark-operator
   EOF
   ```

1. Die Konfigurationen für die Cluster-Rollenbindung anwenden:

   ```
   kubectl apply -f spark-rbac.yaml
   ```

Der Befehl kubectl sollte die erfolgreiche Erstellung des Kontos bestätigen:

```
serviceaccount/driver-account-sa created
clusterrolebinding.rbac.authorization.k8s.io/spark-role configured
```

## Ausführen einer Anwendung über den Spark-Operator
<a name="spark-operator-security-irsa-run"></a>

Nachdem Sie [das Kubernetes-Servicekonto konfiguriert]() haben, können Sie eine Spark-Anwendung ausführen, die die Anzahl der Wörter in der Textdatei zählt, die Sie als Teil von [Voraussetzungen](#spark-operator-security-irsa-prereqs) hochgeladen haben.

1. Erstellen Sie eine neue Datei `word-count.yaml` mit einer `SparkApplication` Definition für Ihre Wortzählanwendung, die auf Amazon EMR Version 6 basiert.

   ```
   cat >word-count.yaml <<EOF
   apiVersion: "sparkoperator.k8s.io/v1beta2"
   kind: SparkApplication
   metadata:
     name: word-count
     namespace: spark-operator
   spec:
     type: Java
     mode: cluster
     image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.10.0:latest"
     imagePullPolicy: Always
     mainClass: org.apache.spark.examples.JavaWordCount
     mainApplicationFile: local:///usr/lib/spark/examples/jars/spark-examples.jar
     arguments:
       - s3://my-pod-bucket/poem.txt
     hadoopConf:
      # EMRFS filesystem
       fs.s3.customAWSCredentialsProvider: com.amazonaws.auth.WebIdentityTokenCredentialsProvider
       fs.s3.impl: com.amazon.ws.emr.hadoop.fs.EmrFileSystem
       fs.AbstractFileSystem.s3.impl: org.apache.hadoop.fs.s3.EMRFSDelegate
       fs.s3.buffer.dir: /mnt/s3
       fs.s3.getObject.initialSocketTimeoutMilliseconds: "2000"
       mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem: "2"
       mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem: "true"
     sparkConf:
       # Required for EMR Runtime
       spark.driver.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.driver.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
       spark.executor.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.executor.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
     sparkVersion: "3.3.1"
     restartPolicy:
       type: Never
     driver:
       cores: 1
       coreLimit: "1200m"
       memory: "512m"
       labels:
         version: 3.3.1
       serviceAccount: my-spark-driver-sa
     executor:
       cores: 1
       instances: 1
       memory: "512m"
       labels:
         version: 3.3.1
   EOF
   ```

   Wenn Sie den Spark-Operator mit einer Version von Version 7 verwenden, passen Sie einige der Konfigurationswerte an:

   ```
   cat >word-count.yaml <<EOF
   apiVersion: "sparkoperator.k8s.io/v1beta2"
   kind: SparkApplication
   metadata:
     name: word-count
     namespace: spark-operator
   spec:
     type: Java
     mode: cluster
     image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-7.7.0:latest"
     imagePullPolicy: Always
     mainClass: org.apache.spark.examples.JavaWordCount
     mainApplicationFile: local:///usr/lib/spark/examples/jars/spark-examples.jar
     arguments:
       - s3://my-pod-bucket/poem.txt
     hadoopConf:
      # EMRFS filesystem
       fs.s3.customAWSCredentialsProvider: com.amazonaws.auth.WebIdentityTokenCredentialsProvider
       fs.s3.impl: com.amazon.ws.emr.hadoop.fs.EmrFileSystem
       fs.AbstractFileSystem.s3.impl: org.apache.hadoop.fs.s3.EMRFSDelegate
       fs.s3.buffer.dir: /mnt/s3
       fs.s3.getObject.initialSocketTimeoutMilliseconds: "2000"
       mapreduce.fileoutputcommitter.algorithm.version.emr_internal_use_only.EmrFileSystem: "2"
       mapreduce.fileoutputcommitter.cleanup-failures.ignored.emr_internal_use_only.EmrFileSystem: "true"
     sparkConf:
       # Required for EMR Runtime
       spark.driver.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/aws-java-sdk-v2/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.driver.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
       spark.executor.extraClassPath: /usr/lib/hadoop-lzo/lib/*:/usr/lib/hadoop/hadoop-aws.jar:/usr/share/aws/aws-java-sdk/*:/usr/share/aws/aws-java-sdk-v2/*:/usr/share/aws/emr/emrfs/conf:/usr/share/aws/emr/emrfs/lib/*:/usr/share/aws/emr/emrfs/auxlib/*:/usr/share/aws/emr/security/conf:/usr/share/aws/emr/security/lib/*:/usr/share/aws/hmclient/lib/aws-glue-datacatalog-spark-client.jar:/usr/share/java/Hive-JSON-Serde/hive-openx-serde.jar:/usr/share/aws/sagemaker-spark-sdk/lib/sagemaker-spark-sdk.jar:/home/hadoop/extrajars/*
       spark.executor.extraLibraryPath: /usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native
     sparkVersion: "3.3.1"
     restartPolicy:
       type: Never
     driver:
       cores: 1
       coreLimit: "1200m"
       memory: "512m"
       labels:
         version: 3.3.1
       serviceAccount: my-spark-driver-sa
     executor:
       cores: 1
       instances: 1
       memory: "512m"
       labels:
         version: 3.3.1
   EOF
   ```

1. Reichen Sie die Spark-Anwendung ein.

   ```
   kubectl apply -f word-count.yaml
   ```

   Der Befehl kubectl sollte eine Bestätigung zurückgeben, dass Sie erfolgreich ein `SparkApplication`-Objekt namens `word-count` erstellt haben.

   ```
   sparkapplication.sparkoperator.k8s.io/word-count configured
   ```

1. Überprüfen Sie die Ereignisse für das `SparkApplication`-Objekt mit dem folgenden Befehl:

   ```
   kubectl describe sparkapplication word-count -n spark-operator
   ```

   Der Befehl kubectl sollte die Beschreibung des `SparkApplication` mit den Ereignissen zurückgeben:

   ```
   Events:
     Type     Reason                               Age                    From            Message
     ----     ------                               ----                   ----            -------
     Normal   SparkApplicationSpecUpdateProcessed  3m2s (x2 over 17h)     spark-operator  Successfully processed spec update for SparkApplication word-count
     Warning  SparkApplicationPendingRerun         3m2s (x2 over 17h)     spark-operator  SparkApplication word-count is pending rerun
     Normal   SparkApplicationSubmitted            2m58s (x2 over 17h)    spark-operator  SparkApplication word-count was submitted successfully
     Normal   SparkDriverRunning                   2m56s (x2 over 17h)    spark-operator  Driver word-count-driver is running
     Normal   SparkExecutorPending                 2m50s                  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] is pending
     Normal   SparkExecutorRunning                 2m48s                  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] is running
     Normal   SparkDriverCompleted                 2m31s (x2 over 17h)    spark-operator  Driver word-count-driver completed
     Normal   SparkApplicationCompleted            2m31s (x2 over 17h)    spark-operator  SparkApplication word-count completed
     Normal   SparkExecutorCompleted               2m31s (x2 over 2m31s)  spark-operator  Executor [javawordcount-fdd1698807392c66-exec-1] completed
   ```

Die Anwendung zählt jetzt die Wörter in Ihrer S3-Datei. Die Anzahl der Wörter finden Sie in den Protokolldateien Ihres Fahrers:

```
kubectl logs pod/word-count-driver -n spark-operator
```

Der Befehl kubectl sollte den Inhalt der Protokolldatei mit den Ergebnissen Ihrer Anwendung zur Wortzählung zurückgeben.

```
INFO DAGScheduler: Job 0 finished: collect at JavaWordCount.java:53, took 5.146519 s
                Software: 1
```

Weitere Informationen zum Einreichen von Anwendungen an Spark über den Spark-Operator finden Sie unter [Using a SparkApplication](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/) in der Dokumentation zum *Kubernetes-Operator für Apache Spark (spark-on-k8s-operator*) unter. GitHub