Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Configuration des autorisations d'accès au cluster avec des rôles IAM pour les comptes de service (IRSA)
<a name="spark-operator-security-irsa"></a>

Cette section utilise un exemple pour montrer comment configurer un compte de service Kubernetes pour qu'il assume un rôle. Gestion des identités et des accès AWS Les pods qui utilisent le compte de service peuvent ensuite accéder à tout AWS service auquel le rôle est autorisé à accéder.

L'exemple suivant exécute une application Spark pour compter les mots d'un fichier dans Amazon S3. Pour ce faire, vous pouvez configurer des rôles IAM pour les comptes de service (IRSA) afin d'authentifier et d'autoriser les comptes de service Kubernetes.

**Note**  
Cet exemple utilise l'espace de noms « spark-operator » pour l'opérateur Spark et pour l'espace de noms dans lequel vous soumettez l'application Spark.

## Conditions préalables
<a name="spark-operator-security-irsa-prereqs"></a>

Avant d'essayer l'exemple présenté sur cette page, vous devez remplir les conditions préalables suivantes :
+ [Préparez-vous pour l'utilisation de l'opérateur Spark]().
+ [Installation de l'opérateur Spark](spark-operator-gs.md#spark-operator-install).
+ [Créez un compartiment Amazon S3.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-bucket.html)
+ Enregistrez votre poème préféré dans un fichier texte nommé `poem.txt`, puis chargez ce fichier dans votre compartiment S3. L'application Spark que vous créez sur cette page lira le contenu du fichier texte. Pour plus d'informations sur le chargement des fichiers sur S3, consultez la rubrique [Chargement d'un objet dans votre compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/uploading-an-object-bucket.html) du *Guide de l'utilisateur Amazon Simple Storage Service*.

## Configuration d'un compte de service Kubernetes pour qu'il assume un rôle IAM
<a name="spark-operator-security-irsa-config"></a>

Suivez les étapes ci-dessous pour configurer un compte de service Kubernetes afin qu'il assume un rôle IAM que les pods peuvent utiliser pour accéder aux AWS services auxquels le rôle est autorisé à accéder.

1. Une fois le[Conditions préalables](#spark-operator-security-irsa-prereqs), utilisez le AWS Command Line Interface pour créer un `example-policy.json` fichier qui autorise un accès en lecture seule au fichier que vous avez chargé sur Amazon S3 :

   ```
   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. Ensuite, créez une politique IAM `example-policy` :

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

1. Puis créez un rôle IAM `example-role` et associez-le à un compte de service Kubernetes pour le pilote Spark :

   ```
   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. Créez un fichier yaml avec les liaisons de rôle de cluster qui sont nécessaires pour le compte de service du pilote Spark :

   ```
   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. Appliquez les configurations de liaison des rôle du cluster :

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

La commande kubectl doit confirmer la création réussie du compte :

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

## Exécution d'une application depuis l'opérateur Spark
<a name="spark-operator-security-irsa-run"></a>

Après avoir [configuré le compte de service Kubernetes](), vous pouvez exécuter une application Spark qui compte le nombre de mots contenus dans le fichier texte que vous avez chargé dans le cadre des conditions préalables [Conditions préalables](#spark-operator-security-irsa-prereqs).

1. Créez un nouveau fichier`word-count.yaml`, avec une `SparkApplication` définition pour votre application de comptage de mots, sur la base de la version 6 d'Amazon EMR.

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

   Si vous utilisez l'opérateur Spark dans une version 7, vous devez ajuster certaines valeurs de configuration :

   ```
   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. Soumettez l'application Spark.

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

   La commande kubectl doit renvoyer la confirmation que vous avez créé avec succès un objet `SparkApplication` appelé `word-count`.

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

1. Pour vérifier les événements de l'objet `SparkApplication`, exécutez la commande suivante :

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

   La commande kubectl doit renvoyer la description de `SparkApplication` avec les événements :

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

L'application compte maintenant les mots de votre fichier S3. Pour connaître le nombre de mots, consultez les fichiers journaux de votre pilote :

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

La commande kubectl doit renvoyer le contenu du fichier journal avec les résultats de votre application de comptage de mots.

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

Pour plus d'informations sur la façon de soumettre des applications à Spark via l'opérateur Spark, consultez la documentation relative SparkApplication à [l'utilisation d'un](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/) opérateur *Kubernetes pour Apache Spark (opérateur spark-on-k 8s) sur.* GitHub