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.

# Exécution de tâches Spark à l'aide de l'opérateur Spark
<a name="spark-operator"></a>

Les versions 6.10.0 et supérieures d'Amazon EMR prennent en charge l'opérateur Kubernetes pour Apache Spark, ou *l'opérateur Spark*, en tant que modèle de soumission de tâches pour Amazon EMR on EKS. Grâce à l'opérateur Spark, vous pouvez déployer et gérer des applications Spark à l'aide du moteur d'exécution Amazon EMR sur vos propres clusters Amazon EKS. Une fois que vous avez déployé l'opérateur Spark dans votre cluster Amazon EKS, vous pouvez directement soumettre des applications Spark à l'aide de cet opérateur. L'opérateur gère le cycle de vie des applications Spark.

**Note**  
Amazon EMR calcule les tarifs sur Amazon EKS en fonction du vCPU et de la consommation de mémoire. Ce calcul s'applique aux modules pilote et exécuteur. Ce calcul commence à partir du moment où vous téléchargez l'image de votre application Amazon EMR jusqu'à ce que le module Amazon EKS se termine et est arrondi à la seconde près.

**Topics**
+ [Configuration de l'opérateur Spark pour Amazon EMR on EKS](spark-operator-setup.md)
+ [Les premiers pas avec l'opérateur Spark pour Amazon EMR on EKS](spark-operator-gs.md)
+ [Utiliser l'autoscaling vertical avec l'opérateur Spark pour Amazon EMR sur EKS](spark-operator-vas.md)
+ [Désinstallation de l'opérateur Spark pour Amazon EMR on EKS](spark-operator-uninstall.md)
+ [Utilisation de la configuration de surveillance pour surveiller l'opérateur Spark Kubernetes et les tâches Spark](spark-operator-monitoring-configuration.md)
+ [Sécurité et opérateur Spark avec Amazon EMR on EKS](spark-operator-security.md)

# Configuration de l'opérateur Spark pour Amazon EMR on EKS
<a name="spark-operator-setup"></a>

Effectuez les tâches suivantes pour vous préparer avant d'installer l'opérateur Spark sur Amazon EKS. Si vous êtes déjà inscrit à Amazon Web Services (AWS) et que vous avez utilisé Amazon EKS, vous êtes presque prêt à utiliser Amazon EMR on EKS. Effectuez les tâches suivantes pour vous préparer pour l'utilisation de l'opérateur Spark sur Amazon EKS. Si vous avez déjà rempli l'une des conditions préalables, vous pouvez l'ignorer et passer à la suivante.
+ **[Installation ou mise à jour vers la dernière version du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)** — Si vous avez déjà installé le AWS CLI, vérifiez que vous disposez de la dernière version.
+ **[Configurer kubectl et eksctl — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)** est un outil de ligne de commande que vous utilisez pour communiquer avec Amazon EKS.
+ **[Installer Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)** – Le gestionnaire de packages Helm pour Kubernetes vous aide à installer et à gérer des applications sur votre cluster Kubernetes. 
+ **[Commencez avec Amazon EKS — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)** — Suivez les étapes pour créer un nouveau cluster Kubernetes avec des nœuds dans Amazon EKS.
+ **[Sélectionner l'URI d'une image de base Amazon EMR](docker-custom-images-tag.md) (version 6.10.0 ou supérieure)** – L'opérateur Spark est pris en charge par les versions  6.10.0 et supérieures d'Amazon EMR.

# Les premiers pas avec l'opérateur Spark pour Amazon EMR on EKS
<a name="spark-operator-gs"></a>

Cette rubrique vous aide à commencer à utiliser l'opérateur Spark sur Amazon EKS en déployant une application Spark et une application Schedule Spark.

## Installation de l'opérateur Spark
<a name="spark-operator-install"></a>

Procédez comme suit pour installer l'opérateur Kubernetes pour Apache Spark.

1. Si vous ne l'avez pas déjà fait, suivez les étapes de [Configuration de l'opérateur Spark pour Amazon EMR on EKS](spark-operator-setup.md).

1. Authentifiez votre client Helm dans le registre Amazon ECR. Dans la commande suivante, remplacez les *region-id* valeurs par vos valeurs préférées Région AWS et par la *ECR-registry-account* valeur correspondante pour la région [Comptes de registre Amazon ECR par région](docker-custom-images-tag.md#docker-custom-images-ECR) sur la page.

   ```
   aws ecr get-login-password \
   --region region-id | helm registry login \
   --username AWS \
   --password-stdin ECR-registry-account.dkr.ecr.region-id.amazonaws.com
   ```

1. Installez l'opérateur Spark à l'aide de la commande suivante.

   Pour le paramètre `--version` des Charts de Helm, utilisez votre étiquette de version Amazon EMR avec le préfixe `emr-` et le suffixe de date supprimés. Par exemple, pour la version `emr-6.12.0-java17-latest`, spécifiez `6.12.0-java17`. L'exemple de la commande ci-dessous utilise la version `emr-7.12.0-latest`, elle spécifie donc `7.12.0` pour les Charts de Helm `--version`.

   ```
   helm install spark-operator-demo \
     oci://895885662937.dkr.ecr.region-id.amazonaws.com/spark-operator \
     --set emrContainers.awsRegion=region-id \
     --version 7.12.0 \
     --namespace spark-operator \
     --create-namespace
   ```

   Par défaut, la commande crée un compte de service `emr-containers-sa-spark-operator` pour l'opérateur Spark. Pour utiliser un autre compte de service, saisissez l'argument `serviceAccounts.sparkoperator.name`. Par exemple :

   ```
   --set serviceAccounts.sparkoperator.name my-service-account-for-spark-operator
   ```

   Si vous souhaitez [utiliser l'autoscaling vertical avec l'opérateur Spark](), ajoutez la ligne suivante à la commande d'installation pour autoriser les webhooks pour l'opérateur :

   ```
   --set webhook.enable=true
   ```

1. Vérifiez que vous avez installé les Charts de Helm à l'aide de la commande `helm list` :

   ```
   helm list --namespace spark-operator -o yaml
   ```

   La commande `helm list` doit vous renvoyer les informations relatives à la version des Charts de Helm qui vient d'être déployée :

   ```
   app_version: v1beta2-1.3.8-3.1.1
   chart: spark-operator-7.12.0
   name: spark-operator-demo
   namespace: spark-operator
   revision: "1"
   status: deployed
   updated: 2023-03-14 18:20:02.721638196 +0000 UTC
   ```

1. Terminez l'installation avec toutes les options supplémentaires dont vous avez besoin. Pour plus d'informations, consultez la [https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/blob/master/charts/spark-operator-chart/README.md](https://github.com/GoogleCloudPlatform/spark-on-k8s-operator/blob/master/charts/spark-operator-chart/README.md)documentation sur GitHub.

## Exécution d'une application Spark
<a name="spark-operator-run"></a>

L'opérateur Spark est pris en charge avec Amazon EMR en version 6.10.0 ou supérieure. Lorsque vous installez l'opérateur Spark, il crée le compte de service `emr-containers-sa-spark` pour exécuter les applications Spark par défaut. Suivez les étapes ci-dessous pour exécuter une application Spark avec l'opérateur Spark sur Amazon EMR on EKS en version 6.10.0 ou supérieure.

1. Pour pouvoir exécuter une application Spark à l'aide de l'opérateur Spark, suivez les étapes indiquées dans [Configuration de l'opérateur Spark pour Amazon EMR on EKS](spark-operator-setup.md) et [Installation de l'opérateur Spark](#spark-operator-install). 

1. Créez un fichier de définition `SparkApplication` `spark-pi.yaml` avec le contenu suivant : 

   ```
   apiVersion: "sparkoperator.k8s.io/v1beta2"
   kind: SparkApplication
   metadata:
     name: spark-pi
     namespace: spark-operator
   spec:
     type: Scala
     mode: cluster
     image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-6.10.0:latest"
     imagePullPolicy: Always
     mainClass: org.apache.spark.examples.SparkPi
     mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples.jar"
     sparkVersion: "3.3.1"
     restartPolicy:
       type: Never
     volumes:
       - name: "test-volume"
         hostPath:
           path: "/tmp"
           type: Directory
     driver:
       cores: 1
       coreLimit: "1200m"
       memory: "512m"
       labels:
         version: 3.3.1
       serviceAccount: emr-containers-sa-spark
       volumeMounts:
         - name: "test-volume"
           mountPath: "/tmp"
     executor:
       cores: 1
       instances: 1
       memory: "512m"
       labels:
         version: 3.3.1
       volumeMounts:
         - name: "test-volume"
           mountPath: "/tmp"
   ```

1. Maintenant, soumettez l'application Spark à l'aide de la commande suivante. Cela créera également un objet `SparkApplication` nommé `spark-pi` :

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

1. Vérifiez les événements de l'objet `SparkApplication` à l'aide de la commande suivante : 

   ```
   kubectl describe sparkapplication spark-pi --namespace spark-operator
   ```

Pour plus d'informations sur l'envoi d'applications à Spark via l'opérateur Spark, consultez la section [Utiliser un `SparkApplication`](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/) dans la `spark-on-k8s-operator` documentation sur GitHub.

## Utiliser Amazon S3 pour le stockage
<a name="spark-operator-s3-storage"></a>

Pour utiliser Amazon S3 comme option de stockage de fichiers, ajoutez les configurations suivantes à votre fichier YAML.

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

 Si vous utilisez les versions 7.2.0 et supérieures d'Amazon EMR, les configurations sont incluses par défaut. Dans ce cas, vous pouvez définir le chemin du fichier sur `s3://<bucket_name>/<file_path>` plutôt que `local://<file_path>` dans le fichier YAML de l'application Spark. 

Soumettez ensuite l'application Spark comme d'habitude.

# Utiliser l'autoscaling vertical avec l'opérateur Spark pour Amazon EMR sur EKS
<a name="spark-operator-vas"></a>

À partir d'Amazon EMR 7.0, vous pouvez utiliser la mise à l'échelle automatique verticale d'Amazon EMR on EKS pour simplifier la gestion des ressources. Elle permet d'adapter automatiquement les ressources de mémoire et de CPU aux besoins de la charge de travail que vous fournissez aux applications Spark sur Amazon EMR. Pour de plus amples informations, veuillez consulter [Utilisation de la mise à l'échelle automatique verticale avec les tâches Spark sur Amazon EMR](jobruns-vas.md).

Cette section décrit comment configurer l'opérateur Spark pour utiliser l'autoscaling vertical.

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

Avant de configurer la surveillance, veillez à effectuer les tâches de configuration suivantes :
+ Suivez les étapes de [Configuration de l'opérateur Spark pour Amazon EMR on EKS](spark-operator-setup.md).
+ (facultatif) Si vous avez déjà installé une ancienne version de l'opérateur Spark, supprimez le SparkApplication/ScheduledSparkApplication CRD.

  ```
  kubectl delete crd sparkApplication
  kubectl delete crd scheduledSparkApplication
  ```
+ Suivez les étapes de [Installation de l'opérateur Spark](spark-operator-gs.md#spark-operator-install). À l'étape 3, ajoutez la ligne suivante à la commande d'installation pour autoriser les webhooks pour l'opérateur :

  ```
  --set webhook.enable=true
  ```
+ Suivez les étapes de [Configuration de la mise à l'échelle automatique verticale pour Amazon EMR on EKS](jobruns-vas-setup.md).
+ Donnez accès aux fichiers se trouvant dans votre emplacement Amazon S3 :

  1. Annotez le compte de service de votre chauffeur et de votre opérateur avec `JobExecutionRole` les autorisations S3.

     ```
     kubectl annotate serviceaccount -n spark-operator emr-containers-sa-spark eks.amazonaws.com/role-arn=JobExecutionRole
     kubectl annotate serviceaccount -n spark-operator emr-containers-sa-spark-operator eks.amazonaws.com/role-arn=JobExecutionRole
     ```

  1. Mettez à jour la politique de confiance de votre rôle d'exécution des tâches dans cet espace de noms.

     ```
     aws emr-containers update-role-trust-policy \
     --cluster-name cluster \
     --namespace ${Namespace}\
     --role-name iam_role_name_for_job_execution
     ```

  1. Modifiez la politique de confiance du rôle IAM de votre rôle d'exécution des tâches et mettez à jour le `serviceaccount` formulaire `emr-containers-sa-spark-*-*-xxxx` vers`emr-containers-sa-*`.

     ```
     {
         "Effect": "Allow",
         "Principal": {
             "Federated": "OIDC-provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
             "StringLike": {
                 "OIDC": "system:serviceaccount:${Namespace}:emr-containers-sa-*"
             }
         }
     }
     ```

  1. Si vous utilisez Amazon S3 comme espace de stockage de fichiers, ajoutez les valeurs par défaut suivantes à votre fichier yaml.

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

## Exécuter une tâche avec l'autoscaling vertical sur l'opérateur Spark
<a name="spark-operator-vas-run"></a>

Pour pouvoir exécuter une application Spark à l'aide de l'opérateur Spark, vous devez suivre les étapes indiquées dans [Conditions préalables](#spark-operator-vas-prereqs). 

Pour utiliser la mise à l'échelle automatique verticale avec l'opérateur Spark, ajoutez la configuration suivante au pilote correspondant aux spécifications de votre application Spark afin d'activer la mise à l'échelle automatique verticale :

```
dynamicSizing:
  mode: Off
  signature: "my-signature"
```

Cette configuration permet une mise à l'échelle automatique verticale et constitue une configuration de signature obligatoire qui vous permet de choisir une signature pour votre tâche.

Pour plus d'informations sur les configurations et les valeurs des paramètres, consultez [Configuration de l'autoscaling vertical pour Amazon EMR sur](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/jobruns-vas-configure.html) EKS. Par défaut, votre tâche est soumise en mode **Désactivé**, réservé à la surveillance uniquement, de la mise à l'échelle automatique verticale. Cet état de surveillance vous permet de calculer et de consulter les recommandations en matière de ressources sans procéder à la mise à l'échelle automatique. Pour plus d'informations, consultez la section [Modes de mise à l'échelle automatique verticaux](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/jobruns-vas-configure.html#jobruns-vas-parameters-opt-mode).

Voici un exemple de fichier de `SparkApplication` définition nommé `spark-pi.yaml` avec les configurations requises pour utiliser l'autoscaling vertical.

```
apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: spark-pi
  namespace: spark-operator
spec:
  type: Scala
  mode: cluster
  image: "895885662937.dkr.ecr.us-west-2.amazonaws.com/spark/emr-7.12.0:latest"
  imagePullPolicy: Always
  mainClass: org.apache.spark.examples.SparkPi
  mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples.jar"
  sparkVersion: "3.4.1"
  dynamicSizing:
    mode: Off
    signature: "my-signature"
  restartPolicy:
    type: Never
  volumes:
    - name: "test-volume"
      hostPath:
        path: "/tmp"
        type: Directory
  driver:
    cores: 1
    coreLimit: "1200m"
    memory: "512m"
    labels:
      version: 3.4.1
    serviceAccount: emr-containers-sa-spark
    volumeMounts:
      - name: "test-volume"
        mountPath: "/tmp"
  executor:
    cores: 1
    instances: 1
    memory: "512m"
    labels:
      version: 3.4.1
    volumeMounts:
      - name: "test-volume"
        mountPath: "/tmp"
```

Maintenant, soumettez l'application Spark à l'aide de la commande suivante. Cela créera également un objet `SparkApplication` nommé `spark-pi` :

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

Pour plus d'informations sur l'envoi d'applications à Spark via l'opérateur Spark, consultez la section [Utiliser un `SparkApplication`](https://www.kubeflow.org/docs/components/spark-operator/user-guide/using-sparkapplication/) dans la `spark-on-k8s-operator` documentation sur GitHub.

## Vérification de la fonctionnalité de mise à l'échelle automatique verticale
<a name="spark-operator-vas-verify"></a>

Pour vérifier que la mise à l'échelle automatique verticale fonctionne correctement pour la tâche soumise, utilisez kubectl pour obtenir la ressource personnalisée `verticalpodautoscaler` et consulter vos recommandations de mise à l'échelle.

```
kubectl get verticalpodautoscalers --all-namespaces \ 
-l=emr-containers.amazonaws.com/dynamic.sizing.signature=my-signature
```

Le résultat de cette requête devrait ressembler à ce qui suit :

```
NAMESPACE        NAME                                                          MODE   CPU   MEM         PROVIDED   AGE
spark-operator   ds-p73j6mkosvc4xeb3gr7x4xol2bfcw5evqimzqojrlysvj3giozuq-vpa   Off          580026651   True       15m
```

Si votre résultat ne ressemble pas à cela ou contient un code d'erreur, consultez [Résolution des problèmes de mise à l'échelle automatique verticale d'Amazon EMR on EKS](troubleshooting-vas.md) pour des étapes permettant de résoudre le problème.

Pour supprimer les modules et les applications, exécutez la commande suivante :

```
kubectl delete sparkapplication spark-pi
```

# Désinstallation de l'opérateur Spark pour Amazon EMR on EKS
<a name="spark-operator-uninstall"></a>

Procédez comme suit pour désinstaller l'opérateur Spark.

1. Supprimez l'opérateur Spark en utilisant le bon espace de noms. Dans cet exemple, l'espace de noms est `spark-operator-demo`.

   ```
   helm uninstall spark-operator-demo -n spark-operator
   ```

1. Supprimez le compte de service de l'opérateur Spark :

   ```
   kubectl delete sa emr-containers-sa-spark-operator -n spark-operator
   ```

1. Supprimez l'opérateur Spark `CustomResourceDefinitions` (CRDs) :

   ```
   kubectl delete crd sparkapplications.sparkoperator.k8s.io
   kubectl delete crd scheduledsparkapplications.sparkoperator.k8s.io
   ```

# Utilisation de la configuration de surveillance pour surveiller l'opérateur Spark Kubernetes et les tâches Spark
<a name="spark-operator-monitoring-configuration"></a>

La configuration de surveillance vous permet de configurer facilement l'archivage des journaux de votre application Spark et des journaux des opérateurs sur Amazon S3 ou vers Amazon CloudWatch. Vous pouvez choisir l'un ou les deux. Cela ajoute un sidecar d'agent de journalisation à vos modules d'opérateur, de pilote et d'exécuteur Spark, puis transmet les journaux de ces composants aux récepteurs que vous avez configurés.

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

Avant de configurer la surveillance, veillez à effectuer les tâches de configuration suivantes :

1. (Facultatif) Si vous avez déjà installé une ancienne version de l'opérateur Spark, supprimez le *SparkApplication/ScheduledSparkApplication*CRD.

   ```
   kubectl delete crd scheduledsparkapplications.sparkoperator.k8s.io
   kubectl delete crd sparkapplications.sparkoperator.k8s.io
   ```

1. Créez un rôle operator/job d'exécution dans IAM si vous n'en avez pas déjà un.

1. Exécutez la commande suivante pour mettre à jour la politique de confiance du rôle operator/job d'exécution que vous venez de créer :

   ```
   aws emr-containers update-role-trust-policy \ 
   --cluster-name cluster \
   --namespace namespace \
   --role-name iam_role_name_for_operator/job_execution_role
   ```

1. Modifiez la politique de confiance du rôle IAM de votre rôle operator/job d'exécution comme suit :

   ```
   {
       "Effect": "Allow",
       "Principal": {
           "Federated": "${OIDC-provider}"
       },
       "Action": "sts:AssumeRoleWithWebIdentity",
       "Condition": {
           "StringLike": {
               "OIDC_PROVIDER:sub": "system:serviceaccount:${Namespace}:emr-containers-sa-*"
           }
       }
   }
   ```

1. Créez une politique de *configuration de surveillance* dans IAM avec les autorisations suivantes :

------
#### [ JSON ]

****  

   ```
   {
     "Version":"2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "logs:DescribeLogStreams",
           "logs:CreateLogStream",
           "logs:CreateLogGroup",
           "logs:PutLogEvents"
         ],
         "Resource": [
           "arn:aws:logs:*:*:log-group:log_group_name",
           "arn:aws:logs:*:*:log-group:log_group_name:*"
         ],
         "Sid": "AllowLOGSDescribelogstreams"
       },
       {
         "Effect": "Allow",
         "Action": [
           "logs:DescribeLogGroups"
         ],
         "Resource": [
           "*"
         ],
         "Sid": "AllowLOGSDescribeloggroups"
       },
       {
         "Effect": "Allow",
         "Action": [
           "s3:PutObject",
           "s3:GetObject",
           "s3:ListBucket"
         ],
         "Resource": [
           "arn:aws:s3:::bucket_name",
           "arn:aws:s3:::bucket_name/*"
         ],
         "Sid": "AllowS3Putobject"
       }
     ]
   }
   ```

------

1. Associez la politique ci-dessus à votre rôle operator/job d'exécution.

# Journaux des opérateurs Spark
<a name="spark-operator-monitoring-configuration-logs"></a>

Vous pouvez définir la configuration de surveillance de la manière suivante lors de cette opération `helm install` :

```
helm install spark-operator spark-operator \
--namespace namespace \
--set emrContainers.awsRegion=aws_region \
--set emrContainers.monitoringConfiguration.image=log_agent_image_url \
--set emrContainers.monitoringConfiguration.s3MonitoringConfiguration.logUri=S3_bucket_uri \
--set emrContainers.monitoringConfiguration.cloudWatchMonitoringConfiguration.logGroupName=log_group_name \
--set emrContainers.monitoringConfiguration.cloudWatchMonitoringConfiguration.logStreamNamePrefix=log_stream_prefix \
--set emrContainers.monitoringConfiguration.sideCarResources.limits.cpuLimit=500m \
--set emrContainers.monitoringConfiguration.sideCarResources.limits.memoryLimit=512Mi \
--set emrContainers.monitoringConfiguration.containerLogRotationConfiguration.rotationSize=2GB \
--set emrContainers.monitoringConfiguration.containerLogRotationConfiguration.maxFilesToKeep=10 \
--set webhook.enable=true \
--set emrContainers.operatorExecutionRoleArn=operator_execution_role_arn
```

**Configuration de surveillance**

Les options de configuration disponibles sous **MonitoringConfiguration** sont les suivantes.
+ **Image** (facultatif) — Enregistrez l'URL de l'image de l'agent. Je viendrai le chercher emrReleaseLabel s'il n'est pas fourni.
+ **s3 MonitoringConfiguration** — Définissez cette option pour archiver sur Amazon S3.
  + **LoGURI** — (obligatoire) — Le chemin du compartiment Amazon S3 dans lequel vous souhaitez stocker vos journaux.
  + Vous trouverez ci-dessous des exemples de formats pour les chemins de compartiment Amazon S3, une fois les journaux chargés. Le premier exemple montre qu'aucune rotation des journaux n'est activée.

    ```
    s3://${logUri}/${POD NAME}/operator/stdout.gz
    s3://${logUri}/${POD NAME}/operator/stderr.gz
    ```

    La rotation des journaux est activée par défaut. Vous pouvez voir à la fois un fichier pivoté, avec un index incrémenté, et un fichier en cours, identique à l'exemple précédent.

    ```
    s3://${logUri}/${POD NAME}/operator/stdout_YYYYMMDD_index.gz
    s3://${logUri}/${POD NAME}/operator/stderr_YYYYMMDD_index.gz
    ```
+ **cloudWatchMonitoringConfiguration** : clé de configuration vers laquelle configurer le transfert Amazon CloudWatch.
  + **logGroupName**(obligatoire) — Nom du groupe de Amazon CloudWatch journaux auquel vous souhaitez envoyer des journaux. Le groupe est automatiquement créé s'il n'existe pas.
  + **logStreamNamePréfixe** (facultatif) : nom du flux de journaux auquel vous souhaitez envoyer des journaux. La valeur par défaut est une chaîne vide. Le format Amazon CloudWatch est le suivant :

    ```
    ${logStreamNamePrefix}/${POD NAME}/STDOUT or STDERR
    ```
+ **sideCarResources**(facultatif) — La clé de configuration pour définir les limites de ressources sur le conteneur latéral Fluentd lancé.
  + **Limite de mémoire** (facultatif) — Limite de mémoire. Ajustez selon vos besoins. La valeur par défaut est 512Mi.
  + **CPULimit** (facultatif) — Limite du processeur. Ajustez selon vos besoins. La valeur par défaut est de 500 m.
+ **containerLogRotationConfiguration** (facultatif) — Contrôle le comportement de rotation du journal du conteneur. Il est activé par défaut.
  + **RotationSize** (obligatoire) — Spécifie la taille du fichier pour la rotation du journal. La plage de valeurs possibles est comprise entre 2 Ko et 2 Go. La partie unitaire numérique du paramètre rotationSize est transmise sous forme d'entier. Les valeurs décimales n'étant pas prises en charge, vous pouvez indiquer une taille de rotation de 1,5 Go, par exemple, avec la valeur 1500 Mo. La valeur par défaut est 2 Go.
  + **maxFilesToConserver** (obligatoire) — Spécifie le nombre maximum de fichiers à conserver dans le conteneur après la rotation. La valeur minimale est 1 et la valeur maximale est 50. La valeur par défaut est 10.

Après avoir configuré *MonitoringConfiguration*, vous devriez être en mesure de consulter les journaux des pods Spark Operator sur un compartiment Amazon S3 ou Amazon CloudWatch sur les deux. Pour un compartiment Amazon S3, vous devez attendre 2 minutes pour que le premier fichier journal soit vidé.

Pour trouver les connexions Amazon CloudWatch, vous pouvez accéder à ce qui suit : **CloudWatch**> **Groupes de journaux** > > ***Log group name**Pod name*****/operator/stderr**

Vous pouvez également accéder à : **CloudWatch**> **Groupes de journaux** > > ***Log group name**Pod name*****/operator/stdout**

# Journaux des applications Spark
<a name="spark-operator-monitoring-application-logs"></a>

Vous pouvez définir cette configuration de la manière suivante.

```
apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: spark-pi
  namespace: namespace
spec:
  type: Scala
  mode: cluster
  imagePullPolicy: Always
  mainClass: org.apache.spark.examples.SparkPi
  mainApplicationFile: "local:///usr/lib/spark/examples/jars/spark-examples.jar"
  sparkVersion: "3.3.1"
  emrReleaseLabel: emr_release_label
  executionRoleArn: job_execution_role_arn
  restartPolicy:
    type: Never
  volumes:
    - name: "test-volume"
      hostPath:
        path: "/tmp"
        type: Directory
  driver:
    cores: 1
    coreLimit: "1200m"
    memory: "512m"
    labels:
      version: 3.3.1
    volumeMounts:
      - name: "test-volume"
        mountPath: "/tmp"
  executor:
    cores: 1
    instances: 1
    memory: "512m"
    labels:
      version: 3.3.1
    volumeMounts:
      - name: "test-volume"
        mountPath: "/tmp"
  monitoringConfiguration:
    image: "log_agent_image"
    s3MonitoringConfiguration:
      logUri: "S3_bucket_uri"
    cloudWatchMonitoringConfiguration:
      logGroupName: "log_group_name"
      logStreamNamePrefix: "log_stream_prefix"
    sideCarResources:
      limits:
        cpuLimit: "500m"
        memoryLimit: "250Mi"
    containerLogRotationConfiguration:
      rotationSize: "2GB"
      maxFilesToKeep: "10"
```

Les options de configuration disponibles sous **MonitoringConfiguration** sont les suivantes.
+ **Image** (facultatif) — Enregistrez l'URL de l'image de l'agent. Je viendrai le chercher emrReleaseLabel s'il n'est pas fourni.
+ **s3 MonitoringConfiguration** — Définissez cette option pour archiver sur Amazon S3.
  + **LoGURI** (obligatoire) — Le chemin du compartiment Amazon S3 dans lequel vous souhaitez stocker vos journaux. Le premier exemple montre qu'aucune rotation des journaux n'est activée :

    ```
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stdout.gz
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stderr.gz
    ```

    La rotation des journaux est activée par défaut. Vous pouvez utiliser à la fois un fichier pivoté (avec index incrémenté) et un fichier actuel (sans horodatage).

    ```
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stdout_YYYYMMDD_index.gz
    s3://${logUri}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stderr_YYYYMMDD_index.gz
    ```
+ **cloudWatchMonitoringConfiguration** : clé de configuration vers laquelle configurer le transfert Amazon CloudWatch.
  + **logGroupName**(obligatoire) — Le nom du groupe de journaux Cloudwatch auquel vous souhaitez envoyer des journaux. Le groupe est automatiquement créé s'il n'existe pas.
  + **logStreamNamePréfixe** (facultatif) : nom du flux de journaux auquel vous souhaitez envoyer des journaux. La valeur par défaut est une chaîne vide. Le format CloudWatch est le suivant :

    ```
    ${logStreamNamePrefix}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stdout
    ${logStreamNamePrefix}/${APPLICATION NAME}-${APPLICATION UID}/${POD NAME}/stderr
    ```
+ **sideCarResources**(facultatif) — La clé de configuration pour définir les limites de ressources sur le conteneur latéral Fluentd lancé.
  + **Limite de mémoire** (facultatif) — Limite de mémoire. Ajustez selon vos besoins. La valeur par défaut est 250 Mi.
  + **CPULimit — Limite** du processeur. Ajustez selon vos besoins. La valeur par défaut est de 500 m.
+ **containerLogRotationConfiguration** (facultatif) — Contrôle le comportement de rotation du journal du conteneur. Il est activé par défaut.
  + **RotationSize** (obligatoire) — Spécifie la taille du fichier pour la rotation du journal. La plage de valeurs possibles est comprise entre 2 Ko et 2 Go. La partie unitaire numérique du paramètre rotationSize est transmise sous forme d'entier. Les valeurs décimales n'étant pas prises en charge, vous pouvez indiquer une taille de rotation de 1,5 Go, par exemple, avec la valeur 1500 Mo. La valeur par défaut est 2 Go.
  + **maxFilesToConserver** (obligatoire) — Spécifie le nombre maximum de fichiers à conserver dans le conteneur après la rotation. La valeur minimale est de 1. La valeur maximale est de 50. La valeur par défaut est 10.

Après avoir configuré MonitoringConfiguration, vous devriez être en mesure de consulter les journaux du pilote et de l'exécuteur de votre application Spark sur un compartiment Amazon S3, ou sur les deux. CloudWatch Pour un compartiment Amazon S3, vous devez attendre 2 minutes pour que le premier fichier journal soit vidé. Par exemple, dans Amazon S3, le chemin du compartiment apparaît comme suit :

**Amazon S3** **> Compartiments** **> ***Bucket name***> > *Spark application name - UUID* *Pod Name* > stderr.gz**

Ou:

**Amazon S3** **> Compartiments** **> ***Bucket name***> > *Spark application name - UUID* *Pod Name* > stdout.gz**

Dans CloudWatch, le chemin apparaît comme suit :

**CloudWatch**> **Groupes de journaux** > ***Log group name***>*Spark application name - UUID*/*Pod name***/stderr**

Ou:

**CloudWatch**> **Groupes de journaux** > ***Log group name***>*Spark application name - UUID*/*Pod name***/stdout**

# Sécurité et opérateur Spark avec Amazon EMR on EKS
<a name="spark-operator-security"></a>

Il existe deux manières de configurer les autorisations d'accès au cluster lorsque vous utilisez l'opérateur Spark. La première consiste à utiliser le contrôle d'accès basé sur les rôles. Le contrôle d'accès basé sur les rôles (RBAC) restreint l'accès en fonction du rôle d'une personne au sein d'une organisation. C'est devenu le principal moyen de gérer l'accès. La deuxième méthode d'accès consiste à assumer un Gestion des identités et des accès AWS rôle, qui fournit un accès aux ressources au moyen d'autorisations spécifiques attribuées.

**Topics**
+ [Configuration des autorisations d'accès au cluster avec le contrôle d'accès basé sur les rôles (RBAC)](spark-operator-security-rbac.md)
+ [Configuration des autorisations d'accès au cluster avec des rôles IAM pour les comptes de service (IRSA)](spark-operator-security-irsa.md)

# Configuration des autorisations d'accès au cluster avec le contrôle d'accès basé sur les rôles (RBAC)
<a name="spark-operator-security-rbac"></a>

Pour déployer l'opérateur Spark, Amazon EMR on EKS crée deux rôles et comptes de service pour l'opérateur Spark et les applications Spark.

**Topics**
+ [Compte de service et rôle de l'opérateur](#spark-operator-sa-oper)
+ [Compte de service et rôle Spark](#spark-operator-sa-spark)

## Compte de service et rôle de l'opérateur
<a name="spark-operator-sa-oper"></a>

Amazon EMR on EKS crée le **compte de service et le rôle de l'opérateur** pour gérer `SparkApplications` pour les tâches Spark et pour d'autres ressources telles que les services.

Le nom par défaut de ce compte de service est `emr-containers-sa-spark-operator`.

Les règles suivantes s'appliquent à cette fonction du service : 

```
 rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - services
  - configmaps
  - secrets
  verbs:
  - create
  - get
  - delete
  - update
- apiGroups:
  - extensions
  - networking.k8s.io
  resources:
  - ingresses
  verbs:
  - create
  - get
  - delete
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
- apiGroups:
  - ""
  resources:
  - events
  verbs:
  - create
  - update
  - patch
- apiGroups:
  - ""
  resources:
  - resourcequotas
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - apiextensions.k8s.io
  resources:
  - customresourcedefinitions
  verbs:
  - create
  - get
  - update
  - delete
- apiGroups:
  - admissionregistration.k8s.io
  resources:
  - mutatingwebhookconfigurations
  - validatingwebhookconfigurations
  verbs:
  - create
  - get
  - update
  - delete
- apiGroups:
  - sparkoperator.k8s.io
  resources:
  - sparkapplications
  - sparkapplications/status
  - scheduledsparkapplications
  - scheduledsparkapplications/status
  verbs:
  - "*"
  {{- if .Values.batchScheduler.enable }}
  # required for the `volcano` batch scheduler
- apiGroups:
  - scheduling.incubator.k8s.io
  - scheduling.sigs.dev
  - scheduling.volcano.sh
  resources:
  - podgroups
  verbs:
  - "*"
  {{- end }}
  {{ if .Values.webhook.enable }}
- apiGroups:
  - batch
  resources:
  - jobs
  verbs:
  - delete
  {{- end }}
```

## Compte de service et rôle Spark
<a name="spark-operator-sa-spark"></a>

Le pod du pilote Spark a besoin d'un compte de service Kubernetes dans le même espace de noms que le pod. Ce compte de service a besoin d'autorisations pour créer, obtenir, répertorier, patcher et supprimer des pods d'exécuteurs, ainsi que pour créer un service Kubernetes sans tête pour le pilote. Le pilote échoue et se termine sans le compte de service, sauf si le compte de service par défaut dans l'espace de noms du pod dispose des autorisations requises.

Le nom par défaut de ce compte de service est `emr-containers-sa-spark`.

Les règles suivantes s'appliquent à cette fonction du service : 

```
 rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - services
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - configmaps
  verbs:
  - "*"
- apiGroups:
  - ""
  resources:
  - persistentvolumeclaims
  verbs:
  - "*"
```

# 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