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. # Apache Spark [Apache Spark](https://aws.amazon.com/emr/features/spark/) est un modèle distribué de programmation et d'infrastructure qui vous permet d'effectuer des opérations de machine learning, de traitement de flux ou d'analyse graphique avec les clusters Amazon EMR. De manière analogue à Apache Hadoop, Spark est un système de traitement distribué open source, couramment utilisé pour les charges de travail de big data. Cependant, Spark présente plusieurs différences notables par rapport à Hadoop MapReduce. Spark a un moteur d'exécution optimisé de graphes acycliques dirigés (DAG) et met en cache de façon active les données en mémoire, ce qui peut améliorer les performances, notamment pour certains algorithmes et requêtes interactives. De manière native, Spark prend en charge les applications écrites en Scala, python ou Java. Il inclut également plusieurs bibliothèques étroitement intégrées pour SQL ([Spark](https://spark.apache.org/sql/)), le machine learning ([MLlib](https://spark.apache.org/mllib/)), le traitement de flux ([Spark streaming](https://spark.apache.org/streaming/)) et le traitement de [graphes (GraphX](https://spark.apache.org/graphx/)). Ces outils facilitent l'exploitation de l'infrastructure Spark pour une grande variété de cas d'utilisation. Vous pouvez installer Spark sur un cluster Amazon EMR avec d’autres applications Hadoop. Cette solution peut également exploiter le système de fichiers Amazon EMR (EMRFS) pour accéder directement aux données dans Amazon S3. Hive est également intégré à Spark afin que vous puissiez utiliser un HiveContext objet pour exécuter des scripts Hive à l'aide de Spark. Un contexte Hive est inclus dans le shell de Spark en tant que `sqlContext`. Pour un exemple de didacticiel sur la configuration d'un cluster EMR avec Spark et sur l'analyse d'un exemple de jeu de données, consultez [Tutoriel : Getting started with Amazon EMR sur le blog News.](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html) AWS Vous pouvez utiliser l'agent de dépannage Apache Spark pour dépanner vos applications Apache Spark sur EMR sur EC2 et EMR Serverless. Pour en savoir plus, veuillez consulter[Qu'est-ce que l'agent de résolution des problèmes Apache Spark pour Amazon EMR](spark-troubleshoot.md). **Important** Apache Spark version 2.3.1, disponible à partir de la version 5.16.0 d'Amazon EMR, corrige [CVE-2018-8024](https://nvd.nist.gov/vuln/detail/CVE-2018-8024) et [CVE-2018-1334](https://nvd.nist.gov/vuln/detail/CVE-2018-1334). Nous vous recommandons de migrer les versions antérieures de Spark vers la version 2.3.1 ou ultérieure. Le tableau suivant répertorie la version de Spark incluse dans la dernière version d’Amazon EMR série 7.x, ainsi que les composants qu’Amazon EMR installe avec Spark. Pour connaître la version des composants installés avec Spark dans cette version, consultez la [version 7.12.0 Versions des composants](emr-7120-release.md). **Informations sur la version de Spark pour emr-7.12.0** | Étiquette de version Amazon EMR | Version de Spark | Composants installés avec Spark | | --- | --- | --- | | emr-7,12.0 | Spark 3.5.6-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | Le tableau suivant répertorie la version de Spark incluse dans la dernière version d'Amazon EMR série 6.x, ainsi que les composants qu'Amazon EMR installe avec Spark. Pour connaître la version des composants installés avec Spark dans cette version, consultez la rubrique [Versions des composants de la version 6.15.0](emr-6150-release.md). **Informations sur la version de Spark pour emr-6.15.0** | Étiquette de version Amazon EMR | Version de Spark | Composants installés avec Spark | | --- | --- | --- | | emr-6.15.0 | Spark 3.4.1-amzn-2 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | **Note** La version 6.8.0 d'Amazon EMR est fournie avec la version 3.3.0 d'Apache Spark. Cette version de Spark utilise Apache Log4j 2 et le fichier `log4j2.properties` pour configurer Log4j dans les processus Spark. Si vous utilisez Spark dans le cluster ou si vous créez des clusters EMR avec des paramètres de configuration personnalisés, et que vous voulez passer à la version 6.8.0 d'Amazon EMR, vous devez migrer vers la nouvelle classification de configuration `spark-log4j2` et le nouveau format de clé pour Apache Log4j 2. Pour de plus amples informations, veuillez consulter [Migration d'Apache Log4j 1.x vers Log4j 2.x](emr-spark-configure.md#spark-migrate-logj42). Le tableau suivant répertorie la version de Spark incluse dans la dernière version d'Amazon EMR série 5.x, ainsi que les composants qu'Amazon EMR installe avec Spark. Pour la version des composants installés avec Spark dans cette version, consultez la [version 5.36.2 Versions des composants](emr-5362-release.md). **Informations sur la version de Spark pour emr-5.36.2** | Étiquette de version Amazon EMR | Version de Spark | Composants installés avec Spark | | --- | --- | --- | | emr-5.36.2 | Spark 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | **Topics** + [Création d’un cluster avec Apache Spark](emr-spark-launch.md) + [Exécution d’applications Spark avec Docker sur Amazon EMR 6.x](emr-spark-docker.md) + [Utiliser le catalogue AWS Glue Data Catalog avec Spark sur Amazon EMR](emr-spark-glue.md) + [Utilisation d'une hiérarchie de plusieurs catalogues dans AWS Glue Data Catalog avec Spark sur Amazon EMR](emr-multi-catalog.md) + [Configuration de Spark](emr-spark-configure.md) + [Qu'est-ce que l'agent de résolution des problèmes Apache Spark pour Amazon EMR](spark-troubleshoot.md) + [Optimisation des performances de Spark](emr-spark-performance.md) + [Mise en cache des fragments de résultats Spark](emr-spark-fragment-result-caching.md) + [Utilisation de l’accélérateur Nvidia RAPIDS pour Apache Spark](emr-spark-rapids.md) + [Accès au shell de Spark](emr-spark-shell.md) + [Utiliser Amazon SageMaker Spark pour le machine learning](emr-spark-sagemaker.md) + [Ecriture d'une application Spark](emr-spark-application.md) + [Améliorer les performances de Spark avec Amazon S3](emr-spark-s3-performance.md) + [Ajout d'une étape Spark](emr-spark-submit-step.md) + [Afficher l'historique de l'application Spark](emr-spark-application-history.md) + [Accédez au site Web Spark UIs](emr-spark-webui.md) + [Utilisation du connecteur Amazon Kinesis Data Streams pour le streaming structuré Spark](emr-spark-structured-streaming-kinesis.md) + [Utilisation de l'intégration d'Amazon Redshift pour Apache Spark avec Amazon EMR](emr-spark-redshift.md) + [Historique des versions de Spark](Spark-release-history.md) + [Utilisation de vues matérialisées avec Amazon EMR](emr-spark-materialized-views.md) # Création d’un cluster avec Apache Spark La procédure suivante permet de créer un cluster avec [Spark](https://aws.amazon.com/big-data/what-is-spark/) installé à l’aide des **options rapides** de la console Amazon EMR. Vous pouvez alternativement utiliser **Options avancées** pour personnaliser davantage la configuration de votre cluster, ou pour soumettre des étapes d'installation par programmation d'applications, puis d'exécution d'applications personnalisées. Avec l'une ou l'autre des options de création de cluster, vous pouvez choisir d'utiliser AWS Glue comme métastore Spark SQL. Pour plus d’informations, consultez [Utiliser le catalogue AWS Glue Data Catalog avec Spark sur Amazon EMR](emr-spark-glue.md). **Pour lancer un cluster avec Spark installé** 1. [Ouvrez la console Amazon EMR à l'adresse /emr. https://console.aws.amazon.com](https://console.aws.amazon.com/emr/) 1. Choisissez **Créer un cluster** pour utiliser **Options rapides**. 1. Entrez un **nom de cluster**. Le nom de votre cluster ne peut pas contenir les caractères <, >, \$1, \$1 ou `(backtick). 1. Pour **Configuration logicielle**, choisissez une option de **Version**. 1. Sous **Applications**, choisissez la solution groupée d'applications **Spark**. 1. Sélectionnez d'autres options si nécessaire, puis choisissez **Create cluster (Créer le cluster)**. **Note** Pour configurer Spark lorsque vous créez le cluster, consultez [Configuration de Spark](emr-spark-configure.md). **Pour lancer un cluster sur lequel Spark est installé à l'aide du AWS CLI** + Créez le cluster à l'aide de la commande suivante. ``` aws emr create-cluster --name "Spark cluster" --release-label emr-7.12.0 --applications Name=Spark \ --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 --use-default-roles ``` **Note** Les caractères de continuation de ligne Linux (\$1) sont inclus pour des raisons de lisibilité. Ils peuvent être supprimés ou utilisés dans les commandes Linux. Pour Windows, supprimez-les ou remplacez-les par un caret (^). **Pour lancer un cluster avec Spark installé à l'aide du kit SDK pour Java** Spécifiez Spark comme application avec `SupportedProductConfig` utilisé dans `RunJobFlowRequest`. + L'exemple suivant montre comment créer un cluster avec Spark au moyen de Java. ``` import com.amazonaws.AmazonClientException; import com.amazonaws.auth.AWSCredentials; import com.amazonaws.auth.AWSStaticCredentialsProvider; import com.amazonaws.auth.profile.ProfileCredentialsProvider; import com.amazonaws.services.elasticmapreduce.AmazonElasticMapReduce; import com.amazonaws.services.elasticmapreduce.AmazonElasticMapReduceClientBuilder; import com.amazonaws.services.elasticmapreduce.model.*; import com.amazonaws.services.elasticmapreduce.util.StepFactory; public class Main { public static void main(String[] args) { AWSCredentials credentials_profile = null; try { credentials_profile = new ProfileCredentialsProvider("default").getCredentials(); } catch (Exception e) { throw new AmazonClientException( "Cannot load credentials from .aws/credentials file. " + "Make sure that the credentials file exists and the profile name is specified within it.", e); } AmazonElasticMapReduce emr = AmazonElasticMapReduceClientBuilder.standard() .withCredentials(new AWSStaticCredentialsProvider(credentials_profile)) .withRegion(Regions.US_WEST_1) .build(); // create a step to enable debugging in the AWS Management Console StepFactory stepFactory = new StepFactory(); StepConfig enabledebugging = new StepConfig() .withName("Enable debugging") .withActionOnFailure("TERMINATE_JOB_FLOW") .withHadoopJarStep(stepFactory.newEnableDebuggingStep()); Application spark = new Application().withName("Spark"); RunJobFlowRequest request = new RunJobFlowRequest() .withName("Spark Cluster") .withReleaseLabel("emr-5.20.0") .withSteps(enabledebugging) .withApplications(spark) .withLogUri("s3://path/to/my/logs/") .withServiceRole("EMR_DefaultRole") .withJobFlowRole("EMR_EC2_DefaultRole") .withInstances(new JobFlowInstancesConfig() .withEc2SubnetId("subnet-12ab3c45") .withEc2KeyName("myEc2Key") .withInstanceCount(3) .withKeepJobFlowAliveWhenNoSteps(true) .withMasterInstanceType("m4.large") .withSlaveInstanceType("m4.large")); RunJobFlowResult result = emr.runJobFlow(request); System.out.println("The cluster ID is " + result.toString()); } } ``` # Exécution d’applications Spark avec Docker sur Amazon EMR 6.x **Note** La procédure décrite fonctionne uniquement avec Amazon EMR version 6.x. Avec Amazon EMR 6.0.0, les applications Spark peuvent utiliser des conteneurs Docker pour définir leurs dépendances de bibliothèque au lieu d'installer des dépendances sur les instances Amazon EC2 individuelles du cluster. Pour exécuter Spark avec Docker, vous devez d'abord configurer le registre Docker et définir des paramètres supplémentaires lors de la soumission d'une application Spark. Pour plus d'informations, consultez [Configuration de l'intégration Docker](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html). Lorsque l'application est soumise, YARN appelle Docker pour extraire l'image Docker spécifiée et exécuter l'application Spark dans un conteneur Docker. Cette approche vous permet de définir et d'isoler facilement les dépendances. Elle réduit le temps d'amorçage ou de préparation des instances dans le cluster Amazon EMR avec les bibliothèques nécessaires à l'exécution des tâches. ## Considérations lors de l'exécution de Spark avec Docker Lorsque vous exécutez Spark avec Docker, assurez-vous que les conditions suivantes sont remplies : + Le package `docker` et l'interface de ligne de commande ne sont installés que sur les nœuds principaux et de tâche. + Sur Amazon EMR 6.1.0 et versions ultérieures, vous pouvez également installer Docker sur un nœud primaire à l'aide des commandes suivantes. + ``` sudo yum install -y docker sudo systemctl start docker ``` + La commande `spark-submit` doit toujours être exécutée à partir d'une instance principale sur le cluster Amazon EMR. + Les registres Docker utilisés pour résoudre les images Docker doivent être définis à l'aide de l'API Classification avec la clé de classification `container-executor` pour définir des paramètres supplémentaires lors du lancement du cluster : + `docker.trusted.registries` + `docker.privileged-containers.registries` + Pour exécuter une application Spark dans un conteneur Docker, les options de configuration suivantes sont nécessaires : + `YARN_CONTAINER_RUNTIME_TYPE=docker` + `YARN_CONTAINER_RUNTIME_DOCKER_IMAGE={DOCKER_IMAGE_NAME}` + Lorsque vous utilisez Amazon ECR pour récupérer des images Docker, vous devez configurer le cluster pour qu'il s'authentifie. Pour ce faire, vous devez utiliser l'option de configuration suivante : + YARN\$1CONTAINER\$1RUNTIME\$1DOCKER\$1CLIENT\$1CONFIG=\$1DOCKER\$1CLIENT\$1CONFIG\$1PATH\$1ON\$1HDFS\$1 + Dans Amazon EMR 6.1.0 et versions ultérieures, vous n’êtes pas obligé d’utiliser la commande répertoriée `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG={DOCKER_CLIENT_CONFIG_PATH_ON_HDFS}` lorsque la fonctionnalité d’authentification automatique ECR est activée. + Toute image Docker utilisée avec Spark implique l'installation préalable de Java dans l'image Docker. Pour plus d'informations sur les conditions préalables, consultez [Configuration de l'intégration de Docker](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html). ## Création d'une image Docker Les images Docker sont créées à l'aide d'un Dockerfile, qui définit les packages et la configuration à inclure dans l'image. Les deux exemples suivants utilisent Dockerfiles et PySpark SparkR. **PySpark Dockerfile** Les images Docker créées à partir de ce Dockerfile incluent Python 3 et le package Python NumPy . Ce Dockerfile utilise Amazon Linux 2 et le kit JDK Amazon Corretto 8. ``` FROM amazoncorretto:8 RUN yum -y update RUN yum -y install yum-utils RUN yum -y groupinstall development RUN yum list python3* RUN yum -y install python3 python3-dev python3-pip python3-virtualenv RUN python -V RUN python3 -V ENV PYSPARK_DRIVER_PYTHON python3 ENV PYSPARK_PYTHON python3 RUN pip3 install --upgrade pip RUN pip3 install numpy pandas RUN python3 -c "import numpy as np" ``` **Dockerfile SparkR** Les images Docker créées à partir de ce Dockerfile incluent R et le package RandomForest CRAN. Ce Dockerfile comprend Amazon Linux 2 et le kit JDK Amazon Corretto 8. ``` FROM amazoncorretto:8 RUN java -version RUN yum -y update RUN amazon-linux-extras install R4 RUN yum -y install curl hostname #setup R configs RUN echo "r <- getOption('repos'); r['CRAN'] <- 'http://cran.us.r-project.org'; options(repos = r);" > ~/.Rprofile RUN Rscript -e "install.packages('randomForest')" ``` Pour plus d'informations sur la syntaxe Dockerfile, consultez la [documentation de référence relative à Dockerfile](https://docs.docker.com/engine/reference/builder/). ## Utilisation d'images Docker depuis Amazon ECR Amazon Elastic Container Registry (Amazon ECR) est un registre de conteneurs Docker entièrement géré qui permet de stocker, de gérer et de déployer facilement les images des conteneurs Docker. Lors de l'utilisation d'Amazon ECR, le cluster doit être configuré pour faire confiance à votre instance d'ECR. Vous devez, par ailleurs, configurer l'authentification pour que le cluster utilise les images Docker à partir d'Amazon ECR. Pour plus d'informations, consultez [Configuration de YARN pour accéder à Amazon ECR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-docker.html#emr-docker-ECR). Pour vous assurer que les hôtes Amazon EMR ont accès aux images stockées dans Amazon ECR, vérifiez que votre cluster dispose des autorisations de la politique `AmazonEC2ContainerRegistryReadOnly` associée au profil d’instance. Pour de plus amples informations, veuillez consulter [Stratégie `AmazonEC2ContainerRegistryReadOnly`](https://docs.aws.amazon.com/AmazonECR/latest/userguide/ecr_managed_policies.html#AmazonEC2ContainerRegistryReadOnly). Dans cet exemple, le cluster doit être créé avec la configuration supplémentaire suivante pour s'assurer que le registre Amazon ECR est approuvé. Remplacez le *123456789123.dkr.ecr.us-east-1.amazonaws.com* point de terminaison par votre point de terminaison Amazon ECR. ``` [ { "Classification": "container-executor", "Configurations": [ { "Classification": "docker", "Properties": { "docker.privileged-containers.registries": "local,centos,123456789123.dkr.ecr.us-east-1.amazonaws.com", "docker.trusted.registries": "local,centos,123456789123.dkr.ecr.us-east-1.amazonaws.com" } } ], "Properties": {} } ] ``` **Utilisation PySpark avec Amazon ECR** L'exemple suivant utilise le PySpark Dockerfile, qui sera balisé et chargé sur Amazon ECR. Après avoir chargé le Dockerfile, vous pouvez exécuter la PySpark tâche et vous référer à l'image Docker depuis Amazon ECR. Après avoir lancé le cluster, utilisez SSH pour vous connecter à un nœud principal et exécutez les commandes suivantes pour créer l'image Docker locale à partir de l'exemple PySpark Dockerfile. Tout d'abord, créez un répertoire et un fichier Dockerfile. ``` mkdir pyspark vi pyspark/Dockerfile ``` Collez le contenu du PySpark Dockerfile et exécutez les commandes suivantes pour créer une image Docker. ``` sudo docker build -t local/pyspark-example pyspark/ ``` Créez le référentiel ECR `emr-docker-examples` pour les exemples. ``` aws ecr create-repository --repository-name emr-docker-examples ``` Marquez et téléchargez l'image créée localement sur ECR, en la remplaçant par votre point de *123456789123.dkr.ecr.us-east-1.amazonaws.com* terminaison ECR. ``` sudo docker tag local/pyspark-example 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example sudo docker push 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example ``` Utilisez SSH pour vous connecter au nœud primaire et préparez un script Python dont le nom de fichier est `main.py`. Collez le contenu suivant dans le fichier `main.py` et enregistrez-le. ``` from pyspark.sql import SparkSession spark = SparkSession.builder.appName("docker-numpy").getOrCreate() sc = spark.sparkContext import numpy as np a = np.arange(15).reshape(3, 5) print(a) ``` Sur Amazon EMR 6.0.0, indiquez le nom de l’image Docker pour soumettre la tâche. Définissez les paramètres de configuration supplémentaires pour vous assurer que l'exécution de la tâche utilise Docker comme environnement d'exécution. Lors de l'utilisation d'Amazon ECR, `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` doit référencer le fichier `config.json` contenant les informations d'identification utilisées pour s'authentifier auprès d'Amazon ECR. ``` DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example DOCKER_CLIENT_CONFIG=hdfs:///user/hadoop/config.json spark-submit --master yarn \ --deploy-mode cluster \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \ --num-executors 2 \ main.py -v ``` Sur Amazon EMR 6.1.0 et versions ultérieures, indiquez le nom de l’image Docker pour soumettre la tâche. Lorsque l'authentification automatique ECR est activée, veuillez exécuter la commande suivante. ``` DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:pyspark-example spark-submit --master yarn \ --deploy-mode cluster \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \ --num-executors 2 \ main.py -v ``` Lorsque la tâche est terminée, prenez note de l'ID de l'application YARN et utilisez la commande suivante pour obtenir le résultat de la PySpark tâche. ``` yarn logs --applicationId application_id | grep -C2 '\[\[' LogLength:55 LogContents: [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] ``` **Utilisation de SparkR avec Amazon ECR** L'exemple suivant utilise le fichier Dockerfile SparkR, qui sera balisé et chargé dans ECR. Une fois le fichier Dockerfile chargé, vous pouvez exécuter la tâche SparkR et vous référer à l'image Docker à partir d'Amazon ECR. Après avoir lancé le cluster, utilisez SSH pour vous connecter à un nœud principal et exécutez les commandes suivantes pour générer l'image Docker locale à partir de l'exemple de Dockerfile SparkR. Tout d'abord, créez un répertoire et un fichier Dockerfile. ``` mkdir sparkr vi sparkr/Dockerfile ``` Collez le contenu du fichier Dockerfile SparkR et exécutez les commandes suivantes pour créer une image Docker. ``` sudo docker build -t local/sparkr-example sparkr/ ``` Marquez et téléchargez l'image créée localement sur Amazon ECR, en la remplaçant par votre point de *123456789123.dkr.ecr.us-east-1.amazonaws.com* terminaison Amazon ECR. ``` sudo docker tag local/sparkr-example 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example sudo docker push 123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example ``` Utilisez SSH pour vous connecter au nœud primaire et préparer un script R avec le nom `sparkR.R`. Collez le contenu suivant dans le fichier `sparkR.R`. ``` library(SparkR) sparkR.session(appName = "R with Spark example", sparkConfig = list(spark.some.config.option = "some-value")) sqlContext <- sparkRSQL.init(spark.sparkContext) library(randomForest) # check release notes of randomForest rfNews() sparkR.session.stop() ``` Sur Amazon EMR 6.0.0, indiquez le nom de l’image Docker pour soumettre la tâche. Définissez les paramètres de configuration supplémentaires pour vous assurer que l'exécution de la tâche utilise Docker comme environnement d'exécution. Lors de l'utilisation d'Amazon ECR, `YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG` doit référencer le fichier `config.json` contenant les informations d'identification utilisées pour s'authentifier auprès d'ECR. ``` DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example DOCKER_CLIENT_CONFIG=hdfs:///user/hadoop/config.json spark-submit --master yarn \ --deploy-mode cluster \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_CLIENT_CONFIG=$DOCKER_CLIENT_CONFIG \ sparkR.R ``` Sur Amazon EMR 6.1.0 et versions ultérieures, indiquez le nom de l’image Docker pour soumettre la tâche. Lorsque l'authentification automatique ECR est activée, exécutez la commande suivante. ``` DOCKER_IMAGE_NAME=123456789123.dkr.ecr.us-east-1.amazonaws.com/emr-docker-examples:sparkr-example spark-submit --master yarn \ --deploy-mode cluster \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \ --conf spark.executorEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_TYPE=docker \ --conf spark.yarn.appMasterEnv.YARN_CONTAINER_RUNTIME_DOCKER_IMAGE=$DOCKER_IMAGE_NAME \ sparkR.R ``` Lorsque la tâche est terminée, prenez note de l'ID de l'application YARN et utilisez la commande suivante pour obtenir la sortie de la tâche SparkR. Cet exemple inclut des tests permettant de vérifier que la bibliothèque randomForest, la version installée et les notes de mise à jour sont disponibles. ``` yarn logs --applicationId application_id | grep -B4 -A10 "Type rfNews" randomForest 4.6-14 Type rfNews() to see new features/changes/bug fixes. Wishlist (formerly TODO): * Implement the new scheme of handling classwt in classification. * Use more compact storage of proximity matrix. * Allow case weights by using the weights in sampling? ======================================================================== Changes in 4.6-14: ``` # Utiliser le catalogue AWS Glue Data Catalog avec Spark sur Amazon EMR À l'aide d'Amazon EMR version 5.8.0 ou ultérieure, vous pouvez configurer Spark pour utiliser le catalogue de données AWS Glue comme métastore Apache Hive. Nous recommandons cette configuration lorsque vous avez besoin d'un métastore Hive persistant ou d'un métastore Hive partagé par différents clusters, services, applications ou comptes. AWS À l'aide d'Amazon EMR version 6.5.0 ou ultérieure, vous pouvez configurer Spark pour utiliser le catalogue de données AWS Glue avec Apache Iceberg. À l'aide d'Amazon EMR version 7.5.0 ou ultérieure, vous pouvez configurer Spark pour utiliser le catalogue de données AWS Glue comme catalogue Iceberg REST. AWS Glue est un service d'extraction, de transformation et de chargement (ETL) entièrement géré qui permet de classer vos données de manière simple et rentable, de les nettoyer, de les enrichir et de les déplacer de manière fiable entre différents magasins de données. Le catalogue de données AWS Glue fournit un référentiel de métadonnées unifié couvrant une variété de sources de données et de formats de données, s'intégrant à Amazon EMR ainsi qu'à Amazon RDS, Amazon Redshift, Redshift Spectrum, Athena et à toute application compatible avec le métastore Apache Hive. AWS Les robots d'exploration Glue peuvent automatiquement déduire un schéma à partir des données sources dans Amazon S3 et stocker les métadonnées associées dans le catalogue de données. Pour plus d'informations sur le catalogue de données, consultez la section [Remplissage du catalogue de données AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/populate-data-catalog.html) dans le *AWS Glue Developer Guide*. Des frais distincts s'appliquent pour AWS Glue. Il existe un tarif mensuel pour le stockage et l'accès aux métadonnées du catalogue de données, un taux horaire facturé par minute pour les tâches AWS Glue ETL et le temps d'exécution des robots d'exploration, et un taux horaire facturé par minute pour chaque point de terminaison de développement provisionné. Le catalogue de données vous permet de stocker jusqu'à un million d'objets sans aucuns frais. Au-delà d'un million d'objets, des frais de 1 USD vous seront facturés tous les 100 000 objets. Dans le catalogue de données, sont considérés comme des objets une table, une partition ou une base de données. Pour de plus amples informations, consultez [Tarification Glue](https://aws.amazon.com/glue/pricing). **Important** Si vous avez créé des tables à l'aide d'Amazon Athena ou d'Amazon Redshift Spectrum avant le 14 août 2017, les bases de données et les tables sont stockées dans un catalogue géré par Athena, distinct du catalogue de données Glue. AWS Pour intégrer Amazon EMR à ces tables, vous devez passer au catalogue de données AWS Glue. Pour plus d'informations, consultez la section [Mise à niveau vers le catalogue de données AWS Glue](https://docs.aws.amazon.com/athena/latest/ug/glue-upgrade.html) dans le guide de l'*utilisateur Amazon Athena*. ## Spécifier le catalogue de données AWS Glue comme métastore Apache Hive Vous pouvez spécifier le catalogue de données AWS Glue comme métastore à l'aide de l'API AWS Management Console AWS CLI, ou Amazon EMR. Lorsque vous utilisez la CLI ou l'API, vous utilisez la classification de configuration de Spark pour spécifier le catalogue de données. En outre, avec Amazon EMR 5.16.0 et versions ultérieures, vous pouvez utiliser la classification de configuration pour spécifier un catalogue de données dans un autre. Compte AWS Lorsque vous utilisez la console, vous pouvez spécifier le catalogue de données à l'aide des **Options avancées** ou des **Options rapides**. **Note** La possibilité d'utiliser AWS Glue Data Catalog est également disponible avec Zeppelin car Zeppelin est installé avec des composants Spark. ------ #### [ Console ] **Pour spécifier AWS Glue Data Catalog comme métastore Apache Hive avec la nouvelle console** 1. [Connectez-vous au et ouvrez la AWS Management Console console Amazon EMR à l'adresse /emr. https://console.aws.amazon.com](https://console.aws.amazon.com/emr) 1. Dans le volet de navigation de gauche, sous **Amazon EMR sur EC2**, choisissez **Clusters**, puis **Créer un cluster**. 1. Sous **Solution groupée d'application**, choisissez **Spark** ou **Custom**. Si vous personnalisez votre cluster, assurez-vous de sélectionner Zeppelin ou Spark comme l'une de vos applications. 1. Sous **Paramètres du catalogue de données AWS Glue**, cochez la case **Utiliser pour les métadonnées de table Spark**. 1. Choisissez toutes les autres options qui s'appliquent à votre cluster. 1. Pour lancer cluster, choisissez **Créer un cluster**. ------ #### [ AWS CLI ] **Pour spécifier le catalogue de données AWS Glue en tant que métastore Apache Hive avec AWS CLI** Pour plus d'informations sur la spécification d'une classification de configuration à l'aide de l'API AWS CLI et Amazon EMR, consultez. [Configuration des applications](emr-configure-apps.md) + Spécifiez la valeur de `hive.metastore.client.factory.class` à l'aide de la classification `spark-hive-site` comme illustré dans l'exemple suivant : ``` [ { "Classification": "spark-hive-site", "Properties": { "hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory" } } ] ``` Pour spécifier un catalogue de données dans un autre AWS compte, ajoutez la `hive.metastore.glue.catalogid` propriété comme indiqué dans l'exemple suivant. Remplacez `acct-id` par le compte AWS du catalogue de données. ``` [ { "Classification": "spark-hive-site", "Properties": { "hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory", "hive.metastore.glue.catalogid": "acct-id" } } ] ``` ------ ## Spécifier le catalogue de données AWS Glue en tant que catalogue Apache Iceberg Vous pouvez spécifier le catalogue de données AWS Glue comme implémentation du catalogue Apache Iceberg, ou comme point de terminaison du catalogue REST Apache Iceberg, à l'aide de l'API AWS Management Console AWS CLI, ou de l'API Amazon EMR, ou lors de la configuration d'exécution de session Spark. Lorsque vous utilisez la CLI ou l'API, vous utilisez la classification de configuration de Spark pour spécifier le catalogue de données. Pour plus de détails, voir [Spécifier le catalogue de données AWS Glue en tant que catalogue Apache Iceberg](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-glue.html#emr-spark-glue-configure-iceberg). ## Autorisations IAM Le profil d'instance EC2 d'un cluster doit disposer des autorisations IAM pour les actions AWS Glue. En outre, si vous activez le chiffrement pour les objets AWS Glue Data Catalog, le rôle doit également être autorisé à chiffrer, déchiffrer et générer les objets AWS KMS key utilisés pour le chiffrement. ### Autorisations pour les actions AWS Glue Aucune action n'est requise si vous utilisez le profil d'instance EC2 par défaut pour Amazon EMR. La politique `AmazonElasticMapReduceforEC2Role` gérée attachée au `EMR_EC2_DefaultRole` autorise toutes les actions AWS Glue nécessaires. Toutefois, si vous spécifiez un profil d'instance EC2 personnalisé et des autorisations, vous devez configurer les actions AWS Glue appropriées. Utilisez la stratégie gérée `AmazonElasticMapReduceforEC2Role` comme point de départ. Pour plus d'informations, consultez [Rôle de service pour les instances EC2 de cluster (profil d'instance EC2)](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-role-for-ec2.html) dans le *Guide de gestion Amazon EMR*. ### Autorisations pour chiffrer et déchiffrer le catalogue de données Glue AWS Votre profil d'instance a besoin d'autorisations pour chiffrer et déchiffrer les données au moyen de votre clé. Vous n'avez *pas* besoin de configurer ces autorisations si les deux déclarations suivantes s'appliquent : + Vous activez le chiffrement des objets du catalogue de données AWS Glue à l'aide de clés gérées pour AWS Glue. + Vous utilisez un cluster Compte AWS identique au AWS Glue Data Catalog. Sinon, vous devez ajouter l'instruction suivante à la politique d'autorisations attachée à votre profil d'instance EC2. Pour plus d'informations sur le chiffrement du catalogue de données AWS Glue, consultez la section [Chiffrer votre catalogue de données](https://docs.aws.amazon.com/glue/latest/dg/encrypt-glue-data-catalog.html) dans le *guide du développeur de AWS Glue*. ### Autorisations basées sur les ressources Si vous utilisez AWS Glue conjointement avec Hive, Spark ou Presto dans Amazon EMR, AWS Glue prend en charge les politiques basées sur les ressources afin de contrôler l'accès aux ressources du catalogue de données. Ces ressources comprennent les bases de données, les tables, les connexions et les fonctions définies par l'utilisateur. Pour plus d'informations, consultez [Politiques de ressources AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-resource-policies.html) dans le *Guide du développeur AWS Glue*. Lorsque vous utilisez des politiques basées sur les ressources pour limiter l'accès à AWS Glue depuis Amazon EMR, le principal que vous spécifiez dans la politique d'autorisation doit être l'ARN du rôle associé au profil d'instance EC2 spécifié lors de la création d'un cluster. Par exemple, pour une politique basée sur les ressources attachée à un catalogue, vous pouvez spécifier l'ARN du rôle de service par défaut pour les instances EC2 du cluster, *EMR\$1EC2\$1DefaultRole* en utilisant le `Principal` format illustré dans l'exemple suivant : ``` arn:aws:iam::acct-id:role/EMR_EC2_DefaultRole ``` Il *acct-id* peut être différent de l'identifiant du compte AWS Glue. Cela permet d'accéder aux clusters EMR à partir de comptes différents. Vous pouvez spécifier plusieurs principaux, chacun provenant d'un compte différent. ## Considérations relatives à l'utilisation de AWS Glue Data Catalog Tenez compte des éléments suivants lorsque vous utilisez AWS Glue Data Catalog comme métastore Apache Hive avec Spark : + Le manque de base de données par défaut sans URI d'emplacement entraîne des échecs lorsque vous créez une table. Pour contourner ce problème, utilisez la clause `LOCATION` pour spécifier un emplacement de bucket, tel que `s3://amzn-s3-demo-bucket1`, lorsque vous utilisez `CREATE TABLE`. Vous pouvez aussi créer des tables dans une autre base de données que celle par défaut. + Il n'est pas possible de renommer des tables depuis AWS Glue. + Lorsque vous créez une table Hive sans spécifier de `LOCATION`, les données de la table sont stockées à l'emplacement spécifié par la propriété `hive.metastore.warehouse.dir`. Par défaut, il s'agit d'un emplacement dans HDFS. Si un autre cluster doit accéder à la table, il échoue, sauf s'il dispose d'autorisations adéquates sur le cluster qui a créé la table. En outre, le stockage dans HDFS étant transitoire, si le cluster est résilié, les données de la table sont perdues et la table doit être recréée. Nous vous recommandons de spécifier un `LOCATION` dans Amazon S3 lorsque vous créez une table Hive à l'aide de AWS Glue. Vous pouvez également utiliser la classification de configuration `hive-site` pour spécifier un emplacement dans Amazon S3 pour `hive.metastore.warehouse.dir`, qui s'applique à toutes les tables Hive. Si une table est créée dans un emplacement HDFS et que le cluster qui l'a créée est toujours en cours d'exécution, vous pouvez mettre à jour l'emplacement de la table vers Amazon S3 depuis AWS Glue. Pour plus d'informations, consultez [Working with Tables on the AWS Glue Console](https://docs.aws.amazon.com/glue/latest/dg/console-tables.html) dans le *AWS Glue Developer Guide*. + Les valeurs de partition contenant des guillemets et des apostrophes ne sont pas prises en charge, par exemple `PARTITION (owner="Doe's").`. + Les [statistiques sur les colonnes](https://cwiki.apache.org/confluence/display/Hive/StatsDev#StatsDev-ColumnStatistics) sont prises en charge à partir de la version emr-5.31.0. + L'utilisation de l'[autorisation Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+Authorization) n'est pas prise en charge. Comme alternative, envisagez d'utiliser les [politiques basées sur les ressources AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/glue-resource-policies.html). Pour plus d'informations, consultez [Utiliser des politiques basées sur les ressources pour Amazon EMR Access to Glue AWS](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles-glue.html) Data Catalog. Tenez compte des points suivants lorsque vous utilisez AWS Glue Data Catalog en tant que catalogue REST Apache Iceberg avec Spark : + Si vous utilisez le catalogue de sessions Spark avec Iceberg, décrit dans[Différences de configuration entre Iceberg SparkCatalog et SparkSessionCatalog](emr-iceberg-use-spark-cluster.md#emr-iceberg-spark-catalog), vous devez configurer le catalogue de données AWS Glue en tant que métastore Apache Hive, en plus de configurer le catalogue de données AWS Glue en tant que catalogue REST Apache Iceberg. + Le point de terminaison IRC AWS Glue Data Catalog prend uniquement en charge le schéma d'authentification Amazon SigV4. OAuth n'est pas pris en charge. Pour OAuth les utilisateurs, veuillez utiliser IAM Identity Center pour configurer l'accès. Voir [Connecting Lake Formation with IAM Identity Center](https://docs.aws.amazon.com/lake-formation/latest/dg/connect-lf-identity-center.html). + Le catalogue REST de AWS Glue Iceberg ne prend pas en charge toutes les opérations en open source. # Utilisation d'une hiérarchie de plusieurs catalogues dans AWS Glue Data Catalog avec Spark sur Amazon EMR Vous pouvez enregistrer votre cluster Amazon EMR pour accéder au catalogue de données AWS Glue, qui met les tables et autres ressources du catalogue à la disposition de différents consommateurs. AWS Glue Data Catalog prend en charge une hiérarchie de catalogues multiples, qui unifie vos données dans les lacs de données Amazon S3. Il fournit également une API de métastore Hive et une API REST Apache Iceberg open source pour accéder aux données. Ces fonctionnalités sont disponibles pour Amazon EMR et d'autres services tels Amazon Athena qu'Amazon Redshift. ## Comment les ressources du catalogue sont organisées Lorsque vous créez des ressources dans le catalogue de données AWS Glue, vous pouvez y accéder depuis n'importe quel moteur SQL compatible avec l'API REST d'Apache Iceberg ou le métastore Hive. AWS Lake Formation gère les autorisations. Dans AWS Glue Data Catalog, les données sont organisées selon une hiérarchie logique de catalogues, de bases de données et de tables : + **Catalogue** : conteneur logique qui contient des objets provenant d'un magasin de données, tels que des schémas ou des tables. + **Catalogue pour stocker les tables Redshift Managed Storage (RMS) : lorsque vous gérez des catalogues pour stocker des tables** RMS, vous pouvez accéder à ces tables à l'aide d'Iceberg. + **Base de** données : organise les objets de données tels que les tables et les vues dans un catalogue. + **Tables et vues** : objets de données d'une base de données qui fournissent une couche d'abstraction avec un schéma compréhensible. Ils fournissent une couche permettant d'accéder aux données sous-jacentes, qui peuvent être dans différents formats et à différents emplacements. ## Configuration d'un catalogue de données à utiliser avec Amazon EMR Pour commencer, vous configurez le catalogue pour qu'il prenne en charge les outils Amazon EMR. Le catalogue de données AWS Glue est compatible avec le métastore Hive et avec Iceberg REST. APIs **Configuration d'Amazon EMR avec un metastore Hive** Pour plus d'informations sur la configuration de cette option, consultez la section relative à la prise en [charge des tâches Spark par AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-data-catalog-hive.html) dans le guide de l'utilisateur de AWS Glue. Cette rubrique explique comment configurer AWS Glue Data Catalog en tant que métastore Hive et comment le rendre disponible en tant que point de terminaison. De plus, la documentation Amazon EMR vous montre comment spécifier Glue Data Catalog en tant que métastore Spark, dans Use [the AWSAWS Glue Data Catalog en tant que métastore Apache Hive](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-glue.html) pour Spark. ## Autorisations d'accès aux ressources dans AWS Glue Data Catalog Cette section décrit les exigences de la politique IAM relatives à l'utilisation des outils Amazon EMR avec les données du catalogue. Après avoir enregistré votre cluster dans le catalogue de données AWS Glue, vous devez disposer des autorisations suivantes pour découvrir la création et les modifications apportées au catalogue de données créé ultérieurement : + **colle : GetCatalog** + **colle : GetCatalogs** + **sièges : AssumeRole** + **sièges : TagSession** + **sièges : SetContext** + **sièges : SetSourceIdentity** Dans la plupart des cas, lorsque vous attribuez des autorisations, nous vous recommandons de créer un rôle IAM et de lui attribuer des autorisations. En outre, pour interroger les données du catalogue, vous devez définir des autorisations pour le catalogue de données à l'aide de AWS Lake Formation. Pour plus d'informations sur la définition des autorisations pour les catalogues de données dans AWS Lake Formation, consultez la section [Octroi et révocation d'autorisations sur les ressources du catalogue de données](https://docs.aws.amazon.com/lake-formation/latest/dg/granting-catalog-permissions.html). Après avoir créé et configuré votre cluster, et défini les autorisations sur les objets de votre catalogue, vous pouvez soumettre des tâches pour interroger et traiter des données. ## Configurer Spark pour accéder à une hiérarchie de catalogues multiples dans AWS Glue Data Catalog Avec EMR 7.5, vous pouvez configurer Spark pour utiliser la hiérarchie multi-catalogues de AWS Glue. Une hiérarchie de catalogues multiples vous permet de : + Importez vos données de stockage géré Redshift (RMS), telles que les tables, les vues et les vues matérialisées provenant d'entrepôts de données Amazon Redshift existants, vers Glue Data Catalog. AWS Vous pouvez interroger ces objets en utilisant EMR sur EC2 et EMR Serverless. + Créez des catalogues RMS, AWS Glue Data Catalog et stockez les données dans RMS à l'aide de ZeroETL et interrogez les données à l'aide de moteurs de requête compatibles avec Iceberg. + Créez des tables Iceberg gérées dans AWS Glue Data Catalog grâce à une gestion du stockage complète qui inclut le compactage, les instantanés et la rétention. ### Connexion à un catalogue multiple lors de l'initialisation d'une session Spark Les exemples suivants montrent comment utiliser le shell interactif Spark, Spark Submit ou Amazon EMR Notebooks pour utiliser la hiérarchie multi-catalogues AWS de Glue. ------ #### [ spark-shell ] 1. Connexion au nœud principal à l'aide de SSH Pour plus d'informations, consultez [Connexion au nœud principal à l'aide de SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) dans le *Guide de gestion d'Amazon EMR*. 1. Entrez la commande suivante pour lancer le shell Spark. Pour utiliser la PySpark coque, remplacez-la `spark-shell` par`pyspark`. ``` spark-shell \ --conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \ --conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket/prefix/ --conf spark.sql.catalog.my_catalog.type=glue \ --conf spark.sql.catalog.my_catalog.glue.id=Glue RMS catalog ID \ --conf spark.sql.defaultCatalog=my_catalog \ --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ``` ------ #### [ spark-submit ] 1. Connexion au nœud principal à l'aide de SSH Pour plus d'informations, consultez [Connexion au nœud principal à l'aide de SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) dans le *Guide de gestion d'Amazon EMR*. 1. Entrez la commande suivante pour lancer la session Spark pour Spark. ``` spark-submit \ --conf spark.sql.catalog.my_catalog=org.apache.iceberg.spark.SparkCatalog \ --conf spark.sql.catalog.my_catalog.warehouse=s3://amzn-s3-demo-bucket1/prefix \ --conf spark.sql.catalog.my_catalog.type=glue \ --conf spark.sql.catalog.my_catalog.glue.id=Glue RMS catalog ID \ --conf spark.sql.defaultCatalog=my_catalog \ --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ``` ------ #### [ EMR Studio notebooks ] Pour initialiser une session Spark à l'aide des blocs-notes EMR Studio, configurez votre session Spark à l'aide de la commande magique `%%configure` de votre bloc-notes Amazon EMR, comme dans l'exemple suivant. Pour plus d'informations, consultez [Utilisation des magies de Blocs-notes EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html#emr-magics) dans le *Guide de gestion Amazon EMR*. ``` %%configure -f{ "conf":{ "spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.my_catalog.type":"glue", "spark.sql.catalog.my_catalog.glue.id":"Glue RMS catalog ID", "spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/", "spark.sql.defaultCatalog", "my_catalog", "spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions" } } ``` ------ #### [ CLI ] Pour initialiser une session Spark à l'aide de la CLI, exécutez l'exemple suivant. Pour plus d'informations sur la spécification d'une classification de configuration à l'aide de l'API Amazon EMR AWS CLI et Amazon EMR, consultez [Configurer](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html) les applications. ``` [ { "Classification": "spark-defaults", "Properties": { "spark.sql.catalog.my_catalog":"org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.my_catalog.type":"glue", "spark.sql.catalog.my_catalog.glue.id":"Glue RMS catalog ID", "spark.sql.catalog.my_catalog.warehouse":"s3://amzn-s3-demo-bucket1/prefix/", "spark.sql.defaultCatalog", "my_catalog", "spark.sql.extensions":"org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions" } } ] ``` ------ #### Initialisation d'une session Spark dans Redshift Managed Storage with AWS Glue Data Catalog L'exemple de commande suivant initialise une session Spark avec le AWS Glue Data Catalog. ``` spark-sql \ --conf spark.sql.catalog.rms=org.apache.iceberg.spark.SparkCatalog \ --conf spark.sql.catalog.rms.type=glue \ --conf spark.sql.catalog.rms.glue.id=Glue RMS catalog ID \ --conf spark.sql.defaultCatalog=rms --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ``` L'exemple suivant initialise une session Spark à l'aide de l'API REST d'Iceberg et du catalogue de données Redshift Managed Storage with Glue AWS . ``` spark-sql \ --conf spark.sql.catalog.rms=org.apache.iceberg.spark.SparkCatalog \ --conf spark.sql.catalog.rms.type=rest \ --conf spark.sql.catalog.rms.warehouse=glue RMS catalog ID \ --conf spark.sql.catalog.rms.uri=Glue endpoint URI/iceberg \ --conf spark.sql.catalog.rms.rest.sigv4-enabled=true \ --conf spark.sql.catalog.rms.rest.signing-name=glue \ --conf spark.sql.defaultCatalog=rms \ --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ``` Pour plus d'informations sur l'utilisation d'une hiérarchie multi-catalogues AWS Glue avec Spark Iceberg, consultez [Utiliser un cluster Iceberg](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-iceberg-use-spark-cluster.html) avec Spark. ## Considérations et limites relatives à une configuration à catalogues multiples + L'utilisation d'une hiérarchie de catalogues multiples avec le métastore Apache Hive n'est pas prise en charge. + L'utilisation d'une hiérarchie de catalogues multiples avec Apache Iceberg ne permet pas de revenir à la métastore Apache Hive lors de l'utilisation. `SparkSessionCatalog` + L'EMR sur les clusters EC2 dotés du rôle Runtime ne prend pas en charge la hiérarchie multi-catalogues. + L'EMR sur les clusters EC2 activé AWS Lake Formation ne prend pas en charge la hiérarchie multi-catalogues. # Configuration de Spark Vous pouvez configurer [Spark sur Amazon EMR](https://aws.amazon.com/elasticmapreduce/details/spark/) à l’aide de classifications de configuration. Pour plus d'informations sur les classifications de configuration, consultez [Configuration des applications](emr-configure-apps.md). Les classifications de configuration pour Spark sur Amazon EMR incluent : + **`spark`** – Définit la propriété `maximizeResourceAllocation` sur la valeur true ou false. Lorsque la valeur est true, Amazon EMR configure automatiquement les propriétés `spark-defaults` en fonction de la configuration matérielle du cluster. Pour de plus amples informations, veuillez consulter [Utilisation de `maximizeResourceAllocation`](#emr-spark-maximizeresourceallocation). + **`spark-defaults`** – Définit les valeurs dans le fichier `spark-defaults.conf`. Pour plus d'informations, consultez [Configuration Spark](https://spark.apache.org/docs/latest/configuration.html) dans la documentation Spark. + **`spark-env`** – Définit les valeurs dans le fichier `spark-env.sh`. Pour plus d'informations, consultez [Variables d'environnement](https://spark.apache.org/docs/latest/configuration.html#environment-variables) dans la documentation Spark. + **`spark-hive-site`** – Définit les valeurs dans le `hive-site.xml` pour Spark. + **`spark-log4j`** : (Amazon EMR versions 6.7.x et antérieures) définit les valeurs dans le fichier `log4j.properties`. Pour plus d'informations, consultez le fichier [log4j.properties.template](https://github.com/apache/spark/blob/branch-3.2/conf/log4j.properties.template) sur Github. + **`spark-log4j2`** : (Amazon EMR versions 6.8.0 et supérieures) définit les valeurs du fichier `log4j2.properties`. Pour plus d'informations, consultez le fichier [log4j2.properties.template](https://github.com/apache/spark/blob/v3.3.0/conf/log4j2.properties.template) sur Github. + **`spark-metrics`** – Définit les valeurs dans le fichier `metrics.properties`. Pour les paramètres et plus d'informations, consultez le fichier [metrics.properties.template](https://github.com/apache/spark/blob/master/conf/metrics.properties.template) sur Github, et [Métriques](https://spark.apache.org/docs/latest/monitoring.html#metrics) dans la documentation Spark. **Note** Si vous migrez des charges de travail Spark vers Amazon EMR depuis une autre plateforme, nous vous recommandons de tester vos charges de travail avec le [Valeurs Spark par défaut définies par Amazon EMR](#spark-defaults) avant d'ajouter des configurations personnalisées. La plupart des clients constatent une amélioration des performances grâce à nos paramètres par défaut. **Topics** + [Valeurs Spark par défaut définies par Amazon EMR](#spark-defaults) + [Configuration du récupérateur de mémoire Spark sur Amazon EMR 6.1.0](#spark-gc-config) + [Utilisation de `maximizeResourceAllocation`](#emr-spark-maximizeresourceallocation) + [Configuration du comportement de mise hors service du nœud](#spark-decommissioning) + [Variable d' ThriftServer environnement Spark](#spark-thriftserver) + [Modification des paramètres Spark par défaut](#spark-change-defaults) + [Migration d'Apache Log4j 1.x vers Log4j 2.x](#spark-migrate-logj42) ## Valeurs Spark par défaut définies par Amazon EMR La table suivante illustre comment Amazon EMR définit les valeurs par défaut dans `spark-defaults` qui affectent les applications. **Valeurs Spark par défaut définies par Amazon EMR** | Paramètre | Description | Valeur par défaut | | --- | --- | --- | | spark.executor.memory | Quantité de mémoire à utiliser par processus d'exécution. Par exemple   `1g`, `2g`. | Ce paramètre est déterminé par les types d'instance de noyau et de tâche dans le cluster. | | spark.executor.cores | Le nombre de cœurs à utiliser sur chaque exécuteur. | Ce paramètre est déterminé par les types d'instance de noyau et de tâche dans le cluster. | | spark.dynamicAllocation.enabled | Lorsque cela est vrai, utilisez l'allocation dynamique des ressources pour augmenter ou réduire le nombre d'exécuteurs enregistrés avec une application en fonction de la charge de travail. | `true` (avec Amazon EMR 4.4.0 et versions ultérieures) Le service Spark réorganisé est automatiquement configuré par Amazon EMR. | | spark.sql.hive.advancedPartitionPredicatePushdown.enabled | Lorsque c'est vrai, le transfert avancé des prédicats de partition vers le métastore Hive est activé. | true | | spark.sql.hive.stringLikePartitionPredicatePushdown.enabled | Pousse vers le bas les filtres `startsWith`, `contains` et `endsWith` dans le métastore Hive. Glue ne prend pas en charge le push down des prédicats pour `startsWith`, `contains`, ou `endsWith`. Si vous utilisez le métastore Glue et que vous rencontrez des erreurs en raison de l'activation des prédicats pour ces fonctions, définissez cette configuration sur `false`. | true | ## Configuration du récupérateur de mémoire Spark sur Amazon EMR 6.1.0 La définition de configurations personnalisées de récupérateur de mémoire avec `spark.driver.extraJavaOptions` et `spark.executor.extraJavaOptions` entraîne un échec du lancement du pilote ou de l'exécuteur avec Amazon EMR 6.1 en raison d'une configuration de récupérateur de mémoire conflictuelle avec Amazon EMR 6.1.0. Pour Amazon EMR 6.1.0, la configuration de récupérateur de mémoire par défaut est définie via `spark.driver.defaultJavaOptions` et `spark.executor.defaultJavaOptions`. Cette configuration s'applique uniquement à Amazon EMR 6.1.0. Les options de la JVM non liées au récupérateur de mémoire, telles que celles permettant de configurer le journal (`-verbose:class`), peuvent toujours être définies via `extraJavaOptions`. Pour plus d'informations, consultez [Propriétés de l'application Spark.](https://spark.apache.org/docs/latest/configuration.html#application-properties) ## Utilisation de `maximizeResourceAllocation` Pour configurer vos exécuteurs afin qu'ils utilisent le maximum de ressources possibles sur chaque nœud d'un cluster, définissez `maximizeResourceAllocation` sur `true` dans votre classification de configuration `spark`. `maximizeResourceAllocation` est spécifique à Amazon EMR. Lorsque vous activez `maximizeResourceAllocation`, Amazon EMR calcule les ressources de calcul et de mémoire maximales disponibles pour un exécuteur sur une instance du groupe d’instances principales. Il définit ensuite les paramètres correspondants `spark-defaults` en fonction des valeurs maximales calculées. Amazon EMR calcule les ressources de calcul et de mémoire maximales disponibles pour un exécuteur en fonction d'un type d'instance issu du parc d'instances principal. Étant donné que chaque parc d'instances peut avoir des types et des tailles d'instances différents au sein d'un même parc, la configuration d'exécuteur utilisée par Amazon EMR n'est peut-être pas la meilleure pour vos clusters. Nous vous déconseillons donc d'utiliser les paramètres par défaut lors de l'utilisation d'une allocation de ressources maximale. Configurez des paramètres personnalisés pour vos clusters de flotte d'instances. **Note** Vous ne devez pas utiliser l'`maximizeResourceAllocation`option sur des clusters contenant d'autres applications distribuées telles que HBase. Amazon EMR utilise des configurations YARN personnalisées pour les applications distribuées, qui peuvent entrer en conflit avec `maximizeResourceAllocation` et faire échouer les applications Spark. Voici un exemple de classification de configuration Spark avec `maximizeResourceAllocation` défini sur `true`. ``` [ { "Classification": "spark", "Properties": { "maximizeResourceAllocation": "true" } } ] ``` **Paramètres configurés dans `spark-defaults` lorsque `maximizeResourceAllocation` est activé** | Paramètre | Description | Value | | --- | --- | --- | | spark.default.parallelism | Le nombre de partitions par défaut RDDs est renvoyé par des transformations telles que jointure et parallélisation lorsqu'elles ne sont pas définies par l'utilisateur. reduceByKey | 2X nombre de cœurs de processeurs disponibles sur des conteneurs YARN. | | spark.driver.memory | Quantité de mémoire à utiliser pour le processus du pilote, c'est-à-dire où SparkContext est initialisé. (par exemple, 1 g, 2 g). | Le paramétrage est configuré en fonction des types d'instances dans le cluster. Cependant, parce que l'application de pilote Spark peut s'exécuter soit sur le maître, soit sur une des instances principales (par exemple, dans le client YARN et les modes cluster, respectivement), la définition dépend du plus petit des types d'instance dans ces deux groupes d'instances. | | spark.executor.memory | Volume de mémoire à utiliser par les processus de l'exécuteur. (par exemple, 1g, 2g) | Le paramétrage est configuré en fonction des types d'instances de noyau et de tâches dans le cluster. | | spark.executor.cores | Le nombre de cœurs à utiliser sur chaque exécuteur. | Le paramétrage est configuré en fonction des types d'instances de noyau et de tâches dans le cluster. | | spark.executor.instances | Le nombre d'exécuteurs. | Le paramétrage est configuré en fonction des types d'instances de noyau et de tâches dans le cluster. Définissez, sauf si `spark.dynamicAllocation.enabled` définit explicitement sur true en même temps. | ## Configuration du comportement de mise hors service du nœud Lorsque vous utilisez Amazon EMR 5.9.0 ou une version ultérieure, Spark sur Amazon EMR inclut un ensemble de fonctionnalités qui permettent de s’assurer que Spark gère plus élégamment l’arrêt des nœuds suite à un redimensionnement manuel ou à une demande de politique de mise à l’échelle automatique. Amazon EMR implémente un mécanisme de liste de refus dans Spark par-dessus le mécanisme de mise hors service de YARN. Ce mécanisme aide à garantir qu'aucune nouvelle tâche n'est planifiée sur un nœud qui est mis hors service, tout en autorisant dans le même temps que les tâches déjà en cours d'exécution se terminent. En outre, il existe des fonctionnalités qui permettent de rétablir les tâches Spark plus rapidement en cas de perte de blocs aléatoires lors de la terminaison d'un nœud. Le processus de recalcul est déclenché plus tôt et optimisé pour un recalcul plus rapide avec moins de tentatives d'étape ; en outre, il est possible d'empêcher l'échec des tâches dû aux défaillances d'extraction provoquées par les blocs aléatoires manquants. **Important** Le paramètre `spark.decommissioning.timeout.threshold` a été ajouté dans la version 5.11.0 d'Amazon EMR pour améliorer la résilience de Spark lorsque vous utilisez des instances Spot. Dans les versions précédentes, lorsqu'un nœud utilise une instance Spot et que l'instance est terminée en raison du prix de l'offre, Spark peut ne pas gérer correctement la terminaison. Les tâches peuvent échouer et les recalculs aléatoires peuvent nécessiter un temps important. Pour cette raison, nous vous conseillons d'utiliser la version 5.11.0 ou une version ultérieure si vous utilisez des instances Spot. **Paramètres de mise hors service d'un nœud Spark** | Paramètre | Description | Valeur par défaut | | --- | --- | --- | | `spark.blacklist.decommissioning.enabled` | Lorsqu'il est défini sur `true`, Spark refuse de répertorier les nœuds qui sont dans l'état `decommissioning` dans YARN. Spark ne planifie pas de nouvelles tâches sur les exécuteurs s'exécutant sur ce nœud. Les tâches déjà en cours d'exécution sont autorisées à se terminer. | `true` | | `spark.blacklist.decommissioning.timeout` | La durée pendant laquelle un nœud dans l'état `decommissioning` est sur la liste de refus. Par défaut, cette valeur est définie sur une heure, qui est aussi l'heure par défaut pour `yarn.resourcemanager.decommissioning.timeout`. Pour s'assurer qu'un nœud est placé sur liste noire pendant toute la période de sa mise hors service, définissez une valeur égale ou supérieure à `yarn.resourcemanager.decommissioning.timeout`. Après l'expiration du délai de mise hors service, le nœud passe à un état `decommissioned` et Amazon EMR peut résilier l'instance EC2 du nœud. Si des tâches continuent à s'exécuter après l'expiration du délai, elles sont perdues ou supprimées, puis replanifiées sur les exécuteurs s'exécutant sur d'autres nœuds. | `1h` | | `spark.decommissioning.timeout.threshold` | Disponible dans Amazon EMR version 5.11.0 ou ultérieure. Indiqué en secondes. Lorsqu'un nœud passe à l'état de mise hors service, si l'hôte est mis hors service au cours d'une durée inférieure ou égale à cette valeur, Amazon EMR placera le nœud sur la liste noire et nettoiera l'état de l'hôte (comme indiqué par `spark.resourceManager.cleanupExpiredHost`) sans attendre que le nœud passe à l'état de mise hors service. Cela permet à Spark de mieux traiter les arrêts d'instances Spot car les instances Spot sont mises hors services dans un délai de 20 secondes, et ce quelle que soit la valeur de `yarn.resourcemager.decommissioning.timeout`, qui peut ne pas fournir aux autres nœuds suffisamment de temps pour lire les fichiers de lecture aléatoire. | `20s` | | `spark.resourceManager.cleanupExpiredHost` | Lorsque la valeur est `true`, Spark annule l'inscription de l'ensemble des données mises en cache et des blocs aléatoires stockés dans les exécuteurs des nœuds qui se trouvent à l'état `decommissioned`. Le processus de récupération s'en trouve accéléré. | `true` | | `spark.stage.attempt.ignoreOnDecommissionFetchFailure` | Lorsque la valeur est `true`, aide à empêcher que les phases Spark n'échouent et n'entraînent l'échec de la tâche en raison du trop grand nombre d'extractions à partir des nœuds mis hors service ayant elles-mêmes échoué. Les extractions défaillantes de blocs aléatoires d'un nœud ayant l'état `decommissioned` ne sont pas comptabilisées dans le nombre maximal d'extractions défaillantes consécutives. | true | ## Variable d' ThriftServer environnement Spark Spark définit la variable d'environnement du port de serveur Thrift Hive, `HIVE_SERVER2_THRIFT_PORT`, sur 10001. ## Modification des paramètres Spark par défaut Vous modifiez les paramètres par défaut dans `spark-defaults.conf` à l'aide de la classification de configuration `spark-defaults` ou du paramètre `maximizeResourceAllocation` dans la classification de configuration `spark`. Les procédures suivantes montrent comment modifier les paramètres à l'aide de l'interface de ligne ou de la console. **Pour créer un cluster avec spark.executor.memory défini sur 2g à l'aide de la CLI** + Créez un cluster avec Spark installé et la valeur `spark.executor.memory` définie sur 2g, à l'aide de la commande suivante, qui fait référence à un fichier, `myConfig.json` stocké dans Amazon S3. ``` aws emr create-cluster --release-label emr-7.12.0 --applications Name=Spark \ --instance-type m5.xlarge --instance-count 2 --service-role EMR_DefaultRole_V2 --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json ``` **Note** Les caractères de continuation de ligne Linux (\$1) sont inclus pour des raisons de lisibilité. Ils peuvent être supprimés ou utilisés dans les commandes Linux. Pour Windows, supprimez-les ou remplacez-les par un caret (^). `myConfig.json`: ``` [ { "Classification": "spark-defaults", "Properties": { "spark.executor.memory": "2G" } } ] ``` **Pour créer un cluster avec spark.executor.memory défini sur 2g à l'aide de la console** 1. Accédez à la nouvelle console Amazon EMR et sélectionnez **Changer pour l'ancienne console** depuis le menu latéral. Pour plus d'informations sur ce qu'implique le passage à l'ancienne console, consultez la rubrique [Utilisation de l'ancienne console](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in). 1. Choisissez **Créer un cluster** et **Go to advanced options (Aller aux options avancées)**. 1. Choisissez **Spark**. 1. Sous **Edit software settings (Modifier les paramètres logiciels)**, conservez l'option **Enter configuration (Saisir la configuration)** et saisissez la configuration suivante : ``` classification=spark-defaults,properties=[spark.executor.memory=2G] ``` 1. Sélectionnez d'autres options, choisissez ****, puis **Create cluster (Créer un cluster)**. **À régler maximizeResourceAllocation** + Créez un cluster avec Spark installé et `maximizeResourceAllocation` défini sur true en utilisant le AWS CLI, en faisant référence à un fichier`myConfig.json`, stocké dans Amazon S3. ``` aws emr create-cluster --release-label emr-7.12.0 --applications Name=Spark \ --instance-type m5.xlarge --instance-count 2 --service-role EMR_DefaultRole_V2 --ec2-attributes InstanceProfile=EMR_EC2_DefaultRole --configurations https://s3.amazonaws.com/amzn-s3-demo-bucket/myfolder/myConfig.json ``` **Note** Les caractères de continuation de ligne Linux (\$1) sont inclus pour des raisons de lisibilité. Ils peuvent être supprimés ou utilisés dans les commandes Linux. Pour Windows, supprimez-les ou remplacez-les par un caret (^). `myConfig.json`: ``` [ { "Classification": "spark", "Properties": { "maximizeResourceAllocation": "true" } } ] ``` **Note** Avec la version 5.21.0 et ultérieures d'Amazon EMR, vous permet de remplacer les configurations de cluster et de spécifier des classifications de configuration supplémentaires pour chaque groupe d'instances dans un cluster en cours d'exécution. Pour ce faire, utilisez la console Amazon EMR, le AWS Command Line Interface (AWS CLI) ou le AWS SDK. Pour plus d'informations, consultez [Fourniture d'une configuration pour un groupe d'instances dans un cluster en cours d'exécution](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps-running-cluster.html). ## Migration d'Apache Log4j 1.x vers Log4j 2.x Les versions 3.2.x et antérieures d'[Apache Spark](https://aws.amazon.com/emr/features/spark/) utilisent l'ancien Apache Log4j 1.x et le fichier `log4j.properties` pour configurer Log4j dans les processus Spark. Les versions 3.3.0 et ultérieures d'Apache Spark utilisent Apache Log4j 2.x et le fichier `log4j2.properties` pour configurer Log4j dans les processus Spark. Si vous avez configuré Apache Spark Log4j à l'aide d'une version Amazon EMR inférieure à 6.8.0, vous devez supprimer l'ancienne classification `spark-log4j` de configuration et migrer vers la classification de configuration `spark-log4j2` et le format de clé avant de pouvoir passer à Amazon EMR 6.8.0 ou version ultérieure. L'ancienne classification `spark-log4j` entraîne l'échec de la création de clusters avec une erreur `ValidationException` dans les versions 6.8.0 et ultérieures d'Amazon EMR. Aucun frais ne vous sera facturé en cas de panne liée à l'incompatibilité de Log4j, mais vous devez supprimer la classification de configuration obsolète `spark-log4j` pour continuer. Pour plus d'informations sur la migration d'Apache Log4j 1.x vers Log4j 2.x, consultez le [Guide de migration d'Apache Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html) et le [Modèle Spark Log4j 2](https://github.com/apache/spark/blob/master/conf/log4j2.properties.template) sur Github. **Note** Avec Amazon EMR, Apache Spark utilise un fichier `log4j2.properties` plutôt que le fichier .xml décrit dans le [Guide de migration d’Apache Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html). De plus, nous ne recommandons pas d'utiliser la méthode du pont Log4j 1.x pour convertir en Log4j 2.x. # Qu'est-ce que l'agent de résolution des problèmes Apache Spark pour Amazon EMR ## Introduction L'agent de résolution des problèmes Apache Spark pour Amazon EMR est une fonctionnalité d'intelligence artificielle conversationnelle qui simplifie le dépannage des applications Apache Spark sur Amazon EMR, Glue AWS et Amazon Notebooks. SageMaker Le dépannage traditionnel de Spark nécessite une analyse manuelle approfondie des journaux, des indicateurs de performance et des modèles d'erreur afin d'identifier les causes profondes et de corriger le code. L'agent simplifie ce processus grâce à des instructions en langage naturel, à une analyse automatisée de la charge de travail et à des recommandations de code intelligentes. Vous pouvez utiliser l'agent pour résoudre les problèmes PySpark et les défaillances des applications Scala. L'agent analyse vos tâches qui ont échoué, identifie les goulots d'étranglement liés aux performances et fournit des recommandations pratiques et des corrections de code tout en vous donnant un contrôle total sur les décisions de mise en œuvre. **Note** L'agent de dépannage Apache Spark est disponible sans frais supplémentaires dans le cadre d'Amazon EMR. L'agent fournit uniquement des analyses et des recommandations. Vous ne payez que pour les ressources Amazon EMR que vous utilisez lorsque vous exécutez vos applications pour valider les correctifs recommandés. ## Présentation de l'architecture L'agent de dépannage comporte trois composants principaux : un assistant AI compatible MCP dans votre environnement de développement pour l'interaction, le [proxy MCP AWS qui gère la communication et l'authentification sécurisées entre votre client et vos AWS services, et le serveur MCP distant Amazon SageMaker Unified Studio `(preview)` qui fournit des outils de dépannage Spark spécialisés pour](https://github.com/aws/mcp-proxy-for-aws) Amazon EMR, Glue AWS et Amazon Notebooks. SageMaker Ce schéma illustre la manière dont vous interagissez avec le serveur MCP Amazon SageMaker Unified Studio Remote par le biais de votre assistant AI. ![\[Architecture de l'agent de résolution des problèmes Spark.\]](http://docs.aws.amazon.com/fr_fr/emr/latest/ReleaseGuide/images/spark-troubleshooting-agent-architecture.png) L'assistant AI orchestrera le dépannage à l'aide des outils spécialisés fournis par le serveur MCP en suivant les étapes suivantes : + **Extraction de fonctionnalités et création de contexte :** l'agent collecte et analyse automatiquement les données de télémétrie de votre application Spark, notamment les journaux du serveur Spark History, les paramètres de configuration et les traces d'erreur. Il extrait les indicateurs de performance clés, les modèles d'utilisation des ressources et les signatures de défaillance afin de créer un profil contextuel complet pour un dépannage intelligent. + **Analyseur des causes profondes et moteur de recommandation GenAI :** l'agent utilise les modèles d'IA et la base de connaissances Spark pour corréler les fonctionnalités extraites et identifier les causes profondes des problèmes ou défaillances de performance. Il fournit des informations diagnostiques et une analyse des problèmes survenus lors de l'exécution de votre application Spark. + **Recommandation de code GenAI Spark :** Sur la base de l'analyse des causes premières de l'étape précédente, l'agent analyse vos modèles de code existants et identifie les opérations inefficaces qui nécessitent des corrections de code en cas de défaillance des applications. Il fournit des recommandations pratiques, notamment des modifications de code spécifiques, des ajustements de configuration et des améliorations architecturales avec des exemples concrets. **Topics** + [Introduction](#spark-troubleshooting-agent-intro) + [Présentation de l'architecture](#spark-troubleshooting-agent-architecture) + [Configuration de l'agent de dépannage](spark-troubleshooting-agent-setup.md) + [Utilisation de l'agent de dépannage](spark-troubleshooting-using-troubleshooting-agent.md) + [Caractéristiques et capacités](spark-troubleshooting-features.md) + [Résolution des problèmes et questions et réponses](spark-troubleshooting-agent-troubleshooting.md) + [Le flux de travail des agents de dépannage de Spark en détail](spark-troubleshooting-agent-workflow.md) + [Exemples rapides](spark-troubleshooting-agent-prompt-examples.md) + [Configuration du rôle IAM](spark-troubleshooting-agent-iam-setup.md) + [Utilisation des outils de dépannage de Spark](spark-troubleshooting-agent-using-tools.md) + [Configuration des points de terminaison VPC d'interface pour Amazon Unified Studio MCP SageMaker](spark-troubleshooting-agent-vpc-endpoints.md) + [Traitement interrégional pour l'agent de résolution des problèmes Apache Spark](spark-troubleshooting-cross-region-processing.md) + [Journalisation des appels MCP Amazon SageMaker Unified Studio à l'aide de AWS CloudTrail](spark-troubleshooting-cloudtrail-integration.md) + [Améliorations des services pour les agents Apache Spark](spark-agents-service-improvements.md) # Configuration de l'agent de dépannage **Note** L'agent de résolution des problèmes Apache Spark utilise l'inférence entre régions pour traiter les demandes en langage naturel et générer des réponses. Pour plus de détails, veuillez consulter[Traitement interrégional pour l'agent de résolution des problèmes Apache Spark](spark-troubleshooting-cross-region-processing.md). Le serveur Amazon SageMaker Unified Studio MCP est en version préliminaire et est sujet à modification. ## Conditions préalables Avant de commencer notre processus de configuration pour l'intégration à Kiro CLI, assurez-vous que les éléments suivants sont installés sur votre poste de travail : + [Installer la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) + [Installez Python 3.10\$1](https://www.python.org/downloads/release/python-3100/) + [Installez le gestionnaire de `uv` packages](https://docs.astral.sh/uv/getting-started/installation/) pour [MCP Proxy](https://github.com/aws/mcp-proxy-for-aws?tab=readme-ov-file) pour AWS + [Installez Kiro CLI](https://kiro.dev/docs/cli/) + AWS informations d'identification locales configurées (via une [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html), des variables d'environnement ou des rôles IAM) : pour les opérations locales telles que le téléchargement d'artefacts de tâche mis à niveau pour l'exécution de tâches de validation EMR. ## Ressources de configuration Vous pouvez utiliser un AWS CloudFormation modèle pour configurer la ressource pour le serveur MCP. Ces modèles sont des exemples que vous devez modifier pour répondre à vos besoins. Le modèle crée les ressources suivantes pour le processus de dépannage : 1. Rôle IAM autorisé à appeler le serveur MCP et aux autorisations requises pour le processus de dépannage pour la plate-forme sélectionnée. Choisissez l'un des boutons **Launch Stack** (Lancer la pile) du tableau suivant. Cela lance la pile sur la AWS CloudFormation console dans la région correspondante. | Région | Lancer | | --- | --- | | USA Est (Ohio) | [https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-east-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-2.s3.us-east-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | USA Est (Virginie du Nord) | [https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-east-1.s3.us-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | USA Ouest (Oregon) | [https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-us-west-2.s3.us-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Asie Pacifique (Tokyo) | [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-1.s3.ap-northeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Europe (Irlande) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-1.s3.eu-west-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Asie-Pacifique (Singapour) | [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-1.s3.ap-southeast-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Asie-Pacifique (Sydney) | [https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-southeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-southeast-2.s3.ap-southeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Canada (Centre) | [https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ca-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ca-central-1.s3.ca-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Amérique du Sud (São Paulo) | [https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=sa-east-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-sa-east-1.s3.sa-east-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Europe (Francfort) | [https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-central-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-central-1.s3.eu-central-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Europe (Stockholm) | [https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-north-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-north-1.s3.eu-north-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Europe (Londres) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-2.s3.eu-west-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Europe (Paris) | [https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=eu-west-3#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-eu-west-3.s3.eu-west-3.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Asie-Pacifique (Séoul) | [https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-northeast-2#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-northeast-2.s3.ap-northeast-2.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | | Asie-Pacifique (Mumbai) | [https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup](https://console.aws.amazon.com/cloudformation/home?region=ap-south-1#/stacks/new?templateURL=https%3A%2F%2Fsmus-mcp-cfn-template-prod-ap-south-1.s3.ap-south-1.amazonaws.com%2Fcloudformation%2Fspark-troubleshooting-mcp-setup.yaml&stackName=spark-troubleshooting-mcp-setup) | Accédez à la page **Spécifier les détails de la pile**, entrez le **nom de la pile**. Saisissez des informations supplémentaires sous **Paramètres**. Fournissez les informations suivantes et procédez à la création de la pile. + **TroubleshootingRoleName**- Nom du rôle IAM à créer pour les opérations de dépannage + **Activer EMREC2** : active les autorisations de dépannage EMR-EC2 (valeur par défaut : true) + **Activer EMRServerless** : active les autorisations de dépannage sans serveur EMR (valeur par défaut : true) + **EnableGlue**- Activer les autorisations de dépannage de Glue (valeur par défaut : true) + **CloudWatchKmsKeyArn**- (Facultatif) ARN de la clé KMS existante pour le chiffrement CloudWatch des journaux (EMR sans serveur uniquement, laissez le champ vide pour le chiffrement par défaut) Vous pouvez également télécharger et consulter [le CloudFormation modèle](https://github.com/aws-samples/aws-emr-utilities/blob/03c20fece616de23ec0ea5389f0113a5bc65fc3a/utilities/apache-spark-agents/spark-troubleshooting-agent-cloudformation/spark-troubleshooting-mcp-setup.yaml), spécifier les options ci-dessus et lancer le modèle vous-même à l'aide des commandes de la CloudFormation CLI, voir un exemple ci-dessous : ``` # deploy the stack with CloudFormation CLI commands aws cloudformation deploy \ --template-file spark-troubleshooting-mcp-setup.yaml \ --stack-name spark-troubleshooting-mcp-setup \ --region \ --capabilities CAPABILITY_NAMED_IAM \ --parameter-overrides \ TroubleshootingRoleName=spark-troubleshooting-role # retrieve the 1-line instruction to set the local environment variables, which will be used for the following MCP server configuration aws cloudformation describe-stacks \ --stack-name spark-troubleshooting-mcp-setup \ --region \ --query "Stacks[0].Outputs[?OutputKey=='ExportCommand'].OutputValue" \ --output text ``` Ouvrez l'onglet Sorties (ou récupérez-la à partir de la commande de la CLI CloudFormation describe-stacks ci-dessus) et copiez l'instruction d'une ligne à partir de CloudFormation la sortie pour définir vos variables d'environnement, puis exécutez-la dans votre environnement local. Exemple d'instruction d'une ligne : ``` export SMUS_MCP_REGION= && export IAM_ROLE=arn:aws:iam::111122223333:role/spark-troubleshooting-role-xxxxxx ``` Exécutez ensuite la commande suivante localement pour configurer le profil IAM et la configuration du serveur MCP : ``` # Step 1: Configure AWS CLI Profile aws configure set profile.smus-mcp-profile.role_arn ${IAM_ROLE} aws configure set profile.smus-mcp-profile.source_profile aws configure set profile.smus-mcp-profile.region ${SMUS_MCP_REGION} # Step 2: if you are using kiro CLI, use the following command to add the MCP configuration # Add Spark Troubleshooting MCP Server kiro-cli-chat mcp add \ --name "sagemaker-unified-studio-mcp-troubleshooting" \ --command "uvx" \ --args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-troubleshooting/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"smus-mcp-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \ --timeout 180000 \ --scope global # Add Spark Code Recommendation MCP Server kiro-cli-chat mcp add \ --name "sagemaker-unified-studio-mcp-code-rec" \ --command "uvx" \ --args "[\"mcp-proxy-for-aws@latest\",\"https://sagemaker-unified-studio-mcp.${SMUS_MCP_REGION}.api.aws/spark-code-recommendation/mcp\", \"--service\", \"sagemaker-unified-studio-mcp\", \"--profile\", \"smus-mcp-profile\", \"--region\", \"${SMUS_MCP_REGION}\", \"--read-timeout\", \"180\"]" \ --timeout 180000 \ --scope global ``` Cela devrait être mis `~/.kiro/settings/mcp.json` à jour pour inclure la configuration du serveur MCP comme indiqué ci-dessous. ``` { "mcpServers": { "sagemaker-unified-studio-mcp-troubleshooting": { "type": "stdio", "command": "uvx", "args": [ "mcp-proxy-for-aws@latest", "https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-troubleshooting/mcp", "--service", "sagemaker-unified-studio-mcp", "--profile", "smus-mcp-profile", "--region", "us-east-1", "--read-timeout", "180" ], "timeout": 180000, "disabled": false }, "sagemaker-unified-studio-mcp-code-rec": { "type": "stdio", "command": "uvx", "args": [ "mcp-proxy-for-aws@latest", "https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-code-recommendation/mcp", "--service", "sagemaker-unified-studio-mcp", "--profile", "smus-mcp-profile", "--region", "us-east-1", "--read-timeout", "180" ], "timeout": 180000, "disabled": false } } } ``` Consultez [Interfaces prises en charge](spark-troubleshooting-using-troubleshooting-agent.md#supported-interfaces) les conseils de configuration pour différents clients MCP tels que Kiro, Cline et. GitHub CoPilot # Utilisation de l'agent de dépannage ## Modes de déploiement pris en charge L'agent de résolution des problèmes Apache Spark pour Amazon EMR prend en charge des fonctionnalités d'analyse complètes des charges de travail Spark défaillantes, notamment le diagnostic automatique des erreurs, l'identification des goulots d'étranglement des performances, les recommandations de code et les suggestions exploitables pour améliorer les performances des applications dans le mode de déploiement Spark suivant : + EMR sur EC2 + EMR sans serveur + AWS Glue Veuillez vous référer à cette section [Caractéristiques et capacités](spark-troubleshooting-features.md) pour en savoir plus sur les fonctionnalités, les capacités et les limites. ## Interfaces prises en charge ### Résolution des problèmes liés aux cellules dans les SageMaker blocs-notes Amazon Une démonstration de l'expérience de dépannage avec Amazon SageMaker Notebooks. En cas de panne d'une cellule Notebook, vous pouvez demander à l'agent Amazon SageMaker Notebook de remédier à l'échec de la demande d'analyse suivie d'une éventuelle correction de code si l'erreur est due au code, en cliquant sur le `Fix with AI` bouton. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/btW8hwio0tE/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/btW8hwio0tE) ### Résolution des problèmes liés aux applications Glue et EMR Spark avec Kiro CLI Démarrez Kiro CLI ou votre assistant AI et vérifiez les outils chargés pour le processus de dépannage. ``` ... sagemaker-unified-studio-mcp-code-rec (MCP) - spark_code_recommendation not trusted sagemaker-unified-studio-mcp-troubleshooting (MCP) - analyze_spark_workload not trusted ... ``` Vous êtes maintenant prêt à démarrer le flux de travail de l'agent de dépannage Spark. Une démonstration de l'expérience de dépannage avec Kiro CLI. Vous pouvez simplement démarrer le processus de résolution des problèmes en suivant le message suivant : ``` Analyze my Glue job. The job name is "xxx" and the job run id is "xxx" ``` [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/YLwV_EenJXY/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/YLwV_EenJXY) ### Intégration avec d'autres clients MCP La configuration décrite dans [Configuration de l'agent de dépannage](spark-troubleshooting-agent-setup.md) peut également être utilisée dans d'autres clients MCP et IDEs pour se connecter au serveur MCP géré : + **Intégration avec Cline** - Pour utiliser le serveur MCP avec Cline, modifiez `cline_mcp_settings.json` et ajoutez la configuration ci-dessus. Consultez [la documentation de Cline](https://docs.cline.bot/mcp/configuring-mcp-servers) pour plus d'informations sur la gestion de la configuration MCP. + **Intégration avec Claude Code** Pour utiliser le serveur MCP avec Claude Code, modifiez le fichier de configuration pour inclure la configuration MCP. Le chemin du fichier varie en fonction de votre système d'exploitation. Reportez-vous à [ https://code.claude.com/docs/en/mcp](https://code.claude.com/docs/en/mcp) pour une configuration détaillée. + **Intégration avec GitHub Copilot** - Pour utiliser le serveur MCP avec GitHub Copilot, suivez les instructions contenues dans [ https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend- copilot-chat-with-mcp](https://docs.github.com/en/copilot/how-tos/provide-context/use-mcp/extend-copilot-chat-with-mcp) pour modifier le fichier de configuration correspondant et suivez les instructions de chaque IDE pour activer l'installation. # Caractéristiques et capacités ## Plateformes prises en charge + **Langages** : applications Python et Scala Spark + **Plateformes cibles** : Amazon EMR, EMR Serverless et Glue AWS ## Comment ça marche En cas de défaillance de votre application Spark, vous pouvez utiliser l'agent de résolution des problèmes pour rechercher automatiquement ce qui s'est mal passé. Il analyse vos journaux d'événements Spark, vos messages d'erreur et l'utilisation des ressources pour identifier le problème exact, qu'il s'agisse d'un manque de mémoire, d'une erreur de configuration ou d'un bogue de code. Lorsque vous demandez à une invite en langage naturel d'analyser votre charge de travail Spark, l'agent se connecte aux ressources de votre plateforme et extrait des fonctionnalités (notamment les journaux d'événements Spark, les plans de requêtes, les chronologies des exécuteurs, les traces de journal, les configurations et les métriques) : + Sur EMR-EC2 : il se connecte à l'interface utilisateur persistante [EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html) du cluster + On Glue : il crée le contexte à partir de l'[interface utilisateur Spark](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html) de Glue Studio pour le travail + [Sur EMR-Serverless : il se connecte au serveur d'historique Spark sans serveur EMR pour le travail](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_GetDashboardForJobRun.html) + L'agent analyse également les traces de votre pile d'erreurs et les détails de configuration pour vous fournir des informations exploitables. Pour les charges de travail défaillantes, vous obtenez une explication claire de la cause première et des étapes spécifiques pour y remédier. Si l'agent détecte un problème lié au code, il fournit automatiquement des recommandations de code pour vous indiquer exactement ce qu'il faut modifier dans votre code. Vous pouvez également demander des suggestions au niveau du code directement quand vous le souhaitez, sans analyse complète. ## Régions disponibles L'agent de résolution des problèmes Spark est disponible dans les régions suivantes : + **Asie-Pacifique** : Tokyo (ap-northeast-1), Séoul (ap-northeast-2), Singapour (ap-southeast-1), Sydney (ap-southeast-2) et Mumbai (ap-southeast-1) + **Amérique du** Nord : Canada (ca-central-1) + **Europe** : Stockholm (eu-nord-1), Irlande (eu-west-1), Londres (eu-west-2), Paris (eu-west-3) et Francfort (eu-central-1) + **Amérique du Sud** : São Paulo (sa-east-1) + **États-Unis** : Virginie du Nord (us-east-1), Ohio (us-east-2) et Oregon (us-west-2) ## Champ de résolution des problèmes liés à Spark et exigences des utilisateurs + **États de charge de travail Spark pris en** charge : les outils ne prennent en charge que les réponses aux charges de travail Spark ayant échoué. + **Interface utilisateur persistante EMR :** lors de l'analyse des charges de travail Amazon EMR-EC2, l'outil d'analyse tente de se connecter à l'interface utilisateur persistante EMR pour récupérer les informations clés de Spark. [Les considérations relatives à l'interface utilisateur EMR Persistent sont documentées ici.](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html#app-history-spark-UI-limitations) + **Interface utilisateur de Glue Studio Spark** : lors de l'analyse des charges de travail AWS Glue, l'outil d'analyse tente de récupérer les informations clés de Spark en analysant les journaux d'événements Spark des utilisateurs depuis Amazon S3. La taille maximale autorisée des journaux d'événements Spark est documentée [ici](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-jobs.html) : 512 Mo et 2 Go pour les journaux évolutifs. + **Recommandations relatives au code :** prise en charge uniquement pour les charges de travail Amazon EMR-EC2 et AWS Glue pour les charges de travail PySpark + **Ressources régionales :** L'agent de résolution des problèmes Spark est régional et utilise les ressources EMR sous-jacentes de cette région pour le processus de dépannage. Le dépannage interrégional n'est pas pris en charge. # Résolution des problèmes et questions et réponses ## Résolution des problèmes Le message d'erreur de l'agent de dépannage Spark est disponible de différentes manières pour les différents clients MCP. Dans cette page, nous listons quelques conseils généraux concernant les problèmes courants que vous pouvez rencontrer lors de l'utilisation de l'agent de dépannage Apache Spark pour Amazon EMR. Rubriques + [Erreur : échec du chargement du serveur MCP](#mcp-server-failed-to-load) + [Observation : chargement lent des outils](#slow-tool-loading) + [Erreur : échec de l'invocation de l'outil avec erreur de régulation](#throttling-error) + [Erreur : l'outil répond avec une erreur utilisateur](#user-error) + [Erreur : l'outil répond avec une erreur interne](#internal-error) ### Erreur : échec du chargement du serveur MCP + Vérifiez que vos configurations MCP sont correctement configurées. + **Validez la syntaxe JSON** : + Assurez-vous que votre JSON est valide et qu'il n'y a aucune erreur de syntaxe + Vérifiez les virgules, les guillemets ou les crochets manquants + Vérifiez vos AWS informations d'identification locales et vérifiez que la politique du rôle MCP IAM est correctement configurée. + Exécutez /mcp pour vérifier la disponibilité du serveur MCP pour le cas `Kiro-CLI` ### Observation : chargement lent des outils + Le chargement des outils peut prendre quelques secondes lors de la première tentative de lancement du serveur. + Si aucun outil n'apparaît, essayez de redémarrer le chat. + Exécutez `/tools` la commande pour vérifier la disponibilité de l'outil. + Exécuter `/mcp` si le serveur est lancé sans erreur. ### Erreur : échec de l'invocation de l'outil avec erreur de régulation + Si vous atteignez votre limite de service, attendez quelques secondes pour lancer un appel d'outil si vous voyez une exception de limitation. ### Erreur : l'outil répond avec une erreur utilisateur + AccessDeniedException - vérifiez le message d'erreur et corrigez le problème d'autorisation. + InvalidInputException - vérifiez le message d'erreur et corrigez les paramètres d'entrée de l'outil. + ResourceNotFoundException - vérifiez le message d'erreur et corrigez le paramètre d'entrée pour la référence aux ressources. ### Erreur : l'outil répond avec une erreur interne + Si cela s'affiche, `The service is handling high-volume requests` veuillez réessayer d'invoquer l'outil dans quelques secondes. + Si vous voyez, `INTERNAL SERVICE EXCEPTION` veuillez documenter l'identifiant d'analyse, le nom de l'outil, tout message d'erreur disponible dans le journal MCP ou la réponse de l'outil, ainsi que l'historique des conversations désinfecté en option, puis contactez le AWS support. ## QUESTIONS-RÉPONSES ### 1. Dois-je activer le paramètre « confiance » pour les outils par défaut ? N'activez pas le paramètre « trust » par défaut pour tous les appels d'outils au départ et utilisez un environnement de construction versionné par git lorsque vous acceptez les recommandations de code. Passez en revue l'exécution de chaque outil pour comprendre les modifications apportées. ### 2. Quels sont les exemples d'instructions courants pour tirer parti des outils de résolution des problèmes ? Reportez-vous à [Exemples rapides](spark-troubleshooting-agent-prompt-examples.md) des exemples rapides sur l'utilisation des outils de résolution des problèmes. ### 3. Quelles données sont transmises au LLM et comment sont-elles traitées ? Les données et les fichiers des clients restent dans la AWS région que vous avez choisie et ne sont pas transmis d'une région à l'autre. Lorsque l'agent opère dans une région qui utilise l'inférence interrégionale globale d'Amazon Bedrock, le service peut acheminer les demandes vers la région la plus proche disposant de la capacité disponible en fonction de la demande. Dans de tels cas, seules les métadonnées extraites des journaux des clients et les résultats d'inférence traités sont transmis, et non les données ou fichiers clients sous-jacents. Toutes les données sont masquées par PII avant d'être envoyées au LLM pour traitement, que l'inférence ait lieu dans la même région ou soit acheminée vers une autre région. Pour plus de détails sur le fonctionnement de l'inférence interrégionale et sur les régions concernées, voir. [Traitement interrégional pour l'agent de résolution des problèmes Apache Spark](spark-troubleshooting-cross-region-processing.md) # Le flux de travail des agents de dépannage de Spark en détail Pour lancer le processus de dépannage, vous devez accéder aux identifiants de vos applications Spark défaillantes exécutées sur des plateformes compatibles (EMR-EC2, EMR Serverless, AWS Glue ou Amazon Data Notebooks). SageMaker L'application doit disposer de journaux accessibles, d'un serveur d'historique Spark et de détails de configuration. Assurez-vous de disposer des autorisations nécessaires pour accéder aux ressources de la plateforme et aux métadonnées des applications. Une fois ces exigences établies, vous pouvez envoyer une invite telle que la suivante pour lancer le processus de résolution des problèmes : ``` Analyze my EMR step execution failure, EMR id with cluster id ``` À ce stade, l'agent va orchestrer le dépannage à l'aide d'outils spécialisés. Le flux de travail suit les étapes suivantes : 1. **Extraction de fonctionnalités et création de contexte** : l'agent collecte et analyse automatiquement les données de télémétrie de votre application Spark, notamment les journaux du serveur d'historique, les paramètres de configuration et les traces d'erreurs. Vous verrez l'outil collecter des informations sur les indicateurs de performance, les modèles d'utilisation des ressources et les signatures d'échec. 1. **Analyse et identification des causes premières** : l'agent utilise les modèles d'IA et la base de connaissances Spark pour corréler les fonctionnalités extraites et identifier les causes profondes des problèmes ou défaillances de performance. Vous recevrez : + **Informations d'analyse** : détails techniques sur ce que l'agent a découvert et analysé. + **Cause première** : Explication claire de ce qui s'est mal passé et pourquoi. + **Évaluation initiale** : que le problème soit lié au code, à la configuration ou aux ressources, des conseils et des analyses généraux seront fournis pour les atténuer. 1. **Recommandations relatives au code** (le cas échéant) : si l'analyse identifie des problèmes liés au code sur la base de la classification des erreurs, l'agent peut suggérer de tirer parti de l'outil de recommandation de code pour fournir des recommandations spécifiques afin de mettre en œuvre le correctif de code recommandé avec le before/after code exact et les remplacements suggérés. Le processus de résolution des problèmes est itératif : vous pouvez poursuivre la conversation pour approfondir des problèmes spécifiques ; vous pouvez également utiliser les outils de manière interactive dans le cadre de notre développement de code Spark local pour corriger des bogues de code ou améliorer votre code en permanence. # Exemples rapides Voici une liste d'exemples rapides qui peuvent être utilisés dans le cadre de l'expérience de dépannage. ## 1. Résoudre les problèmes d'exécution d'une tâche Spark Résolution des problèmes liés à l'EMR sur EC2 : ``` Troubleshoot my EMR-EC2 step with id s-xxxxxxxxxxxx on cluster j-xxxxxxxxxxxxx ``` Résolution des problèmes liés à Glue Job : ``` Troubleshoot my Glue job with job run id jr_xxxxxxxxxxxxxxxxxxxxxxxxxxxx and job name test_job ``` Résolution des problèmes liés à l'EMR sans serveur : ``` Troubleshoot my EMR-Serverless job run with application id 00xxxxxxxx and job run id 00xxxxxxxx ``` ## 2. Demande de recommandation de correction de code Demandez une recommandation de correction de code pour EMR sur une tâche EC2 : ``` Recommend code fix for my EMR-EC2 step with id s-STEP_ID on cluster j-CLUSTER_ID ``` Demandez une recommandation de correction de code pour la tâche Glue : ``` Recommend code fix for my Glue job with job run id jr_JOB_RUN_ID and job name test_job ``` # Configuration du rôle IAM La CloudFormation pile des instructions de configuration automatise la configuration du rôle IAM pour vous. Si vous souhaitez l'exécuter manuellement, veuillez suivre les instructions ci-dessous : ## Configuration du rôle IAM pour le serveur MCP Pour accéder au serveur MCP géré par SMUS, un rôle IAM est requis avec la politique en ligne suivante : ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "AllowUseSagemakerUnifiedStudioMcpServer", "Effect": "Allow", "Action": [ "sagemaker-unified-studio-mcp:InvokeMcp", "sagemaker-unified-studio-mcp:CallReadOnlyTool", "sagemaker-unified-studio-mcp:CallPrivilegedTool" ], "Resource": [ "*" ] } ] } ``` Au cours des prochaines étapes, nous allons créer un profil pour ce rôle. Le compte qui assume ce rôle pour obtenir les informations d'identification doit être ajouté à la politique d'attribution du rôle. ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "AllowAccountToAssumeRole", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam:::root" }, "Action": "sts:AssumeRole" } ] } ``` ## Autorisations supplémentaires par mode de déploiement (EMR-EC2/EMR-S/Glue) ### Applications EMR-EC2 ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "EMREC2ReadAccess", "Effect": "Allow", "Action": [ "elasticmapreduce:DescribeCluster", "elasticmapreduce:DescribeStep", "elasticmapreduce:ListSteps", "elasticmapreduce:ListClusters", "elasticmapreduce:DescribeJobFlows" ], "Resource": [ "*" ] }, { "Sid": "EMRS3LogAccess", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:ListBucket" ], "Resource": "*" }, { "Sid": "EMRPersistentApp", "Effect": "Allow", "Action": [ "elasticmapreduce:CreatePersistentAppUI", "elasticmapreduce:DescribePersistentAppUI", "elasticmapreduce:GetPersistentAppUIPresignedURL" ], "Resource": [ "*" ] } ] } ``` ### Emplois pour Glue ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "GlueReadAccess", "Effect": "Allow", "Action": [ "glue:GetJob", "glue:GetJobRun", "glue:GetJobRuns", "glue:GetJobs", "glue:BatchGetJobs" ], "Resource": [ "arn:aws:glue:*::job/*" ] }, { "Sid": "GlueCloudWatchLogsAccess", "Effect": "Allow", "Action": [ "logs:GetLogEvents", "logs:FilterLogEvents" ], "Resource": [ "arn:aws:logs:*::log-group:/aws/glue/*" ] }, { "Sid": "GlueSparkWebUI", "Effect": "Allow", "Action": [ "glue:RequestLogParsing", "glue:GetLogParsingStatus", "glue:GetEnvironment", "glue:GetStage", "glue:GetStages", "glue:GetStageFiles", "glue:BatchGetStageFiles", "glue:GetStageAttempt", "glue:GetStageAttemptTaskList", "glue:GetStageAttemptTaskSummary", "glue:GetExecutors", "glue:GetExecutorsThreads", "glue:GetStorage", "glue:GetStorageUnit", "glue:GetQueries", "glue:GetQuery", "glue:GetDashboardUrl" ], "Resource": [ "arn:aws:glue:*::job/*" ] }, { "Sid": "GluePassRoleAccess", "Effect": "Allow", "Action": "iam:PassRole", "Resource": "*", "Condition": { "StringLike": { "iam:PassedToService": "glue.amazonaws.com" } } } ] } ``` ### Applications EMR sans serveur ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "EMRServerlessReadAccess", "Effect": "Allow", "Action": [ "emr-serverless:GetJobRun", "emr-serverless:GetApplication", "emr-serverless:ListApplications", "emr-serverless:ListJobRuns", "emr-serverless:ListJobRunAttempts", "emr-serverless:GetDashboardForJobRun", "emr-serverless:ListTagsForResource" ], "Resource": [ "*" ] }, { "Sid": "EMRServerlessCloudWatchLogsAccess", "Effect": "Allow", "Action": [ "logs:GetLogEvents", "logs:FilterLogEvents" ], "Resource": [ "arn:aws:logs:*::log-group:/aws/emr-serverless/*" ] }, { "Sid": "EMRServerlessS3LogsAccess", "Effect": "Allow", "Action": [ "s3:GetObject", "s3:ListBucket" ], "Resource": "*" } ] } ``` ### Autorisations KMS - CloudWatch Journaux Si les CloudWatch journaux sont chiffrés à l'aide d'une clé CMK, ajoutez la politique suivante afin que le service puisse lire les journaux des applications sans serveur EMR. ``` { "Effect": "Allow", "Action": [ "kms:Decrypt", "kms:DescribeKey" ], "Resource": "arn:aws:kms:::key/" } ``` # Utilisation des outils de dépannage de Spark ## Outils de résolution des problèmes disponibles Le service MCP fournit différents outils pour l'agent de résolution des problèmes Spark. Les principaux outils sont les suivants : | Nom de l'outil | Catégorie d'outil | Description | | --- | --- | --- | | analyse\$1spark\$1workload | Analyse des causes profondes | Fournit un dépannage détaillé pour les charges de travail Apache Spark défaillantes | | recommandation du code spark\$1code | Recommandation de correction de code | Fournit des recommandations de code Apache Spark en cas d'échec des tâches | # Configuration des points de terminaison VPC d'interface pour Amazon Unified Studio MCP SageMaker Vous pouvez établir une connexion privée entre votre VPC et le service Amazon SageMaker Unified Studio MCP en créant un point de terminaison *VPC* d'interface. Les points de terminaison de l'interface sont alimentés par [Amazon VPC](https://aws.amazon.com/vpc/), qui vous permet d'accéder en privé au serveur MCP de votre VPC sans passerelle Internet, appareil NAT, connexion VPN ou connexion. Les instances de votre VPC n'ont pas besoin d'adresses IP publiques pour communiquer avec le service MCP et le trafic entre votre VPC et le service MCP ne quitte pas le réseau Amazon. Chaque point de terminaison d'interface est représenté par une ou plusieurs [interfaces réseau élastiques](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html) dans vos sous-réseaux VPC. Pour plus d'informations, consultez la section [Points de terminaison VPC d'interface dans le guide](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html) de l'utilisateur Amazon *VPC.* ## Étape 1 : Création d'un point de terminaison VPC d'interface pour Amazon SageMaker Unified Studio MCP Vous pouvez créer un point de terminaison VPC pour le service Amazon SageMaker Unified Studio MCP à l'aide de la console Amazon VPC ou du. AWS CLI Pour plus d’informations, consultez [Création d’un point de terminaison d’interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) dans le *Guide de l’utilisateur Amazon VPC*. Créez un point de terminaison VPC pour Amazon SageMaker Unified Studio MCP en utilisant le nom de service suivant : + com.amazonaws. **. sagemaker-unified-studio-mcp Si vous activez le DNS privé pour le point de terminaison, vous pouvez envoyer des demandes d'API à Amazon SageMaker Unified Studio MCP en utilisant son nom DNS par défaut pour la région, par exemple, `sagemaker-unified-studio-mcp.us-east-1.api.aws` Pour plus d’informations, consultez [Accès à un service via un point de terminaison d’interface](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#access-service-though-endpoint) dans le *Guide de l’utilisateur Amazon VPC*. ## Étape 2 : Création d'une politique de point de terminaison VPC pour Amazon SageMaker Unified Studio MCP Vous pouvez associer une politique de point de terminaison à votre point de terminaison VPC qui contrôle l'accès à Amazon SageMaker Unified Studio MCP. La politique spécifie les informations suivantes : + Le principal qui peut exécuter des actions. + Les actions qui peuvent être effectuées. + Les ressources sur lesquelles les actions peuvent être exécutées. Pour plus d’informations, consultez [Contrôle de l’accès aux services avec points de terminaison d’un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints-access.html) dans le *Guide de l’utilisateur Amazon VPC*. ### Exemple : politique de point de terminaison VPC permettant à MCP d'accéder à un rôle IAM spécifique Voici un exemple de politique de point de terminaison pour l'accès à Amazon SageMaker Unified Studio MCP. Lorsqu'elle est attachée à un point de terminaison, cette politique accorde l'accès aux actions Amazon SageMaker Unified Studio MCP répertoriées pour un principal de rôle IAM spécifique sur toutes les ressources. ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::ACCOUNT-ID:role/YourRoleName" }, "Action": [ "sagemaker-unified-studio-mcp:InvokeMcp", "sagemaker-unified-studio-mcp:CallReadOnlyTool", "sagemaker-unified-studio-mcp:CallPrivilegedTool" ], "Resource": "*" } ] } ``` ## Étape 3 : test de votre VPC La `curl` commande valide la connectivité end-to-end réseau entre votre réseau VPC (EC2) et le point de terminaison VPC en effectuant une demande. HTTP/HTTPS Une réponse curl recevant un message du serveur MCP confirme que le chemin réseau complet est fonctionnel. ### Méthode 1 : avec le DNS privé activé (recommandé) ``` curl https://sagemaker-unified-studio-mcp.us-east-1.api.aws/spark-troubleshooting/mcp ``` ### Méthode 2 : sans activation du DNS privé ``` curl -k https://vpce-0069xxxx-ejwhxxx.sagemaker-unified-studio-mcp.us-east-1.vpce.amazonaws.com/spark-troubleshooting/mcp ``` **Note** L'`-k`indicateur contourne la vérification du certificat SSL en raison d'une incompatibilité du nom d'hôte entre le nom DNS du point de terminaison du VPC et le nom commun (CN) du certificat. Dans les deux cas, la commande curl renvoie une réponse :`{"Message":"...."}`. Le retour avec un message vérifie que le chemin réseau est correctement connecté au point de terminaison VPC du service MCP. ## Étape 4 : Commencez à utiliser le point de terminaison VPC MCP Une fois que vous avez vérifié la connexion, vous pouvez suivre les étapes pour configurer le MCP dans[Configuration de l'agent de dépannage](spark-troubleshooting-agent-setup.md). Utilisez simplement le point de terminaison VPC privé dans votre configuration MCP. # Traitement interrégional pour l'agent de résolution des problèmes Apache Spark L'agent de résolution des problèmes Apache Spark utilise l'inférence entre régions pour traiter les demandes en langage naturel et générer des réponses. Avec l'inférence entre régions, l'agent achemine automatiquement votre demande d'inférence afin d'optimiser les performances, de maximiser les ressources informatiques disponibles et la disponibilité des modèles, et de fournir la meilleure expérience client possible. Le type d'inférence entre régions utilisé dépend de la région dans laquelle vous exécutez l'agent de résolution des problèmes Apache Spark. Dans la plupart des régions, l'agent sélectionne la région optimale au sein de votre zone géographique pour traiter vos demandes d'inférence. Toutefois, dans certaines régions, une demande d'inférence faite par l'agent est acheminée de manière sécurisée vers toutes les ressources informatiques disponibles dans toutes les régions commerciales AWS du monde. ## Inférence interrégionale L'agent de résolution des problèmes Apache Spark est alimenté par Amazon Bedrock et utilise l'inférence entre régions pour répartir le trafic entre les différentes AWS régions afin d'améliorer les performances et la fiabilité de l'inférence des grands modèles de langage (LLM). Bien que l'inférence entre régions ne change pas l'endroit où votre application Spark ou votre expérience de dépannage sont hébergées ou où vos données sont stockées, vos invites de saisie et les résultats de sortie peuvent être transmis à différentes régions pour le traitement des inférences. Toutes les données sont transmises cryptées sur le réseau sécurisé d'Amazon. L'utilisation de l'inférence interrégionale n'entraîne aucun coût supplémentaire. ## Régions prises en charge pour l'inférence interrégionale **Régions utilisant l'inférence géographique entre régions** Pour la plupart des régions, les demandes d'inférence entre régions sont conservées dans les AWS régions qui font partie de la même zone géographique que celle où vous exécutez l'agent de résolution des problèmes Apache Spark. Par exemple, une demande émanant de l'agent de la région de l'Est des États-Unis (Virginie du Nord) est acheminée uniquement vers AWS les régions situées dans la zone géographique des États-Unis d'Amérique. Le tableau suivant décrit les régions vers lesquelles vos demandes peuvent être acheminées en fonction de la zone géographique d'origine de la demande : | Géographie prise en charge | Régions d'inférence | | --- | --- | | États-Unis | USA Est (Virginie du Nord) (us-east-1), USA Ouest (Oregon) (us-west-2), USA Est (Ohio) (us-east-2), USA Ouest (Californie du Nord) (us-west-1) | | Europe | Europe (Francfort) (eu-central-1), Europe (Irlande) (eu-ouest-1), Europe (Paris) (eu-ouest-3), Europe (Stockholm) (eu-nord-1), Europe (Londres) (eu-ouest-2) | | Asie-Pacifique | Asie-Pacifique (Tokyo) (ap-northeast-1), Asie-Pacifique (Séoul) (ap-northeast-2), Asie-Pacifique (Mumbai) (ap-south-1) | ### Régions utilisant l'inférence interrégionale globale **Important** Les AWS régions suivantes utilisent l'inférence interrégionale globale. Lorsque vous utilisez l'agent de résolution des problèmes Apache Spark dans ces régions, vos demandes peuvent être transmises dans le monde entier à d'autres AWS régions pour le traitement des inférences afin d'optimiser les performances et la disponibilité : Amérique du Sud (São Paulo) (sa-east-1) Asie-Pacifique (Singapour) (ap-southeast-1) Asie-Pacifique (Sydney) (ap-southeast-2) Canada (Centre) (ca-central-1) # Journalisation des appels MCP Amazon SageMaker Unified Studio à l'aide de AWS CloudTrail Le serveur Amazon SageMaker Unified Studio MCP est intégré à AWS CloudTrail un service qui fournit un enregistrement des actions effectuées par un utilisateur, un rôle ou un AWS service dans le serveur Amazon SageMaker Unified Studio MCP. CloudTrail capture tous les appels d'API pour le serveur Amazon SageMaker Unified Studio MCP sous forme d'événements. Les appels capturés incluent des appels vers le serveur MCP Amazon SageMaker Unified Studio et des appels de code vers d'autres AWS opérations lors de l'exécution de l'outil depuis le serveur SageMaker Unified Studio MCP. Si vous créez un suivi, vous pouvez activer la diffusion continue d' CloudTrail événements vers un compartiment Amazon S3, y compris des événements pour le serveur MCP Amazon SageMaker Unified Studio. Si vous ne configurez pas de suivi, vous pouvez toujours consulter les événements les plus récents dans la CloudTrail console dans **Historique des événements**. À l'aide des informations collectées par CloudTrail, vous pouvez déterminer la demande envoyée au serveur Amazon SageMaker Unified Studio MCP, l'adresse IP à partir de laquelle la demande a été faite, l'auteur de la demande, la date à laquelle elle a été faite, ainsi que des informations supplémentaires. Pour en savoir plus CloudTrail, consultez le [guide de AWS CloudTrail l'utilisateur](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/). ## Informations sur le serveur MCP Amazon SageMaker Unified Studio dans CloudTrail CloudTrail est activé sur votre AWS compte lorsque vous le créez. Lorsqu'une activité se produit sur le serveur Amazon SageMaker Unified Studio MCP, cette activité est enregistrée dans un CloudTrail événement avec d'autres événements de AWS service dans **l'historique** des événements. Vous pouvez consulter, rechercher et télécharger les événements récents dans votre AWS compte. Pour plus d'informations, consultez la section [Affichage des événements à l'aide de l'historique des CloudTrail événements](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html). Pour un enregistrement continu des événements de votre AWS compte, y compris des événements relatifs au serveur SageMaker Unified Studio MCP, créez une trace. Un suivi permet CloudTrail de fournir des fichiers journaux à un compartiment Amazon S3. Par défaut, lorsque vous créez un parcours dans la console, celui-ci s'applique à toutes les AWS régions. Le journal enregistre les événements de toutes les régions de la AWS partition et transmet les fichiers journaux au compartiment Amazon S3 que vous spécifiez. En outre, vous pouvez configurer d'autres AWS services pour analyser plus en détail les données d'événements collectées dans les CloudTrail journaux et agir en conséquence. Pour plus d’informations, consultez les ressources suivantes : + [Présentation de la création d’un journal de suivi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html) + [CloudTrail services et intégrations pris en charge](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html) + [Configuration des notifications Amazon SNS pour CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/configure-sns-notifications-for-cloudtrail.html) + [Réception de fichiers CloudTrail journaux de plusieurs régions](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) et [réception de fichiers CloudTrail journaux de plusieurs comptes](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html) Tous les appels d'outils du serveur SageMaker Unified Studio MCP et les appels d'API aux AWS services pendant les exécutions de l'outil sont enregistrés par. CloudTrail Par exemple, les appels aux différents outils et les appels de AWS service effectués à partir des outils génèrent des entrées dans les fichiers CloudTrail journaux. Chaque événement ou entrée de journal contient des informations sur la personne ayant initié la demande. Les informations relatives à l’identité permettent de déterminer les éléments suivants : + Si la demande a été effectuée avec des informations d’identification d’utilisateur root ou IAM. + Si la demande a été effectuée avec des informations d’identification de sécurité temporaires pour un rôle ou un utilisateur fédéré. + Si la demande a été faite par un autre AWS service. Pour de plus amples informations, veuillez consulter l'[élément userIdentity CloudTrail ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html). ## Comprendre les entrées du fichier journal du serveur Amazon SageMaker Unified Studio MCP Un suivi est une configuration qui permet de transmettre des événements sous forme de fichiers journaux à un compartiment Amazon S3 que vous spécifiez. CloudTrail les fichiers journaux contiennent une ou plusieurs entrées de journal. Un événement représente une demande unique provenant de n'importe quelle source et inclut des informations sur l'action demandée, la date et l'heure de l'action, les paramètres de la demande, etc. CloudTrail les fichiers journaux ne constituent pas une trace ordonnée des appels d'API publics, ils n'apparaissent donc pas dans un ordre spécifique. L'exemple suivant montre une entrée de CloudTrail journal illustrant l'`CallTool`action. ``` { "eventVersion": "1.09", "userIdentity": { ... }, "eventTime": "...", "eventSource": "sagemaker-unified-studio-mcp.amazonaws.com", "eventName": "CallPrivilegedTool", "awsRegion": "us-east-1", "sourceIPAddress": "...", "userAgent": "...", "requestParameters": { "id": 1, "method": "tools/call", "params": { "name": "generate_spark_upgrade_plan", "arguments": "***", "_meta": { "progressToken": 1 } }, "jsonrpc": "2.0" }, "responseElements": { "result": { "content": "***", "structuredContent": "***", "isError": false }, "id": 1, "jsonrpc": "2.0" }, "requestID": "12345678-1234-1234-1234-123456789012", "eventID": "87654321-4321-4321-4321-210987654321", "readOnly": false, "eventType": "AwsMcpEvent", "managementEvent": true, "recipientAccountId": "123456789012", "eventCategory": "Management" } ``` L'exemple suivant montre une entrée de CloudTrail journal qui illustre l'`AddJobFlowSteps`action d'Amazon SageMaker Unified Studio MCP lors de l'appel d'un outil de mise à niveau. ``` { "eventVersion": "1.11", "userIdentity": { "type": "AssumedRole", "principalId": "...", "arn": "...", "accountId": "123456789012", "accessKeyId": "...", "sessionContext": { ... }, "invokedBy": "sagemaker-unified-studio-mcp.amazonaws.com" }, "eventTime": "...", "eventSource": "elasticmapreduce.amazonaws.com", "eventName": "AddJobFlowSteps", "awsRegion": "us-east-1", "sourceIPAddress": "sagemaker-unified-studio-mcp.amazonaws.com", "userAgent": "sagemaker-unified-studio-mcp.amazonaws.com", "requestParameters": { "jobFlowId": "j-2PY4KXXXXXX63", "steps": [ ... ] }, "responseElements": { "stepIds": [ ... ] }, "requestID": "12345678-1234-1234-1234-123456789013", "eventID": "87654321-4321-4321-4321-210987654322", "readOnly": false, "eventType": "AwsApiCall", "managementEvent": true, "recipientAccountId": "123456789012", "sharedEventID": "12345678-1234-1234-1234-123456789012", "vpcEndpointId": "sagemaker-unified-studio-mcp.amazonaws.com", "vpcEndpointAccountId": "sagemaker-unified-studio-mcp.amazonaws.com", "eventCategory": "Management" } ``` # Améliorations des services pour les agents Apache Spark L'agent Apache Spark pour Amazon EMR peut utiliser du contenu, par exemple, pour aider l'agent à fournir de meilleures réponses aux questions courantes, à résoudre des problèmes opérationnels ou à des fins de débogage. ## Contenu susceptible d' AWS être utilisé pour améliorer le service + Vos demandes en langage naturel et vos réponses générées par les agents Apache Spark pour Amazon EMR, AWS Glue et Amazon Notebooks SageMaker ## Contenu qui AWS n'est pas utilisé pour améliorer le service + Code que vous écrivez vous-même pour les applications Spark + SageMaker Contexte et métadonnées du bloc-notes + Données issues de votre catalogue de données AWS Glue ou d'autres sources de données Seuls les employés d’Amazon auront accès à ces données. Votre confiance, votre confidentialité et la sécurité du contenu de vos clients sont nos priorités absolues et garantissent que notre utilisation est conforme à nos engagements envers vous. Pour plus d’informations, consultez FAQ sur la confidentialité des données. ## Comment se désinscrire Pour refuser la collecte de données pour les agents Apache Spark, configurez une politique de désactivation des services d'intelligence artificielle dans AWS Organizations for Amazon SageMaker Unified Studio MCP Service. Pour plus d'informations, consultez les [politiques de désinscription des services d'intelligence artificielle](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html) dans le *Guide de l'utilisateur AWS des Organizations*. Lorsque vous configurez une politique de désinscription des services d'intelligence artificielle, cela a les effets suivants : + AWS supprimera les données collectées et stockées pour améliorer le service avant votre désinscription (le cas échéant). + Après votre désinscription, AWS nous ne collecterons ni ne stockerons plus ces données. + AWS n'utilisera plus votre contenu pour améliorer le service. # Optimisation des performances de Spark Amazon EMR propose plusieurs fonctions d'optimisation des performances pour Spark. Cette rubrique explique en détail chaque fonction d'optimisation. Pour de plus amples informations sur la définition de la configuration Spark, veuillez consulter [Configuration de Spark](emr-spark-configure.md). ## Exécution de requêtes adaptative L'exécution adaptative des requêtes est un framework permettant de réoptimiser les plans de requêtes en fonction des statistiques d'exécution. À partir de la version 5.30.0 d’Amazon EMR, les optimisations d’exécution adaptative des requêtes suivantes d’Apache Spark 3 sont disponibles sur Apache Amazon EMR Runtime pour Spark 2. + Conversion de jointure adaptative + Coalescence adaptative de partitions shuffle **Conversion de jointure adaptative** La conversion adaptative des jointures améliore les performances des requêtes en convertissant les sort-merge-join broadcast-hash-joins opérations en opérations basées sur la taille d'exécution des étapes de requête. Broadcast-hash-joinsont tendance à être plus performantes lorsqu'un côté de la jointure est suffisamment petit pour diffuser efficacement sa sortie sur tous les exécuteurs, évitant ainsi d'avoir à mélanger les échanges et à trier les deux côtés de la jointure. La conversion adaptative des jointures élargit l'éventail des cas dans lesquels Spark s'exécute broadcast-hash-joins automatiquement. Cette caractéristique est activée par défaut. Il peut être désactivé en le définissant `spark.sql.adaptive.enabled` sur `false`, ce qui désactive également le cadre d'exécution adaptative des requêtes. Spark décide de sort-merge-join convertir a en a broadcast-hash-join lorsque la statistique de taille d'exécution de l'un des côtés de la jointure ne dépasse pas`spark.sql.autoBroadcastJoinThreshold`, la valeur par défaut étant de 10 485 760 octets (10 MiB). **Coalescence adaptative de partitions réorganisées** La fusion adaptative des partitions de distribution améliore les performances des requêtes en fusionnant de petites partitions de distribution contiguës afin d'éviter la surcharge liée à un trop grand nombre de petites tâches. Cela vous permet de configurer un plus grand nombre de partitions de shuffle initiales à l'avance, puis de les réduire à une taille ciblée lors de l'exécution, ce qui augmente les chances d'avoir des partitions shuffle réparties de manière plus uniforme. Cette fonctionnalité est activée par défaut, sauf si `spark.sql.shuffle.partitions` est explicitement défini. Il peut être activé en réglant `spark.sql.adaptive.coalescePartitions.enabled` sur `true`. Le nombre initial de partitions réorganisées et la taille de la partition cible peuvent être ajustés à l'aide des propriétés `spark.sql.adaptive.coalescePartitions.minPartitionNum` et `spark.sql.adaptive.advisoryPartitionSizeInBytes` respectivement. Consultez le tableau suivant pour plus de détails sur les propriétés Spark associées à cette fonctionnalité. **Propriétés de la partition de coalescence adaptative Spark** | Propriété | Valeur par défaut | Description | | --- | --- | --- | | `spark.sql.adaptive.coalescePartitions.enabled` | true, sauf si `spark.sql.shuffle.partitions` est explicitement défini. | Lorsque true et spark.sql.adaptive.enabled est true, Spark fusionne les partitions réorganisées contiguës en fonction de la taille cible (spécifiée par `spark.sql.adaptive.advisoryPartitionSizeInBytes`), afin d'éviter un trop grand nombre de petites tâches. | | `spark.sql.adaptive.advisoryPartitionSizeInBytes` | 64 Mo | Taille conseillée en octets de partition shuffle lors de la fusion. Cette configuration n'a d'effet que lorsque `spark.sql.adaptive.enabled` et `spark.sql.adaptive.coalescePartitions.enabled` sont tous deux `true`. | | `spark.sql.adaptive.coalescePartitions.minPartitionNum` | 25 | Le nombre minimum de partitions shuffle après fusion. Cette configuration n'a d'effet que lorsque `spark.sql.adaptive.enabled` et `spark.sql.adaptive.coalescePartitions.enabled` sont tous deux `true`. | | `spark.sql.adaptive.coalescePartitions.initialPartitionNum` | 1 000 | Nombre initial de partitions réorganisées avant la fusion. Cette configuration n'a d'effet que lorsque `spark.sql.adaptive.enabled` et `spark.sql.adaptive.coalescePartitions.enabled` sont tous deux `true`. | ## Nettoyage dynamique de partition Le nettoyage dynamique de partition améliore les performances de tâche avec plus de précision en sélectionnant des partitions spécifiques au sein d'une table qui doivent être lues et traitées pour une requête spécifique. En réduisant la quantité de données lues et traitées, l'exécution du travail est nettement moins longue. Avec Amazon EMR 5.26.0, cette fonctionnalité est activée par défaut. Avec Amazon EMR 5.24.0 et 5.25.0, vous pouvez activer cette fonctionnalité en définissant la propriété Spark `spark.sql.dynamicPartitionPruning.enabled` depuis Spark ou lors de la création de clusters. **Propriétés des partitions d'élimination dynamique Spark** | Propriété | Valeur par défaut | Description | | --- | --- | --- | | `spark.sql.dynamicPartitionPruning.enabled` | `true` | Lorsque c'est vrai, activez l'élimination dynamique des partitions. | | `spark.sql.optimizer.dynamicPartitionPruning.enforceBroadcastReuse` | `true` | Si la valeur est `true`, Spark effectue une vérification défensive avant l'exécution de la requête pour s'assurer que la réutilisation des échanges de diffusion dans les filtres d'élimination dynamique n'est pas interrompue par des règles de préparation ultérieures, telles que les règles en colonnes définies par l'utilisateur. Lorsque la réutilisation est interrompue et que cette configuration est `true`, Spark supprime les filtres d'élimination dynamique concernés afin de se prémunir contre les problèmes de performance et d'exactitude. Des problèmes d'exactitude peuvent survenir lorsque l'échange de diffusion du filtre d'élimination dynamique produit des résultats différents et incohérents par rapport à l'échange de diffusion de l'opération de jointure correspondante. La définition de cette configuration sur `false` doit être effectuée avec prudence ; elle permet de contourner les scénarios, par exemple lorsque la réutilisation est interrompue par des règles en colonnes définies par l'utilisateur. Lorsque l'exécution adaptative des requêtes est activée, la réutilisation des diffusions est toujours appliquée. | Cette optimisation améliore les fonctionnalités existantes de Spark 2.4.2, qui prend uniquement en charge les transmission des prédicats statiques qui peuvent être résolus au moment voulu. Voici des exemples de prédicat statiques en mode push Spark 2.4.2. ``` partition_col = 5 partition_col IN (1,3,5) partition_col between 1 and 3 partition_col = 1 + 3 ``` Le nettoyage dynamique de partition permet au moteur Spark de déduire dynamiquement au moment de l'exécution les partitions qui doivent être lues et qui peuvent être éliminées. Par exemple, la requête suivante implique deux tables : `store_sales` (qui contient toutes les ventes totales pour tous les magasins et est partitionnée par région) et `store_regions` (qui contient un mappage de régions pour chaque pays). Les tables contiennent des données sur les magasins répartis dans le monde entier, mais nous interrogeons uniquement des données pour l'Amérique du Nord. ``` select ss.quarter, ss.region, ss.store, ss.total_sales from store_sales ss, store_regions sr where ss.region = sr.region and sr.country = 'North America' ``` Sans nettoyage dynamique de partition, cette requête lit toutes les régions avant de filtrer le sous-ensemble de régions qui correspondent aux résultats de la sous-requête. Avec le nettoyage dynamique de partition, cette requête lit et traite uniquement les partitions pour les régions renvoyées dans la sous-requête. Cela permet d'économiser du temps et des ressources en lisant moins de données dans le stockage et en traitant moins d'enregistrements. ## Aplatissement des sous-requêtes scalaires Cette optimisation améliore les performances des requêtes qui ont des sous-requêtes scalaires sur la même table. Avec Amazon EMR 5.26.0, cette fonctionnalité est activée par défaut. Avec Amazon EMR 5.24.0 et 5.25.0, vous pouvez l'activer en définissant la propriété Spark `spark.sql.optimizer.flattenScalarSubqueriesWithAggregates.enabled` depuis Spark ou lors de la création de clusters. Lorsque cette propriété a la valeur true, l'optimiseur de requête aplatit les sous-requêtes scalaires regroupées qui utilisent la même relation si possible. Les sous-requêtes scalaires sont mises à plat en poussant tous les prédicats présents dans la sous-requête dans les fonctions d'agrégation, puis en effectuant une agrégation, avec toutes les fonctions d'agrégation, par relation. Voici un exemple de requête qui bénéficie de cette optimisation. ``` select (select avg(age) from students /* Subquery 1 */ where age between 5 and 10) as group1, (select avg(age) from students /* Subquery 2 */ where age between 10 and 15) as group2, (select avg(age) from students /* Subquery 3 */ where age between 15 and 20) as group3 ``` L'optimisation réécrit la requête précédente comme suit : ``` select c1 as group1, c2 as group2, c3 as group3 from (select avg (if(age between 5 and 10, age, null)) as c1, avg (if(age between 10 and 15, age, null)) as c2, avg (if(age between 15 and 20, age, null)) as c3 from students); ``` Notez que la requête réécrite lit la table des étudiants une seule fois et les prédicats des trois sous-requêtes sont ajoutés à la fonction `avg`. ## DISTINCT avant INTERSECT Cette optimisation optimise les jointures lorsque vous utilisez INTERSECT. Avec Amazon EMR 5.26.0, cette fonctionnalité est activée par défaut. Avec Amazon EMR 5.24.0 et 5.25.0, vous pouvez l'activer en définissant la propriété Spark `spark.sql.optimizer.distinctBeforeIntersect.enabled` depuis Spark ou lors de la création de clusters. Les requêtes utilisant INTERSECT sont automatiquement converties pour utiliser une semi-jointure gauche. Lorsque cette propriété est définie sur true, l'optimiseur de requêtes envoie l'opérateur DISTINCT aux enfants d'INTERSECT s'il détecte que l'opérateur DISTINCT peut faire en sorte que le semi-gauche joigne a au lieu de a. BroadcastHashJoin SortMergeJoin Voici un exemple de requête qui bénéficie de cette optimisation. ``` (select item.brand brand from store_sales, item where store_sales.item_id = item.item_id) intersect (select item.brand cs_brand from catalog_sales, item where catalog_sales.item_id = item.item_id) ``` Sans activer cette propriété `spark.sql.optimizer.distinctBeforeIntersect.enabled`, la requête sera réécrite comme suit. ``` select distinct brand from (select item.brand brand from store_sales, item where store_sales.item_id = item.item_id) left semi join (select item.brand cs_brand from catalog_sales, item where catalog_sales.item_id = item.item_id) on brand <=> cs_brand ``` Lorsque vous activez cette propriété `spark.sql.optimizer.distinctBeforeIntersect.enabled`, la requête est réécrite comme suit. ``` select brand from (select distinct item.brand brand from store_sales, item where store_sales.item_id = item.item_id) left semi join (select distinct item.brand cs_brand from catalog_sales, item where catalog_sales.item_id = item.item_id) on brand <=> cs_brand ``` ## Jonction de filtre Bloom Cette optimisation peut améliorer les performances de certaines jonctions en préfiltrant un côté de la jonction à l’aide d’un [filtre Bloom](https://en.wikipedia.org/wiki/Bloom_filter) généré à partir des valeurs de l’autre côté de la jonction. Avec Amazon EMR 5.26.0, cette fonctionnalité est activée par défaut. Avec Amazon EMR 5.25.0, vous pouvez activer cette fonctionnalité en définissant la propriété Spark `spark.sql.bloomFilterJoin.enabled` sur `true` depuis Spark ou lors de la création de clusters. L'exemple suivant est une requête qui peut bénéficier d'un filtre Bloom. ``` select count(*) from sales, item where sales.item_id = item.id and item.category in (1, 10, 16) ``` Lorsque cette fonction est activée, le filtre Bloom est construit à partir de tous les ID d'éléments dont la catégorie figure dans l'ensemble des catégories interrogées. Pendant l'analyse de la table des ventes, le filtre Bloom est utilisé pour déterminer les ventes pour les éléments qui ne sont pas dans l'ensemble défini par le filtre Bloom. Ainsi, ces ventes identifiées peuvent être filtrées dès que possible. ## Réorganisation optimisée des jonctions Cette optimisation peut améliorer les performances des requêtes en réorganisant les jonctions impliquant des tables avec des filtres. Avec Amazon EMR 5.26.0, cette fonctionnalité est activée par défaut. Avec Amazon EMR 5.25.0, vous pouvez activer cette fonctionnalité en définissant le paramètre de configuration Spark `spark.sql.optimizer.sizeBasedJoinReorder.enabled` sur true. Par défaut, Spark procède à la jonction des tables de gauche à droite, comme indiqué dans la requête. Cette stratégie peut ignorer des possibilités d’exécution de jonctions plus petites avec des filtres dans un premier temps, afin de bénéficier des jonctions plus coûteuses ultérieurement. L'exemple de requête ci-dessous indique tous les éléments renvoyés à partir de tous les magasins d’un pays. Sans réorganisation optimisée des jonctions, Spark joint les deux tables volumineuses `store_sales` et `store_returns` en premier, puis les joint avec `store` et finalement avec `item`. ``` select ss.item_value, sr.return_date, s.name, i.desc, from store_sales ss, store_returns sr, store s, item i where ss.id = sr.id and ss.store_id = s.id and ss.item_id = i.id and s.country = 'USA' ``` Avec la réorganisation optimisée des jonctions, Spark joint d’abord `store_sales` et `store`, car `store` possède un filtre et est plus petite que `store_returns` et `broadcastable`. Ensuite, Spark joint `store_returns`, puis `item`. Si `item` disposait d’un filtre et pouvait être diffusée, elle pourrait bénéficier d’une réorganisation, ce qui entraînerait la jonction de `store_sales` avec `store`, puis avec `item`, et finalement avec `store_returns`. # Mise en cache des fragments de résultats Spark Amazon EMR 6.6.0 et versions ultérieures incluent la fonctionnalité optionnelle de mise en cache des fragments de résultats de Spark qui met automatiquement en cache les fragments de résultats. Ces fragments de résultats font partie des résultats issus de sous-arborescences de requêtes stockées dans un compartiment Amazon S3 de votre choix. Les fragments de résultats de requête stockés sont réutilisés lors des exécutions de requêtes suivantes, ce qui permet d'accélérer les requêtes. La mise en cache des fragments de résultats analyse vos requêtes Spark et met en cache les fragments de résultats éligibles dans l'emplacement S3 que vous avez spécifié. Lors des exécutions de requête suivantes, les fragments de résultats de requête utilisables sont automatiquement détectés et extraits depuis S3. La mise en cache des fragments de résultats est différente de la mise en cache des ensembles de résultats, dans laquelle les requêtes suivantes doivent correspondre exactement à la requête d'origine pour renvoyer des résultats depuis le cache. Lorsqu'elle est utilisée pour des requêtes qui ciblent de manière répétée un sous-ensemble statique de vos données, la mise en cache des fragments de résultats accélère considérablement les performances. Considérez la requête suivante, qui compte les commandes jusqu'en 2022 : ``` select l_returnflag, l_linestatus, count(*) as count_order from lineitem where l_shipdate <= current_date and year(l_shipdate) == '2022' group by l_returnflag, l_linestatus ``` Au fil du temps, cette requête doit être exécutée tous les jours pour indiquer le total des ventes de l'année. Sans la mise en cache des fragments de résultats, les résultats pour tous les jours de l'année devront être recalculés chaque jour. La requête deviendra plus lente au fil du temps et sera plus lente à la fin de l'année, lorsque les 365 jours de résultats devront être recalculés. Lorsque vous activez la mise en cache des fragments de résultats, vous utilisez les résultats de tous les jours précédents de l'année à partir du cache. Chaque jour, la fonctionnalité ne doit recalculer qu'un seul jour de résultats. Une fois que la fonctionnalité a calculé le fragment de résultat, elle met le fragment en cache. Par conséquent, les temps de requête activés par le cache sont rapides et restent constants pour chaque requête suivante. ## Activation de la mise en cache des fragments de résultats Spark Pour activer la mise en cache des fragments de résultats, veuillez suivre les étapes ci-dessous : 1. Créez un compartiment de cache dans Amazon S3 et autorisez read/write l'accès à EMRFS. Pour de plus amples informations, veuillez consulter [Autorisation d'accès aux données EMRFS dans Amazon S3](emr-plan-credentialsprovider.md). 1. Configurez Amazon EMR Spark pour activer la fonctionnalité. ``` spark.subResultCache.enabled = true spark.subResultCache.fs.root.path = s3://&example-s3-bucket;/cache_dir/ ``` 1. Activez la gestion du cycle de vie S3 pour que le compartiment nettoie automatiquement les fichiers de cache. 1. Configurez éventuellement les maxBufferSize propriétés reductionRationThreshold et pour affiner la fonctionnalité. ``` spark.sql.subResultCache.reductionRatioThreshold spark.sql.subResultCache.maxBufferSize ``` ## Considérations relatives à l'utilisation de la mise en cache des fragments de résultats Les économies réalisées lorsque vous utilisez des résultats déjà mis en cache dans Amazon S3 plutôt que de les recalculer augmentent avec le nombre de fois où les mêmes résultats mis en cache peuvent être utilisés. Les requêtes comportant des analyses de grandes tables suivies de filtres ou d'agrégations de hachage qui réduisent la taille du résultat d'au moins 8 (c'est-à-dire un ratio d'au moins 8:1 dans la taille d'entrée:résultats) bénéficieront le plus de cette fonctionnalité. Plus le rapport de réduction entre l'entrée et les résultats est élevé, plus le rapport coût-bénéfice est important. Les requêtes présentant des taux de réduction inférieurs, mais comportant des étapes de calcul coûteuses entre l'analyse des tables et le filtrage ou les agrégations, en bénéficieront également, à condition que le coût de production des résultats soit supérieur à celui de leur extraction sur Amazon S3. Par défaut, la mise en cache des fragments de résultats ne prend effet que lorsqu'elle détecte qu'un taux de réduction sera d'au moins 8:1. Lorsque vos requêtes réutilisent à plusieurs reprises les résultats mis en cache, les avantages de cette fonctionnalité sont les plus importants. Les requêtes de fenêtre progressives et incrémentielles en sont de bons exemples. Par exemple, une requête à fenêtre continue de 30 jours qui s'exécute déjà depuis 29 jours ne devrait extraire que 1/30e des données cibles de sa source d'entrée d'origine et utiliserait des fragments de résultats mis en cache pour les 29 jours précédents. Une requête de fenêtre incrémentielle en bénéficierait encore plus, car le début de la fenêtre reste fixe : à chaque invocation de la requête, un faible pourcentage du traitement nécessitera une lecture depuis la source d'entrée. Voici d'autres considérations à prendre en compte lors de l'utilisation de la mise en cache des fragments de résultats : + Les requêtes qui ne ciblent pas les mêmes données avec les mêmes fragments de requête auront un faible taux d'accès au cache et ne bénéficieront donc pas de cette fonctionnalité. + Les requêtes présentant de faibles ratios de réduction qui ne contiennent pas d'étapes de calcul coûteuses produiront des résultats mis en cache à peu près aussi coûteux à lire qu'à traiter initialement. + La première requête démontrera toujours une régression mineure en raison du coût d'écriture dans le cache. + La fonctionnalité de mise en cache des fragments de résultats fonctionne exclusivement avec les fichiers Parquet. Les autres formats de fichiers ne sont pas pris en charge. + Les tampons de la fonctionnalité de mise en cache des fragments de résultats essaieront uniquement de mettre en cache les scans dont la taille de fractionnement des fichiers est supérieure ou égale à 128 Mo. Avec la configuration par défaut de Spark, la mise en cache des fragments de résultats est désactivée si la taille de numérisation (taille totale de tous les fichiers analysés) divisée par le nombre de cœurs d'exécuteurs est inférieure à 128 Mo. Lorsque l'une des configurations Spark répertoriées ci-dessous est définie, la taille du fichier fractionné sera la suivante : ``` min(maxPartitionBytes, max(openCostInBytes, scan size / minPartitionNum)) ``` + spark.sql. leafNodeDefaultParallélisme (la valeur par défaut est spark.default.parallelism) + fichiers spark.sql. minPartitionNum (la valeur par défaut est spark.sql. leafNodeDefaultParallélisme) + fichiers spark.sql. openCostInOctets + fichiers spark.sql. maxPartitionBytes + La fonction de mise en cache des fragments de résultats est mise en cache au niveau de la granularité de la partition RDD. Le ratio de réduction décrit précédemment, qui est par défaut de 8:1, est évalué par partition RDD. Les charges de travail présentant des ratios de réduction par RDD supérieurs ou inférieurs à 8:1 peuvent présenter des avantages en termes de performances moindres que les charges de travail présentant des ratios de réduction par RDD constamment inférieurs à 8:1. + La fonctionnalité de mise en cache des fragments de résultats utilise une mémoire tampon d'écriture de 16 Mo par défaut pour chaque partition RDD mise en cache. Si plus de 16 Mo sont mis en cache par partition RDD, le coût lié à la détermination de l'impossibilité d'une écriture peut entraîner une régression des performances. + Bien que, par défaut, la mise en cache des fragments de résultats ne tente pas de mettre en cache les résultats des partitions RDD avec un ratio de réduction inférieur à 8:1 et plafonne sa mémoire tampon d'écriture à 16 Mo, ces deux valeurs sont réglables selon les configurations suivantes : ``` spark.sql.subResultCache.reductionRatioThreshold (default: 8.0) spark.sql.subResultCache.maxBufferSize (default: 16MB, max: 64MB) ``` + Plusieurs clusters utilisant la même version d’Amazon EMR peuvent partager le même emplacement de cache. Pour garantir l'exactitude des résultats, la mise en cache des fragments de résultats n'utilisera pas les résultats du cache écrits par différentes versions d'Amazon EMR. + La mise en cache des fragments de résultats sera automatiquement désactivée pour les cas d'utilisation de Spark Streaming ou lorsque RecordServer Apache Ranger AWS Lake Formation est utilisé. + Le cache de fragments obtenu read/writes utilise les compartiments EMRFS/S3A et Amazon S3. Les chiffrements CSE (uniquement avec EMRFS) /SSE S3/ SSE KMS sont pris en charge. À titre de contexte, S3A fournit une implémentation Hadoop permettant à un cluster de lire et d'écrire des données vers et depuis Amazon S3. Notez que la prise en charge de S3A est disponible avec EMR-7.4.0 et versions ultérieures. # Utilisation de l’accélérateur Nvidia RAPIDS pour Apache Spark Avec Amazon EMR 6.2.0 et versions ultérieures, vous pouvez utiliser le plug-in [Accélérateur RAPIDS pour Apache Spark](https://docs.nvidia.com/spark-rapids/user-guide/latest/overview.html) de Nvidia pour accélérer Spark à l’aide des types d’instances d’unité de traitement graphique (GPU) EC2. L’accélérateur RAPIDS accélérera par GPU vos pipelines de science des données Apache Spark 3.0 sans modifier le code et accélérera le traitement des données et l’entraînement des modèles, tout en réduisant considérablement les coûts d’infrastructure. Les sections suivantes vous guident dans la configuration de votre cluster EMR pour utiliser le plug-in Spark-rapids pour Spark. ## Choix des types d'instance Pour utiliser le plug-in Nvidia Spark-rapids pour Spark, les groupes d'instances principaux et de tâches doivent utiliser des types d'instances de GPU EC2 répondant aux [exigences matérielles](https://nvidia.github.io/spark-rapids/) de Spark-RAPIDS. Pour la liste complète des types d’instances GPU pris en charge par Amazon EMR, voir la rubrique [Types d’instances pris en charge](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-supported-instance-types.html) du *Guide de gestion d’Amazon EMR*. Le type d'instance du groupe d'instances principal peut être du type GPU ou non, mais les types d'instances ARM ne sont pas pris en charge. ## Configuration des configurations d'applications pour votre cluster **1. Activer Amazon EMR pour installer les plug-ins sur votre nouveau cluster** Pour installer des plug-ins, fournissez la configuration suivante lors de la création de votre cluster : ``` { "Classification":"spark", "Properties":{ "enableSparkRapids":"true" } } ``` **2. Configurer YARN pour utiliser le GPU** Pour plus d’informations sur l’utilisation du GPU sur YARN, voir la rubrique [Utilisation du GPU sur YARN](https://hadoop.apache.org/docs/r3.2.1/hadoop-yarn/hadoop-yarn-site/UsingGpus.html) de la documentation Apache Hadoop. Voici des exemples de configurations YARN pour les versions 6.x et 7.x d’Amazon EMR : ------ #### [ Amazon EMR 7.x ] **Exemple de configuration YARN pour Amazon EMR 7.x** ``` { "Classification":"yarn-site", "Properties":{ "yarn.nodemanager.resource-plugins":"yarn.io/gpu", "yarn.resource-types":"yarn.io/gpu", "yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto", "yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin", "yarn.nodemanager.linux-container-executor.cgroups.mount":"true", "yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/spark-rapids-cgroup", "yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn", "yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor" } },{ "Classification":"container-executor", "Properties":{ }, "Configurations":[ { "Classification":"gpu", "Properties":{ "module.enabled":"true" } }, { "Classification":"cgroups", "Properties":{ "root":"/spark-rapids-cgroup", "yarn-hierarchy":"yarn" } } ] } ``` ------ #### [ Amazon EMR 6.x ] **Exemple de configuration YARN pour Amazon EMR 6.x** ``` { "Classification":"yarn-site", "Properties":{ "yarn.nodemanager.resource-plugins":"yarn.io/gpu", "yarn.resource-types":"yarn.io/gpu", "yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto", "yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin", "yarn.nodemanager.linux-container-executor.cgroups.mount":"true", "yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/sys/fs/cgroup", "yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn", "yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor" } },{ "Classification":"container-executor", "Properties":{ }, "Configurations":[ { "Classification":"gpu", "Properties":{ "module.enabled":"true" } }, { "Classification":"cgroups", "Properties":{ "root":"/sys/fs/cgroup", "yarn-hierarchy":"yarn" } } ] } ``` ------ **3. Configurer Spark pour utiliser RAPIDS** Voici les configurations requises pour permettre à Spark d'utiliser le plug-in RAPIDS : ``` { "Classification":"spark-defaults", "Properties":{ "spark.plugins":"com.nvidia.spark.SQLPlugin", "spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh", "spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/usr/lib/hadoop/lib/native:/usr/lib/hadoop-lzo/lib/native:/docker/usr/lib/hadoop/lib/native:/docker/usr/lib/hadoop-lzo/lib/native" } } ``` [XGBoost4La bibliothèque J-Spark](https://xgboost.readthedocs.io/en/latest/jvm/xgboost4j_spark_tutorial.html) dans XGBoost la documentation est également disponible lorsque le plugin Spark RAPIDS est activé sur votre cluster. Vous pouvez utiliser la configuration suivante pour intégrer XGBoost votre tâche Spark : ``` { "Classification":"spark-defaults", "Properties":{ "spark.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar" } } ``` Pour des configurations Spark supplémentaires que vous pouvez utiliser pour régler un cluster EMR accéléré par GPU, reportez-vous au [Guide de réglage de Rapids Accelerator pour Apache Spark](https://docs.nvidia.com/spark-rapids/user-guide/latest/tuning-guide.html) dans la documentation Nvidia.github.io. **4. Configurer le planificateur de capacité YARN** `DominantResourceCalculator` doit être configuré pour permettre la planification et l'isolation du GPU. Pour plus d'informations, reportez-vous à la section [Utilisation du GPU sur YARN](https://hadoop.apache.org/docs/r3.2.1/hadoop-yarn/hadoop-yarn-site/UsingGpus.html) dans la documentation d'Apache Hadoop. ``` { "Classification":"capacity-scheduler", "Properties":{ "yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator" } } ``` **5. Création d’un fichier JSON pour inclure toutes vos configurations** Vous pouvez créer un fichier JSON contenant votre configuration pour utiliser le plug-in RAPIDS pour votre cluster Spark. Vous fournirez le fichier ultérieurement lors du lancement de votre cluster. Le fichier peut être stocké localement ou sur S3. Pour plus d'informations sur la manière de fournir des configurations d'applications pour vos clusters, consultez [Configuration des applications](emr-configure-apps.md). Utilisez les exemples de fichiers suivants comme modèles pour créer vos propres configurations. ------ #### [ Amazon EMR 7.x ] **Exemple de fichier `my-configurations.json` pour Amazon EMR 7.x** ``` [ { "Classification":"spark", "Properties":{ "enableSparkRapids":"true" } }, { "Classification":"yarn-site", "Properties":{ "yarn.nodemanager.resource-plugins":"yarn.io/gpu", "yarn.resource-types":"yarn.io/gpu", "yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto", "yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin", "yarn.nodemanager.linux-container-executor.cgroups.mount":"true", "yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/spark-rapids-cgroup", "yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn", "yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor" } }, { "Classification":"container-executor", "Properties":{ }, "Configurations":[ { "Classification":"gpu", "Properties":{ "module.enabled":"true" } }, { "Classification":"cgroups", "Properties":{ "root":"/spark-rapids-cgroup", "yarn-hierarchy":"yarn" } } ] }, { "Classification":"spark-defaults", "Properties":{ "spark.plugins":"com.nvidia.spark.SQLPlugin", "spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh", "spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/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.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar", "spark.rapids.sql.concurrentGpuTasks":"1", "spark.executor.resource.gpu.amount":"1", "spark.executor.cores":"2", "spark.task.cpus":"1", "spark.task.resource.gpu.amount":"0.5", "spark.rapids.memory.pinnedPool.size":"0", "spark.executor.memoryOverhead":"2G", "spark.locality.wait":"0s", "spark.sql.shuffle.partitions":"200", "spark.sql.files.maxPartitionBytes":"512m" } }, { "Classification":"capacity-scheduler", "Properties":{ "yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator" } } ] ``` ------ #### [ Amazon EMR 6.x ] **Exemple de fichier `my-configurations.json` pour Amazon EMR 6.x** ``` [ { "Classification":"spark", "Properties":{ "enableSparkRapids":"true" } }, { "Classification":"yarn-site", "Properties":{ "yarn.nodemanager.resource-plugins":"yarn.io/gpu", "yarn.resource-types":"yarn.io/gpu", "yarn.nodemanager.resource-plugins.gpu.allowed-gpu-devices":"auto", "yarn.nodemanager.resource-plugins.gpu.path-to-discovery-executables":"/usr/bin", "yarn.nodemanager.linux-container-executor.cgroups.mount":"true", "yarn.nodemanager.linux-container-executor.cgroups.mount-path":"/sys/fs/cgroup", "yarn.nodemanager.linux-container-executor.cgroups.hierarchy":"yarn", "yarn.nodemanager.container-executor.class":"org.apache.hadoop.yarn.server.nodemanager.LinuxContainerExecutor" } }, { "Classification":"container-executor", "Properties":{ }, "Configurations":[ { "Classification":"gpu", "Properties":{ "module.enabled":"true" } }, { "Classification":"cgroups", "Properties":{ "root":"/sys/fs/cgroup", "yarn-hierarchy":"yarn" } } ] }, { "Classification":"spark-defaults", "Properties":{ "spark.plugins":"com.nvidia.spark.SQLPlugin", "spark.executor.resource.gpu.discoveryScript":"/usr/lib/spark/scripts/gpu/getGpusResources.sh", "spark.executor.extraLibraryPath":"/usr/local/cuda/targets/x86_64-linux/lib:/usr/local/cuda/extras/CUPTI/lib64:/usr/local/cuda/compat/lib:/usr/local/cuda/lib:/usr/local/cuda/lib64:/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.submit.pyFiles":"/usr/lib/spark/jars/xgboost4j-spark_3.0-1.4.2-0.3.0.jar", "spark.rapids.sql.concurrentGpuTasks":"1", "spark.executor.resource.gpu.amount":"1", "spark.executor.cores":"2", "spark.task.cpus":"1", "spark.task.resource.gpu.amount":"0.5", "spark.rapids.memory.pinnedPool.size":"0", "spark.executor.memoryOverhead":"2G", "spark.locality.wait":"0s", "spark.sql.shuffle.partitions":"200", "spark.sql.files.maxPartitionBytes":"512m" } }, { "Classification":"capacity-scheduler", "Properties":{ "yarn.scheduler.capacity.resource-calculator":"org.apache.hadoop.yarn.util.resource.DominantResourceCalculator" } } ] ``` ------ ## Ajoutez une action d'amorçage pour votre cluster Pour plus d’informations sur la façon de fournir des scripts d’action d’amorçage lors de la création d’un cluster, voir la rubrique [Bases de l’action d’amorçage](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-bootstrap.html#bootstrapUses) du *Guide de gestion d’Amazon EMR*. Les exemples de scripts suivants montrent comment créer un fichier d’action bootstrap pour Amazon EMR 6.x et 7.x : ------ #### [ Amazon EMR 7.x ] **Exemple de fichier `my-bootstrap-action.sh` pour Amazon EMR 7.x** Pour utiliser YARN afin de gérer les ressources GPU avec Amazon EMR 7.x, vous devez monter CGroup v1 manuellement sur votre cluster. Vous pouvez le faire à l’aide d’un script d’action d’amorçage, comme indiqué dans cet exemple. ``` #!/bin/bash set -ex sudo mkdir -p /spark-rapids-cgroup/devices sudo mount -t cgroup -o devices cgroupv1-devices /spark-rapids-cgroup/devices sudo chmod a+rwx -R /spark-rapids-cgroup ``` ------ #### [ Amazon EMR 6.x ] **Exemple de fichier `my-bootstrap-action.sh` pour Amazon EMR 6.x** Pour Amazon EMR 6.x, vous devez ouvrir des autorisations CGroup pour YARN sur votre cluster. Pour ce faire, vous pouvez utiliser un script d’action d’amorçage, comme illustré dans cet exemple. ``` #!/bin/bash set -ex sudo chmod a+rwx -R /sys/fs/cgroup/cpu,cpuacct sudo chmod a+rwx -R /sys/fs/cgroup/devices ``` ------ ## Lancement de votre cluster La dernière étape consiste à lancer votre cluster avec les configurations de cluster mentionnées ci-dessus. Voici un exemple de commande pour lancer un cluster via la CLI Amazon EMR : ``` aws emr create-cluster \ --release-label emr-7.12.0 \ --applications Name=Hadoop Name=Spark \ --service-role EMR_DefaultRole_V2 \ --ec2-attributes KeyName=my-key-pair,InstanceProfile=EMR_EC2_DefaultRole \ --instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m4.4xlarge \ InstanceGroupType=CORE,InstanceCount=1,InstanceType=g4dn.2xlarge \ InstanceGroupType=TASK,InstanceCount=1,InstanceType=g4dn.2xlarge \ --configurations file:///my-configurations.json \ --bootstrap-actions Name='My Spark Rapids Bootstrap action',Path=s3://amzn-s3-demo-bucket/my-bootstrap-action.sh ``` # Accès au shell de Spark Le shell Spark est basé sur le Scala REPL (Read-Eval-Print-Loop). Il vous permet de créer des programmes Spark de façon interactive et de soumettre du travail à l'infrastructure. Vous pouvez accéder au shell de Spark en vous connectant au nœud primaire avec SSH et en invoquant `spark-shell`. Pour plus d'informations sur la connexion au nœud primaire, consultez la section [Connexion au nœud primaire à l'aide de SSH](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-ssh.html) dans le *Guide de gestion Amazon EMR*. Les exemples suivants utilisent les journaux d'accès du serveur HTTP Apache stockés dans Amazon S3. **Note** Le compartiment utilisé dans ces exemples est disponible pour les clients ayant accès à la région USA Est (Virginie du Nord). Par défaut, le shell Spark crée son propre [SparkContext](https://spark.apache.org/docs/1.3.1/api/scala/index.html#org.apache.spark.SparkContext)objet appelé`sc`. Vous pouvez utiliser ce contexte s'il est requis dans le REPL. sqlContextest également disponible en coque et il s'agit d'un [HiveContext](https://spark.apache.org/docs/latest/api/scala/index.html#org.apache.spark.sql.hive.HiveContext). **Example Utilisation du shell de Spark pour compter les occurrences d'une chaîne dans un fichier stocké dans Amazon S3** Cet exemple utilise `sc` pour lire un fichier texte stocké dans Amazon S3. ``` scala> sc res0: org.apache.spark.SparkContext = org.apache.spark.SparkContext@404721db scala> val textFile = sc.textFile("s3://elasticmapreduce/samples/hive-ads/tables/impressions/dt=2009-04-13-08-05/ec2-0-51-75-39.amazon.com.rproxy.govskope.ca-2009-04-13-08-05.log") ``` Spark crée le fichier texte et la [structure de données](https://spark.apache.org/docs/latest/programming-guide.html#resilient-distributed-datasets-rdds) associée. Ensuite, l'exemple compte le nombre de lignes figurant dans le fichier journal avec la chaîne « cartoonnetwork.com » : ``` scala> val linesWithCartoonNetwork = textFile.filter(line => line.contains("cartoonnetwork.com")).count() linesWithCartoonNetwork: org.apache.spark.rdd.RDD[String] = MapPartitionsRDD[2] at filter at :23 scala> linesWithCartoonNetwork res2: Long = 9 ``` **Example Utilisation du shell de Spark basé sur Python pour compter les occurrences d'une chaîne dans un fichier stocké dans Amazon S3** Spark inclut également un shell basé sur Python, `pyspark`, que vous pouvez utiliser pour créer un prototype de programmes Spark écrits en Python. Tout comme avec`spark-shell`, invoke `pyspark` sur le nœud principal ; il possède également le même [SparkContext](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.html#pyspark.SparkContext)objet. ``` >>> sc >>> textfile = sc.textFile("s3://elasticmapreduce/samples/hive-ads/tables/impressions/dt=2009-04-13-08-05/ec2-0-51-75-39.amazon.com.rproxy.govskope.ca-2009-04-13-08-05.log") ``` Spark crée le fichier texte et la [structure de données](https://spark.apache.org/docs/latest/programming-guide.html#resilient-distributed-datasets-rdds) associée. Ensuite, l'exemple compte le nombre de lignes figurant dans le fichier journal avec la chaîne « cartoonnetwork.com ». ``` >>> linesWithCartoonNetwork = textfile.filter(lambda line: "cartoonnetwork.com" in line).count() 15/06/04 17:12:22 INFO lzo.GPLNativeCodeLoader: Loaded native gpl library from the embedded binaries 15/06/04 17:12:22 INFO lzo.LzoCodec: Successfully loaded & initialized native-lzo library [hadoop-lzo rev EXAMPLE] 15/06/04 17:12:23 INFO fs.EmrFileSystem: Consistency disabled, using com.amazon.ws.emr.hadoop.fs.s3n.S3NativeFileSystem as filesystem implementation >>> linesWithCartoonNetwork 9 ``` # Utiliser Amazon SageMaker Spark pour le machine learning Lorsque vous utilisez les versions 5.11.0 et ultérieures d'Amazon EMR, le composant `aws-sagemaker-spark-sdk` est installé parallèlement à Spark. Ce composant installe Amazon SageMaker Spark et les dépendances associées pour l'intégration de Spark à [Amazon SageMaker](https://aws.amazon.com/sagemaker/). Veuillez noter que le `aws-sagemaker-spark-sdk` composant n'est pas disponible à partir d'Amazon EMR 7.x et versions ultérieures. Vous pouvez utiliser Amazon SageMaker Spark pour créer des pipelines d'apprentissage automatique (ML) Spark à l'aide d'Amazon SageMaker Stages. Pour plus d'informations, consultez le [fichier README d'Amazon SageMaker Spark](https://github.com/aws/sagemaker-spark/blob/master/README.md) sur GitHub et son [utilisation d'Apache Spark avec Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html) dans le manuel *Amazon SageMaker Developer Guide*. # Ecriture d'une application Spark Les applications [Spark](https://aws.amazon.com/big-data/what-is-spark/) peuvent être écrites en Scala, Java ou Python. Il existe plusieurs exemples d'applications Spark proposés dans la rubrique [Exemples Spark](https://spark.apache.org/examples.html) de la documentation Apache Spark. L'exemple d'estimation du nombre Pi est présenté ci-dessous dans les trois applications prises en charge en mode natif. Vous pouvez également consulter des exemples complets dans `$SPARK_HOME/examples` et sur [GitHub](https://github.com/apache/spark/tree/master/examples/src/main). Pour plus d'informations sur la façon de compiler JARs pour Spark, consultez la rubrique [Démarrage rapide](https://spark.apache.org/docs/latest/quick-start.html) dans la documentation d'Apache Spark. ## Scala Pour éviter les problèmes de compatibilité avec Scala, nous vous conseillons d'utiliser les dépendances Spark pour obtenir la bonne version de Scala lorsque vous compilez une application Spark pour un cluster Amazon EMR. La version de Scala que vous devez utiliser dépend de la version de Spark installée sur votre cluster. Par exemple, la version 5.30.1 d'Amazon EMR utilise Spark 2.4.5, qui est construit avec Scala 2.11. Si votre cluster utilise la version 5.30.1 d'Amazon EMR, utilisez les dépendances Spark pour Scala 2.11. Pour plus d'informations sur les versions de Scala utilisées par Spark, consultez la [documentation d'Apache Spark](https://spark.apache.org/documentation.html). ``` package org.apache.spark.examples import scala.math.random import org.apache.spark._ /** Computes an approximation to pi */ object SparkPi { def main(args: Array[String]) { val conf = new SparkConf().setAppName("Spark Pi") val spark = new SparkContext(conf) val slices = if (args.length > 0) args(0).toInt else 2 val n = math.min(100000L * slices, Int.MaxValue).toInt // avoid overflow val count = spark.parallelize(1 until n, slices).map { i => val x = random * 2 - 1 val y = random * 2 - 1 if (x*x + y*y < 1) 1 else 0 }.reduce(_ + _) println("Pi is roughly " + 4.0 * count / n) spark.stop() } } ``` ## Java ``` package org.apache.spark.examples; import org.apache.spark.SparkConf; import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.JavaSparkContext; import org.apache.spark.api.java.function.Function; import org.apache.spark.api.java.function.Function2; import java.util.ArrayList; import java.util.List; /** * Computes an approximation to pi * Usage: JavaSparkPi [slices] */ public final class JavaSparkPi { public static void main(String[] args) throws Exception { SparkConf sparkConf = new SparkConf().setAppName("JavaSparkPi"); JavaSparkContext jsc = new JavaSparkContext(sparkConf); int slices = (args.length == 1) ? Integer.parseInt(args[0]) : 2; int n = 100000 * slices; List l = new ArrayList(n); for (int i = 0; i < n; i++) { l.add(i); } JavaRDD dataSet = jsc.parallelize(l, slices); int count = dataSet.map(new Function() { @Override public Integer call(Integer integer) { double x = Math.random() * 2 - 1; double y = Math.random() * 2 - 1; return (x * x + y * y < 1) ? 1 : 0; } }).reduce(new Function2() { @Override public Integer call(Integer integer, Integer integer2) { return integer + integer2; } }); System.out.println("Pi is roughly " + 4.0 * count / n); jsc.stop(); } } ``` ## Python ``` import argparse import logging from operator import add from random import random from pyspark.sql import SparkSession logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") def calculate_pi(partitions, output_uri): """ Calculates pi by testing a large number of random numbers against a unit circle inscribed inside a square. The trials are partitioned so they can be run in parallel on cluster instances. :param partitions: The number of partitions to use for the calculation. :param output_uri: The URI where the output is written, typically an Amazon S3 bucket, such as 's3://example-bucket/pi-calc'. """ def calculate_hit(_): x = random() * 2 - 1 y = random() * 2 - 1 return 1 if x**2 + y**2 < 1 else 0 tries = 100000 * partitions logger.info( "Calculating pi with a total of %s tries in %s partitions.", tries, partitions ) with SparkSession.builder.appName("My PyPi").getOrCreate() as spark: hits = ( spark.sparkContext.parallelize(range(tries), partitions) .map(calculate_hit) .reduce(add) ) pi = 4.0 * hits / tries logger.info("%s tries and %s hits gives pi estimate of %s.", tries, hits, pi) if output_uri is not None: df = spark.createDataFrame([(tries, hits, pi)], ["tries", "hits", "pi"]) df.write.mode("overwrite").json(output_uri) if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument( "--partitions", default=2, type=int, help="The number of parallel partitions to use when calculating pi.", ) parser.add_argument( "--output_uri", help="The URI where output is saved, typically an S3 bucket." ) args = parser.parse_args() calculate_pi(args.partitions, args.output_uri) ``` # Améliorer les performances de Spark avec Amazon S3 Amazon EMR propose des fonctionnalités pour aider à optimiser la performance lors de l'utilisation de Spark pour demander, lire et écrire des données enregistrées dans Amazon S3. [S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) peut améliorer la performance de requête pour les fichiers CSV et JSON dans certaines applications en « poussant vers le bas » le traitement à Amazon S3. Le committer optimisé pour EMRFS S3 est une alternative à la [OutputCommitter](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/mapreduce/OutputCommitter.html)classe, qui utilise la fonctionnalité de téléchargement en plusieurs parties d'EMRFS pour améliorer les performances lors de l'écriture de fichiers Parquet sur Amazon S3 à l'aide de Spark et de Datasets. DataFrames **Topics** + [Utilisation de S3 Select avec Spark pour améliorer les performances des requêtes](emr-spark-s3select.md) + [EMR Spark MagicCommitProtocol](emr-spark-magic-commit-protocol.md) + [Utilisation d'un valideur EMRFS optimisé pour S3](emr-spark-s3-optimized-committer.md) + [Utiliser le protocole de validation optimisé pour EMRFS S3](emr-spark-s3-optimized-commit-protocol.md) + [Réessayer de demander Amazon S3 avec EMRFS](emr-spark-emrfs-retry.md) # Utilisation de S3 Select avec Spark pour améliorer les performances des requêtes **Important** Amazon S3 Select n’est plus disponible pour les nouveaux clients. Les clients existants d’Amazon S3 Select peuvent continuer à utiliser cette fonctionnalité comme d’habitude. [En savoir plus](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) À partir de la version 5.17.0 d'Amazon EMR, vous pouvez utiliser [S3 Select](https://aws.amazon.com/blogs/aws/s3-glacier-select/) avec Spark sur Amazon EMR. *S3 Select* permet aux applications de ne récupérer qu’un sous-ensemble de données d’un objet. Pour Amazon EMR, le travail de calcul qu’implique le filtrage d’importants jeux de données pour le traitement est « poussé » du cluster vers Amazon S3, ce qui peut améliorer les performances de certaines applications et réduire le volume de données transféré entre Amazon EMR et Amazon S3. S3 Select est pris en charge avec les fichiers CSV et JSON à l'aide des valeurs `s3selectCSV` et `s3selectJSON` pour spécifier le format de données. Pour plus d’informations et d’exemples, consultez [Spécifier S3 Select dans votre code](#emr-spark-s3select-specify). ## S3 Select est-il adapté à mon application ? Nous vous recommandons de tester vos applications avec et sans S3 Select pour voir si son utilisation peut être adaptée à votre application. Utilisez les consignes suivantes pour déterminer si votre application peut utiliser S3 Select : + Votre requête exclut plus de la moitié de l'ensemble de données d'origine. + Votre connexion réseau entre Amazon S3 et le cluster Amazon EMR a une bonne vitesse de transfert et une bande passante disponible. Amazon S3 ne compresse pas les réponses HTTP, de sorte que la taille de la réponse est susceptible d'augmenter pour les fichiers d'entrée compressés. ## Considérations et restrictions + Le chiffrement côté serveur d'Amazon S3 avec des clés de chiffrement fournies par le client (SSE-C) et le chiffrement côté client ne sont pas pris en charge. + La propriété `AllowQuotedRecordDelimiters` n'est pas prise en charge. Si cette propriété est spécifiée, la requête échoue. + Seuls les fichiers CSV et JSON au format UTF-8 sont pris en charge. CSVsLes lignes multiples ne sont pas prises en charge. + Seuls les fichiers non compressés ou gzip sont pris en charge. + Les options Spark CSV et JSON telles que `nanValue`, `positiveInf`, `negativeInf` et les options liées aux enregistrements corrompus (par exemple, les modes failfast et dropmalformed) ne sont pas prises en charge. + L'utilisation de virgules (,) avec des décimales n'est pas prise en charge. Par exemple, `10,000` n'est pas pris en charge, mais `10000` l'est. + Les caractères de commentaire ne sont pas pris en charge dans la dernière ligne. + Des lignes vides à la fin d'un fichier ne sont pas traitées. + Les filtres suivants ne sont pas transmis à Amazon S3 : + Fonctions d'agrégation, telles que `COUNT()` et `SUM()`. + Filtres qui `CAST()` un attribut. Par exemple, `CAST(stringColumn as INT) = 1`. + Filtres avec un attribut d'objet ou complexe. Par exemple, `intArray[1] = 1, objectColumn.objectNumber = 1`. + Filtres pour lesquels la valeur n'est pas une valeur littérale. Par exemple, `intColumn1 = intColumn2` + Seuls [les types de données S3 Select pris en charge](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-glacier-select-sql-reference-data-types.html) sont pris en charge par les limitations de documentation. ## Spécifier S3 Select dans votre code Les exemples suivants montrent comment spécifier S3 Select pour CSV à l'aide de Scala, SQL, R et PySpark. Vous pouvez utiliser S3 Select pour JSON de la même manière. Pour une liste d'options, leurs valeurs par défaut et leurs limitations, consultez [Options](#emr-spark-s3select-specify-options). ------ #### [ PySpark ] ``` spark .read .format("s3selectCSV") // "s3selectJson" for Json .schema(...) // optional, but recommended .options(...) // optional .load("s3://path/to/my/datafiles") ``` ------ #### [ R ] ``` read.df("s3://path/to/my/datafiles", "s3selectCSV", schema, header = "true", delimiter = "\t") ``` ------ #### [ Scala ] ``` spark .read .format("s3selectCSV") // "s3selectJson" for Json .schema(...) // optional, but recommended .options(...) // optional. Examples: // .options(Map("quote" -> "\'", "header" -> "true")) or // .option("quote", "\'").option("header", "true") .load("s3://path/to/my/datafiles") ``` ------ #### [ SQL ] ``` CREATE TEMPORARY VIEW MyView (number INT, name STRING) USING s3selectCSV OPTIONS (path "s3://path/to/my/datafiles", header "true", delimiter "\t") ``` ------ ### Options Les options suivantes sont disponibles lors de l'utilisation de `s3selectCSV` et `s3selectJSON`. Si rien n'est spécifié, les valeurs par défaut sont utilisées. #### Options avec S3selectCSV | Option | Par défaut | Usage | | --- | --- | --- | | `compression` | `"none"` | Indique si la compression est utilisée. `"gzip"` est le seul paramètre pris en charge, à part `"none"`. | | `delimiter` | "," | Spécifie le caractère délimiteur de champ. | | `quote` | `'\"'` | Spécifie le caractère de citation. La spécification d'une chaîne vide n'est pas prise en charge et mène à une erreur de XML malformé. | | `escape` | `'\\'` | Spécifie le caractère échappe. | | `header` | `"false"` | `"false"` spécifie qu'il n'y a pas d'en-tête. `"true"` spécifie qu'une en-tête est dans la première ligne. Les en-têtes ne sont prises en charge que pour la première ligne, et les lignes vides avant une en-tête ne sont pas prises en charge. | | comment | `"#"` | Spécifie le caractère de commentaire. L'indicateur de commentaire ne peut pas être désactivé. En d'autres termes, la valeur de `\u0000` n'est pas prise en charge. | | `nullValue` | "" | | #### Options avec S3selectJSON | Option | Par défaut | Usage | | --- | --- | --- | | `compression` | `"none"` | Indique si la compression est utilisée. `"gzip"` est le seul paramètre pris en charge, à part `"none"`. | | `multiline` | « false » | `"false"` spécifie que JSON est en format `LINES` S3 Select. Cela implique que chaque ligne des données d'entrée contient un seul objet JSON. `"true"` spécifie que JSON est en format `DOCUMENT` S3 Select, ce qui signifie qu'un objet JSON peut s'étendre sur plusieurs lignes dans les données d'entrée. | # EMR Spark MagicCommitProtocol À partir de la version 6.15.0 d'EMR, MagicCommitProtocol devient la valeur par défaut FileCommitProtocol pour Spark lors de l'utilisation du système de fichiers S3A. ## MagicCommitProtocol MagicCommitProtocol Il s'agit d'une implémentation alternative optimisée pour écrire des fichiers avec EMR Spark sur Amazon S3 lors de l'utilisation du système de fichiers S3A. [FileCommitProtocol](https://dlcdn.apache.org/spark/docs/2.4.2/api/java/org/apache/spark/internal/io/FileCommitProtocol.html) Ce protocole vise à améliorer les performances des applications en évitant d'utiliser des opérations de renommage dans Amazon S3 pendant les phases de validation des tâches et des tâches. MagicCommitProtocol Il s'agit de l' FileCommitProtocol implémentation par défaut utilisée par Spark s'exécutant sur Amazon Elastic Map Reduce (EMR) lorsque le système de fichiers S3A est utilisé. Il utilise MagicCommitProtocol en interne le [MagicV2Committer pour effectuer les écritures](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/s3a-magicv2-committer.html) de fichiers sur Amazon S3. Pour les opérations d'insertion statique, les MagicCommitProtocol fichiers sont écrits dans l'emplacement de sortie de la tâche pendant la phase de validation de la tâche. En revanche, pour les opérations d'insertion et de réécriture dynamiques, les fichiers écrits par des tentatives de tâche apparaissent uniquement dans l'emplacement de sortie de la tâche lors de la validation de la tâche. Pour ce faire, les métadonnées de validation sont réexportées vers le pilote Spark lors de l'appel de validation de la tâche. ## Activant MagicCommitProtocol MagicCommitProtocol Il est activé par défaut pour que Spark s'exécute sur Amazon Elastic Map Reduce (EMR) lors de l'utilisation du système de fichiers S3A. Pour utiliser le système de fichiers S3A, vous pouvez soit : 1. Utilisez le schéma de fichier comme `s3a://` lors de la définition de la table, de la partition ou du répertoire. 1. Définissez la configuration `fs.s3.impl=org.apache.hadoop.fs.s3a.S3AFileSystem` dans le fichier core-site.xml. ## Désactivation du MagicCommitProtocol 1. Vous pouvez le `spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol` définir sur false en le codant en dur dans a`SparkConf`, en le passant en tant que `--conf` paramètre dans le shell Spark ou `spark-submit` les `spark-sql` outils, ou dans`conf/spark-defaults.conf`. Pour plus d'informations, consultez la section [Configuration de Spark](https://spark.apache.org/docs/latest/configuration.html) dans la documentation d'Apache Spark. L'exemple suivant montre comment le désactiver MagicCommitProtocol lors de l'exécution d'une `spark-sql` commande. ``` spark-sql \ --conf spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol=false \ -e "INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;" ``` 1. Utilisez la classification `spark-defaults` de configuration pour définir la `spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol.leverageMagicCommitProtocol` propriété sur false. Pour plus d'informations, consultez [Configuration des applications](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps.html). ## MagicCommitProtocol considérations + Pour l'insertion d'une partition statique, sur les exécuteurs Spark, chaque fichier écrit par une tentative de tâche MagicCommitProtocol consomme une petite quantité de mémoire jusqu'à ce que la tâche soit validée ou abandonnée. La quantité de mémoire consommée est négligeable dans la plupart des tâches. Aucune mémoire supplémentaire n'est requise sur le pilote Spark + Pour l'insertion dynamique d'une partition, sur les pilotes Spark, MagicCommitProtocol il faut de la mémoire pour stocker les informations de métadonnées de chaque fichier validé jusqu'à ce que la tâche soit validée ou abandonnée. Dans la plupart des tâches, le paramètre de mémoire par défaut du pilote Spark est négligeable. Pour les tâches qui ont des tâches de longue durée qui écrivent un grand nombre de fichiers, la mémoire que le protocole de validation consomme peut être perceptible et nécessiter des ajustements de la mémoire allouée pour Spark, en particulier pour les exécuteurs Spark. Vous pouvez régler la mémoire à l'aide de la propriété `spark.driver.memory` pour les pilotes Spark et de la propriété `spark.executor.memory` pour les exécuteurs Spark. À titre indicatif, une seule tâche d'écriture de 100 000 fichiers nécessite généralement 200 Mo de mémoire supplémentaires. Pour plus d'informations, consultez [Propriétés d'applications](https://spark.apache.org/docs/latest/configuration.html#application-properties) dans la Documentation de configuration Apache Spark. # Utilisation d'un valideur EMRFS optimisé pour S3 Le committer optimisé pour EMRFS S3 est une [OutputCommitter](https://hadoop.apache.org/docs/current/api/org/apache/hadoop/mapreduce/OutputCommitter.html)implémentation alternative optimisée pour écrire des fichiers sur Amazon S3 lors de l'utilisation d'EMRFS. Le validateur EMRFS optimisé pour S3 améliore les performances de l'application en évitant les opérations de liste et de renommage effectuées dans Amazon S3 pendant les phases de validation des tâches. Le valideur est disponible dans les versions 5.19.0 et ultérieures d'Amazon EMR et est activé par défaut dans les versions 5.20.0 et ultérieures d'Amazon EMR. Le committer est utilisé pour les tâches Spark qui utilisent Spark ou Datasets. DataFrames À partir d'Amazon EMR 6.4.0, ce validateur peut être utilisé pour tous les formats courants, notamment parquet, ORC et les formats basés sur le texte (notamment CSV et JSON). Pour les versions antérieures à Amazon EMR 6.4.0, seul le format Parquet est pris en charge. Dans certaines situations, le valideur n'est pas utilisé. Pour de plus amples informations, veuillez consulter [Exigences du valideur EMRFS optimisé pour S3](emr-spark-committer-reqs.md). **Topics** + [Exigences du valideur EMRFS optimisé pour S3](emr-spark-committer-reqs.md) + [Le valideur EMRFS optimisé pour S3 et les chargements partitionnés](emr-spark-committer-multipart.md) + [Considérations de réglage de tâche](emr-spark-committer-tuning.md) + [Activer le validateur EMRFS S3 pour Amazon EMR 5.19.0](emr-spark-committer-enable.md) # Exigences du valideur EMRFS optimisé pour S3 Le valideur EMRFS optimisé pour S3 est utilisé lorsque les conditions suivantes sont réunies : + Vous exécutez des tâches Spark qui utilisent Spark ou Datasets pour écrire des fichiers sur Amazon S3. DataFrames À partir d'Amazon EMR 6.4.0, ce validateur peut être utilisé pour tous les formats courants, notamment parquet, ORC et les formats basés sur le texte (notamment CSV et JSON). Pour les versions antérieures à Amazon EMR 6.4.0, seul le format Parquet est pris en charge. + Les chargements partitionnés sont activés dans Amazon EMR. Il s’agit de l’option par défaut. Pour de plus amples informations, veuillez consulter [Le valideur EMRFS optimisé pour S3 et les chargements partitionnés](emr-spark-committer-multipart.md). + Le support de format de fichier intégré à Spark est utilisé. La prise en charge du format de fichier intégré est utilisée dans les circonstances suivantes : + Pour les tables de métastore Hive, lorsque `spark.sql.hive.convertMetastoreParquet` est défini sur `true` pour les tables Parquet, ou lorsque `spark.sql.hive.convertMetastoreOrc` est défini sur `true` pour les tables Orc avec Amazon EMR 6.4.0 ou version ultérieure. Il s'agit des paramètres par défaut. + Lorsque les tâches écrivent dans des sources de données ou des tables au format de fichier – par exemple, la table cible est créée avec la clause `USING parquet`. + Lorsque des tâches écrivent dans des tableaux Parquet de metastore Hive non partitionnées. Le support Parquet intégré à Spark ne prend pas en charge avec les tableaux Hive partitionnés. Il s'agit d'une limitation connue. Pour plus d'informations, consultez la section [Conversion des tables Hive Metastore Parquet](https://spark.apache.org/docs/latest/sql-data-sources-parquet.html#hive-metastore-parquet-table-conversion) dans le guide Apache Spark DataFrames et Datasets. + Les opérations de tâche Spark qui écrivent dans un emplacement de partition par défaut (par exemple, `${table_location}/k1=v1/k2=v2/`) utilisent le valideur. Le valideur n'est pas utilisé si une opération de tâche écrit dans un emplacement de partition personnalisé, par exemple, si un emplacement de partition personnalisé est défini à l'aide de la commande `ALTER TABLE SQL`. + Les valeurs suivantes pour Spark doivent être utilisées : + La propriété `spark.sql.parquet.fs.optimized.committer.optimization-enabled` doit être définie sur `true`. Il s'agit du paramètre par défaut avec Amazon EMR 5.20.0 ou version suivante. Avec Amazon EMR 5.19.0, la valeur par défaut est `false`. Pour plus d'informations sur la configuration de cette valeur, consultez [Activer le validateur EMRFS S3 pour Amazon EMR 5.19.0](emr-spark-committer-enable.md). + Si vous écrivez dans des tables de métastore Hive non partitionnées, seuls les formats de fichier Parquet et Orc sont pris en charge. `spark.sql.hive.convertMetastoreParquet`doit être défini sur `true` si vous écrivez sur des tables de métastore Parquet Hive non partitionnées. `spark.sql.hive.convertMetastoreOrc`doit être défini sur `true` si vous écrivez dans des tables de métastore Orc Hive non partitionnées. Il s'agit des paramètres par défaut. + `spark.sql.parquet.output.committer.class` doit être défini sur `com.amazon.emr.committer.EmrOptimizedSparkSqlParquetOutputCommitter`. Il s’agit du paramètre par défaut. + `spark.sql.sources.commitProtocolClass` doit être défini sur `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` ou `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol`. `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol` est le paramètre par défaut pour les versions 5.30.0 et ultérieures de la série Amazon EMR 5.x, et pour les versions 6.2.0 et ultérieures de la série Amazon EMR 6.x. `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol` est le paramètre par défaut pour les versions précédentes d’Amazon EMR. + Si des tâches Spark remplacent des ensembles de données Parquet partitionnés par des colonnes de partition dynamique, l'option d'écriture `partitionOverwriteMode` et `spark.sql.sources.partitionOverwriteMode` doivent être définis sur `static`. Il s’agit du paramètre par défaut. **Note** L'option d'écriture `partitionOverwriteMode` a été introduite dans Spark 2.4.0. Pour Spark version 2.3.2, inclus avec Amazon EMR version 5.19.0, définissez la propriété `spark.sql.sources.partitionOverwriteMode`. ## Cas dans lesquels le valideur EMRFS optimisé pour S3 n’est pas utilisé En général, le valideur EMRFS S3 optimisé n’est pas utilisé dans les situations suivantes. **** | Situation | Pourquoi le validateur n'est pas utilisé | | --- | --- | | Lorsque vous écrivez dans HDFS | Le validateur prend uniquement en charge l'écriture sur Amazon S3 à l'aide d'EMRFS. | | Lorsque vous utilisez le système de fichiers S3A | Le validateur ne prend en charge que EMRFS. | | Lorsque vous utilisez l' MapReduce API RDD de Spark | Le committer prend uniquement en charge l'utilisation de SparkSQL ou DataFrame Dataset. APIs | Les exemples en Scala suivants illustrent quelques situations supplémentaires qui empêchent d'utiliser le validateur optimisé pour EMRFS S3 en totalité (premier exemple) et en partie (deuxième exemple). **Example – Mode de remplacement de partition dynamique** L'exemple Scala suivant indique à Spark d'utiliser un algorithme de validation différent, ce qui empêche complètement l'utilisation du validateur optimisé pour EMRFS S3. Le code définit la propriété `partitionOverwriteMode` sur `dynamic` pour n'écraser que les partitions sur lesquelles vous écrivez des données. Ensuite, les colonnes de partition dynamique sont spécifiées par `partitionBy`, et le mode d'écriture est défini sur `overwrite`. ``` val dataset = spark.range(0, 10) .withColumn("dt", expr("date_sub(current_date(), id)")) dataset.write.mode("overwrite") .option("partitionOverwriteMode", "dynamic") .partitionBy("dt") .parquet("s3://amzn-s3-demo-bucket1/output") ``` Vous devez configurer les trois paramètres pour éviter d'utiliser le validateur EMRFS S3. Lorsque vous le faites, Spark exécute un algorithme de validation différent qui est spécifié dans le protocole de validation de Spark. Pour les versions d'Amazon EMR 5.x antérieures à la version 5.30.0 et pour les versions d'Amazon EMR 6.x antérieures à la version 6.2.0, le protocole de validation utilise le répertoire de préparation de Spark, qui est un répertoire temporaire créé sous l'emplacement de sortie commençant par `.spark-staging`. L'algorithme renomme séquentiellement les répertoires de partition, ce qui peut avoir un impact négatif sur les performances. Pour de plus amples informations sur Amazon EMR versions 5.30.0 et versions ultérieures, ainsi que 6.2.0 et versions ultérieures, veuillez consulter [Utiliser le protocole de validation optimisé pour EMRFS S3](emr-spark-s3-optimized-commit-protocol.md). L'algorithme dans Spark 2.4.0 exécute les étapes suivantes : 1. Les tentatives de tâches écrivent leur résultat dans les répertoires de partition situés dans le répertoire de préparation de Spark, par exemple, `${outputLocation}/spark-staging-${jobID}/k1=v1/k2=v2/`. 1. Pour chaque partition écrite, la tâche tente de suivre les chemins de partition relatifs, par exemple, `k1=v1/k2=v2`. 1. Lorsqu'une tâche se termine avec succès elle fournit le pilote avec tous les chemins de partition relatifs qu'elle a suivis. 1. Une fois toutes les tâches terminées, la phase de validation de tâche collecte tous les répertoires de partition que les tentatives de tâche réussies ont écrit dans le répertoire intermédiaire de Spark. Spark renomme de manière séquentielle chacun de ces répertoires dans son emplacement de sortie final à l'aide d'opérations attribution de nouveau nom de l'arborescence. 1. Le répertoire intermédiaire est supprimé avant que la phase de validation de tâche soit terminée. **Example – Emplacement de partition personnalisé** Dans cet exemple, le code Scala s'insère dans deux partitions. Une partition possède un emplacement de partition personnalisé. L'autre partition utilise l'emplacement de partition par défaut. Le valideur EMRFS optimisé pour S3 est utilisé uniquement pour écrire la sortie de tâche dans la partition qui utilise l'emplacement de partition par défaut. ``` val table = "dataset" val location = "s3://bucket/table" spark.sql(s""" CREATE TABLE $table (id bigint, dt date) USING PARQUET PARTITIONED BY (dt) LOCATION '$location' """) // Add a partition using a custom location val customPartitionLocation = "s3://bucket/custom" spark.sql(s""" ALTER TABLE $table ADD PARTITION (dt='2019-01-28') LOCATION '$customPartitionLocation' """) // Add another partition using default location spark.sql(s"ALTER TABLE $table ADD PARTITION (dt='2019-01-29')") def asDate(text: String) = lit(text).cast("date") spark.range(0, 10) .withColumn("dt", when($"id" > 4, asDate("2019-01-28")).otherwise(asDate("2019-01-29"))) .write.insertInto(table) ``` Le code Scala crée les objets Amazon S3 suivants : ``` custom/part-00001-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet custom_$folder$ table/_SUCCESS table/dt=2019-01-29/part-00000-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet table/dt=2019-01-29_$folder$ table_$folder$ ``` Lorsque vous écrivez des partitions dans des emplacements personnalisés, Spark utilise un algorithme de validation similaire à celui de l'exemple précédent, qui est décrit ci-dessous. Comme dans l'exemple précédent, l'algorithme se traduit par des attributions séquentielles de nouveaux noms, ce qui peut avoir un impact négatif sur les performances. 1. Lors de l'écriture de la sortie d'une partition dans un emplacement personnalisé, les tâches écrivent un fichier dans le répertoire intermédiaire de Spark, qui est créé sous l'emplacement de sortie final. Le nom du fichier comprend un UUID aléatoire pour éviter les conflits de fichier. La tentative de tâche suit chaque fichier, ainsi que le chemin de la sortie souhaité final. 1. Lorsqu'une tâche se termine avec succès, elle fournit au pilote les fichiers et les chemins de sortie souhaités finaux. 1. Une fois toutes les tâches terminées, la phase de validation de tâche renomme de manière séquentielle tous les fichiers qui ont été écrits pour les partitions dans les emplacements personnalisés en leurs chemins de sortie finaux. 1. Le répertoire intermédiaire est supprimé avant que la phase de validation de tâche soit terminée. # Le valideur EMRFS optimisé pour S3 et les chargements partitionnés Pour utiliser le valideur EMRFS optimisé pour S3, vous devez activer les chargements partitionnés dans Amazon EMR. Les chargements partitionnés sont activés par défaut. Vous pouvez les réactiver si besoin est. Pour plus d'informations, consultez [Configuration d'un chargement partitionné pour Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart) dans le *Guide de gestion Amazon EMR*. Le valideur EMRFS optimisé pour S3 utilise des caractéristiques similaires à des transactions de chargements partitionnés pour assurer que les fichiers écrits par des tentatives de tâches apparaissent uniquement dans l'emplacement de sortie du travail lors de la validation de tâche. En utilisant les téléchargements partitionnés de cette manière, le validateur améliore les performances de validation des tâches par rapport à la version 2 de l' FileOutputCommitter algorithme par défaut. Lors de l'utilisation d'un valideur EMRFS optimisé pour S3, il existe certaines différences importantes à prendre en compte comparé au comportement de chargement partitionné : + Les chargements partitionnés sont toujours effectués, peu importe la taille du fichier. Ceci diffère du comportement normal d'EMRFS, où la propriété `fs.s3n.multipart.uploads.split.size` contrôle la taille du fichier à laquelle les chargements partitionnés sont enclenchés. + Les chargements partitionnés sont laissés en état non terminé pendant un plus long laps de temps jusqu'à ce que la tâche soit validée ou abandonnée. Ceci diffère du comportement normal d'EMRFS, où un chargement partitionné se termine lorsqu'un tâche termine d'écrire un fichier donné. En raison de ces différences, si un Spark Executor JVM crache ou qu'il est tué lorsque des tâches sont en cours d'exécution ou écrivent des données à Amazon S3, les chargements partitionnés inachevés ont plus de chances d'être laissés de côté. Pour cette raison, lorsque vous utilisez un valideur EMRFS optimisé pour S3, assurez-vous de suivre les bonnes pratiques de gestion de chargements partitionnés échoués. Pour plus d'informations, consultez [Bonnes pratiques](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#emr-bucket-bestpractices) pour travailler avec des compartiments Amazon S3 dans le *Guide de gestion Amazon EMR*. # Considérations de réglage de tâche Le valideur EMRFS optimisé pour S3 consomme une petite quantité de mémoire pour chaque fichier écrit par une tentative de tâche, jusqu'à ce que la tâche soit validée ou abandonnée. La quantité de mémoire consommée est négligeable dans la plupart des tâches. Pour les tâches dotées de tâches à longue exécution qui écrivent un grand nombre de fichiers, la mémoire consommée par le valideur peut être significative et nécessitera des ajustements à l'allocation de mémoire aux exécuteurs Spark. Vous pouvez ajuster la mémoire d'exécuteur à l'aide de la propriété `spark.executor.memory`. Une seule tâche écrivant 100 000 fichiers nécessiterait en général environ 100 Mo de mémoire supplémentaire. Pour plus d'informations, consultez [Propriétés d'applications](https://spark.apache.org/docs/latest/configuration.html#application-properties) dans la Documentation de configuration Apache Spark. # Activer le validateur EMRFS S3 pour Amazon EMR 5.19.0 Si vous utilisez Amazon EMR 5.19.0, vous pouvez définir la propriété `spark.sql.parquet.fs.optimized.committer.optimization-enabled` sur `true` lorsque vous créez un cluster, ou depuis Spark si vous utilisez Amazon EMR. ## Activation d'un valideur EMRFS optimisé pour S3 lors de la création d'un cluster Utilisez la classification de configuration `spark-defaults` pour définir la propriété `spark.sql.parquet.fs.optimized.committer.optimization-enabled` sur `true`. Pour de plus amples informations, veuillez consulter [Configuration des applications](emr-configure-apps.md). ## Activation d'un valideur EMRFS optimisé pour S3 depuis Spark Vous pouvez définir `spark.sql.parquet.fs.optimized.committer.optimization-enabled` sur `true` en l'ancrant dans un `SparkConf`, en le passant comme paramètre `--conf` dans le shell Spark ou les outils `spark-submit` et `spark-sql`, ou dans `conf/spark-defaults.conf`. Pour plus d'informations, consultez [Configuration Spark](https://spark.apache.org/docs/latest/configuration.html) dans la documentation Apache Spark. L'exemple suivant montre comment activer le valideur en exécutant une commande spark-sql. ``` spark-sql \ --conf spark.sql.parquet.fs.optimized.committer.optimization-enabled=true \ -e "INSERT OVERWRITE TABLE target_table SELECT * FROM source_table;" ``` # Utiliser le protocole de validation optimisé pour EMRFS S3 Le protocole de validation optimisé pour EMRFS S3 est une [FileCommitProtocol](https://spark.apache.org/docs/2.2.0//api/java/org/apache/spark/internal/io/FileCommitProtocol.html)implémentation alternative optimisée pour écrire des fichiers avec remplacement dynamique de partition Spark sur Amazon S3 lors de l'utilisation d'EMRFS. Le protocole améliore les performances des applications en évitant les opérations de renommage dans Amazon S3 pendant la phase de validation de la tâche de remplacement de partition dynamique Spark. Notez que le [validateur optimisé pour EMRFS S3 améliore également les performances en évitant](emr-spark-s3-optimized-committer.html) les opérations de renommage. Cependant, cela ne fonctionne pas pour les cas de remplacement de partition dynamique, tandis que les améliorations du protocole de validation ne ciblent que les cas de remplacement de partition dynamique. Le protocole de validation est disponible avec les versions 5.30.0 et suivantes d'Amazon EMR et 6.2.0 et suivantes, et il est activé par défaut. Amazon EMR a ajouté une amélioration du parallélisme à partir de la version 5.31.0. Le protocole est utilisé pour les tâches Spark qui utilisent Spark ou Datasets. DataFrames Dans certaines circonstances, le protocole de validation n'est pas utilisé. Pour de plus amples informations, veuillez consulter [Conditions requises pour le protocole de validation EMRFS optimisé pour S3](emr-spark-committer-reqs.md). **Topics** + [Conditions requises pour le protocole de validation EMRFS optimisé pour S3](emr-spark-commit-protocol-reqs.md) + [Le protocole de validation EMRFS optimisé pour S3 et les chargements partitionnés](emr-spark-commit-protocol-multipart.md) + [Considérations de réglage de tâche](emr-spark-commit-protocol-tuning.md) # Conditions requises pour le protocole de validation EMRFS optimisé pour S3 Le protocole de validation EMRFS optimisé pour S3 est utilisé lorsque les conditions suivantes sont remplies : + Vous exécutez des tâches Spark qui utilisent Spark ou Datasets pour remplacer les tables partitionnées. DataFrames + Vous exécutez des tâches Spark dont le mode de remplacement de partition est `dynamic`. + Les chargements partitionnés sont activés dans Amazon EMR. Il s’agit de l’option par défaut. Pour de plus amples informations, veuillez consulter [Le protocole de validation EMRFS optimisé pour S3 et les chargements partitionnés](emr-spark-commit-protocol-multipart.md). + Le cache du système de fichiers pour EMRFS est activé. Il s’agit de l’option par défaut. Vérifiez que le paramètre `fs.s3.impl.disable.cache` est défini sur `false`. + Le support intégré des sources de données de Spark est utilisé. La prise en charge de la source de données intégrée est utilisée dans les circonstances suivantes : + Lorsque les tâches écrivent dans des sources de données ou des tables intégrées. + Lorsque les tâches écrivent dans la table Parquet du métastore Hive. Cela se produit lorsque `spark.sql.hive.convertInsertingPartitionedTable` et `spark.sql.hive.convertMetastoreParquet` sont tous deux définis sur true. Il s'agit des paramètres par défaut. + Lorsque les jobs écrivent dans la table ORC du métastore Hive. Cela se produit lorsque `spark.sql.hive.convertInsertingPartitionedTable` et `spark.sql.hive.convertMetastoreOrc` sont tous deux définis sur `true`. Il s'agit des paramètres par défaut. + Les opérations de tâches Spark qui écrivent dans un emplacement de partition par défaut (par exemple, `${table_location}/k1=v1/k2=v2/`) utilisent le protocole de validation. Le protocole n'est pas utilisé si une opération de tâche écrit dans un emplacement de partition personnalisé (par exemple, si un emplacement de partition personnalisé est défini à l'aide de la commande `ALTER TABLE SQL`). + Les valeurs suivantes pour Spark doivent être utilisées : + `spark.sql.sources.commitProtocolClass` doit être défini sur `org.apache.spark.sql.execution.datasources.SQLEmrOptimizedCommitProtocol`. Il s'agit du paramètre par défaut pour les versions 5.30.0 et supérieures d'Amazon EMR, ainsi que pour les versions 6.2.0 et supérieures. + L'option d'écriture `partitionOverwriteMode` ou `spark.sql.sources.partitionOverwriteMode` doit être définie sur `dynamic`. Le paramètre par défaut est `static`. **Note** L'option d'écriture `partitionOverwriteMode` a été introduite dans Spark 2.4.0. Pour Spark version 2.3.2, inclus avec Amazon EMR version 5.19.0, définissez la propriété `spark.sql.sources.partitionOverwriteMode`. + Si les tâches Spark remplacent la table Parquet du métastore Hive, `spark.sql.hive.convertMetastoreParquet`, `spark.sql.hive.convertInsertingPartitionedTable` et `spark.sql.hive.convertMetastore.partitionOverwriteMode` doivent être définis sur `true`. Il s'agit des paramètres par défaut. + Si les tâches Spark remplacent la table ORC du métastore Hive, `spark.sql.hive.convertMetastoreOrc`, `spark.sql.hive.convertInsertingPartitionedTable` et `spark.sql.hive.convertMetastore.partitionOverwriteMode` doivent être définis sur `true`. Il s'agit des paramètres par défaut. **Example – Mode de remplacement de partition dynamique** Dans cet exemple de Scala, l'optimisation est déclenchée. Tout d'abord, vous définissez la propriété `partitionOverwriteMode` sur `dynamic`. Cela remplace uniquement les partitions sur lesquelles vous écrivez des données. Ensuite, vous spécifiez les colonnes de partition dynamique avec `partitionBy` et définissez le mode d'écriture sur `overwrite`. ``` val dataset = spark.range(0, 10) .withColumn("dt", expr("date_sub(current_date(), id)")) dataset.write.mode("overwrite") // "overwrite" instead of "insert" .option("partitionOverwriteMode", "dynamic") // "dynamic" instead of "static" .partitionBy("dt") // partitioned data instead of unpartitioned data .parquet("s3://amzn-s3-demo-bucket1/output") // "s3://" to use Amazon EMR file system, instead of "s3a://" or "hdfs://" ``` ## Lorsque le protocole de validation EMRFS optimisé pour S3 n'est pas utilisé En général, le protocole de validation optimisé pour EMRFS S3 fonctionne de la même manière que le protocole de validation Spark par défaut open source. `org.apache.spark.sql.execution.datasources.SQLHadoopMapReduceCommitProtocol` L'optimisation ne se produira pas dans les situations suivantes. **** | Situation | Pourquoi le protocole de validation n'est pas utilisé | | --- | --- | | Lorsque vous écrivez dans HDFS | Le protocole de validation prend uniquement en charge l'écriture sur Amazon S3 à l'aide d'EMRFS. | | Lorsque vous utilisez le système de fichiers S3A | Le protocole de validation ne prend en charge que le protocole EMRFS. | | Lorsque vous utilisez l' MapReduce API RDD de Spark | Le protocole de validation prend uniquement en charge l'utilisation de SparkSQL ou DataFrame Dataset. APIs | | Lorsque le remplacement dynamique de la partition n'est pas déclenché | Le protocole de validation optimise uniquement les cas de remplacement dynamique de partitions. Pour les autres cas, consultez [Utilisation d'un valideur EMRFS optimisé pour S3](emr-spark-s3-optimized-committer.md). | Les exemples Scala suivants démontrent quelques situations supplémentaires que le protocole de validation EMRFS optimisé pour S3 délègue à `SQLHadoopMapReduceCommitProtocol`. **Example – Mode de remplacement dynamique de partition avec emplacement de partition personnalisé** Dans cet exemple, les programmes Scala remplacent deux partitions en mode de remplacement dynamique de partition. Une partition possède un emplacement de partition personnalisé. L'autre partition utilise l'emplacement de partition par défaut. Le protocole de validation EMRFS optimisé pour S3 n'améliore que la partition qui utilise l'emplacement de partition par défaut. ``` val table = "dataset" val inputView = "tempView" val location = "s3://bucket/table" spark.sql(s""" CREATE TABLE $table (id bigint, dt date) USING PARQUET PARTITIONED BY (dt) LOCATION '$location' """) // Add a partition using a custom location val customPartitionLocation = "s3://bucket/custom" spark.sql(s""" ALTER TABLE $table ADD PARTITION (dt='2019-01-28') LOCATION '$customPartitionLocation' """) // Add another partition using default location spark.sql(s"ALTER TABLE $table ADD PARTITION (dt='2019-01-29')") def asDate(text: String) = lit(text).cast("date") spark.range(0, 10) .withColumn("dt", when($"id" > 4, asDate("2019-01-28")).otherwise(asDate("2019-01-29"))) .createTempView(inputView) // Set partition overwrite mode to 'dynamic' spark.sql(s"SET spark.sql.sources.partitionOverwriteMode=dynamic") spark.sql(s"INSERT OVERWRITE TABLE $table SELECT * FROM $inputView") ``` Le code Scala crée les objets Amazon S3 suivants : ``` custom/part-00001-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet custom_$folder$ table/_SUCCESS table/dt=2019-01-29/part-00000-035a2a9c-4a09-4917-8819-e77134342402.c000.snappy.parquet table/dt=2019-01-29_$folder$ table_$folder$ ``` L'écriture sur des emplacements de partition personnalisés dans les versions antérieures de Spark peut entraîner une perte de données. Dans cet exemple, la partition `dt='2019-01-28'` serait perdue. Pour plus de détails, consultez [SPARK-35106](https://issues.apache.org/jira/browse/SPARK-35106). Ce problème est résolu dans les versions 5.33.0 et ultérieures d'Amazon EMR, à l'exception des versions 6.0.x et 6.1.x. Lorsque vous écrivez des partitions dans des emplacements personnalisés, Spark utilise un algorithme de validation similaire à celui de l'exemple précédent, qui est décrit ci-dessous. Comme dans l'exemple précédent, l'algorithme se traduit par des attributions séquentielles de nouveaux noms, ce qui peut avoir un impact négatif sur les performances. L'algorithme dans Spark 2.4.0 exécute les étapes suivantes : 1. Lors de l'écriture de la sortie d'une partition dans un emplacement personnalisé, les tâches écrivent un fichier dans le répertoire intermédiaire de Spark, qui est créé sous l'emplacement de sortie final. Le nom du fichier comprend un UUID aléatoire pour éviter les conflits de fichier. La tentative de tâche suit chaque fichier, ainsi que le chemin de la sortie souhaité final. 1. Lorsqu'une tâche se termine avec succès, elle fournit au pilote les fichiers et les chemins de sortie souhaités finaux. 1. Une fois toutes les tâches terminées, la phase de validation de tâche renomme de manière séquentielle tous les fichiers qui ont été écrits pour les partitions dans les emplacements personnalisés en leurs chemins de sortie finaux. 1. Le répertoire intermédiaire est supprimé avant que la phase de validation de tâche soit terminée. # Le protocole de validation EMRFS optimisé pour S3 et les chargements partitionnés Pour utiliser l'optimisation pour le remplacement dynamique des partitions dans le protocole de validation optimisé pour EMRFS S3, les chargements partitionnés doivent être activés dans Amazon EMR. Les chargements partitionnés sont activés par défaut. Vous pouvez les réactiver si besoin est. Pour plus d'informations, consultez [Configuration d'un chargement partitionné pour Simple Storage Service (Amazon S3)](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#Config_Multipart) dans le *Guide de gestion Amazon EMR*. Pendant l'écrasement dynamique de partition, le protocole de validation EMRFS optimisé pour S3 utilise les caractéristiques de transaction des chargements partitionnés pour s'assurer que les fichiers écrits par les tentatives de tâches n'apparaissent que dans l'emplacement de sortie de la tâche au moment de la validation de la tâche. En utilisant les chargements partitionnés de cette manière, le protocole de validation améliore les performances de validation des tâches par rapport au protocole par défaut `SQLHadoopMapReduceCommitProtocol`. Lors de l'utilisation du protocole de validation EMRFS optimisé pour S3, il y a quelques différences clés à prendre en compte par rapport au comportement traditionnel des chargements partitionnés : + Les chargements partitionnés sont toujours effectués, peu importe la taille du fichier. Ceci diffère du comportement normal d'EMRFS, où la propriété `fs.s3n.multipart.uploads.split.size` contrôle la taille du fichier à laquelle les chargements partitionnés sont enclenchés. + Les chargements partitionnés sont laissés en état non terminé pendant un plus long laps de temps jusqu'à ce que la tâche soit validée ou abandonnée. Ceci diffère du comportement normal d'EMRFS, où un chargement partitionné se termine lorsqu'un tâche termine d'écrire un fichier donné. En raison de ces différences, si une JVM Spark Executor se bloque ou est mise hors service alors que des tâches sont en cours d'exécution et écrivent des données sur Amazon S3, ou si une JVM Spark Driver se bloque ou est mise hors service alors qu'une tâche est en cours d'exécution, les chargements partitionnés incomplets sont plus susceptibles d'être laissés derrière. Pour cette raison, lorsque vous utilisez le protocole de validation EMRFS optimisé pour S3, assurez-vous de suivre les bonnes pratiques de gestion de chargements partitionnés échoués. Pour plus d'informations, consultez [Bonnes pratiques](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-upload-s3.html#emr-bucket-bestpractices) pour travailler avec des compartiments Amazon S3 dans le *Guide de gestion Amazon EMR*. # Considérations de réglage de tâche Sur les exécuteurs Spark, le protocole de validation EMRFS optimisé pour S3 consomme une petite quantité de mémoire pour chaque fichier écrit par une tentative de tâche, jusqu'à ce que la tâche soit validée ou abandonnée. La quantité de mémoire consommée est négligeable dans la plupart des tâches. Sur les pilotes Spark, le protocole de validation optimisé pour EMRFS S3 nécessite de la mémoire pour stocker les informations de métadonnées de chaque fichier validé jusqu'à ce que la tâche soit validée ou abandonnée. Dans la plupart des tâches, le paramètre de mémoire par défaut du pilote Spark est négligeable. Pour les tâches qui ont des tâches de longue durée qui écrivent un grand nombre de fichiers, la mémoire que le protocole de validation consomme peut être perceptible et nécessiter des ajustements de la mémoire allouée pour Spark, en particulier pour les exécuteurs Spark. Vous pouvez régler la mémoire à l'aide de la propriété `spark.driver.memory` pour les pilotes Spark et de la propriété `spark.executor.memory` pour les exécuteurs Spark. Une seule tâche écrivant 100 000 fichiers nécessiterait en général environ 100 Mo de mémoire supplémentaire. Pour plus d'informations, consultez [Propriétés d'applications](https://spark.apache.org/docs/latest/configuration.html#application-properties) dans la Documentation de configuration Apache Spark. # Réessayer de demander Amazon S3 avec EMRFS Cette rubrique fournit des informations sur les stratégies de nouvelle tentative que vous pouvez utiliser lorsque vous envoyez des demandes à Amazon S3 avec EMRFS. Lorsque votre taux de demandes augmente, S3 essaie de s'adapter au nouveau taux. Au cours de ce processus, S3 peut limiter les demandes et renvoyer une erreur `503 Slow Down`. Pour améliorer le taux de réussite de vos demandes S3, vous pouvez ajuster votre stratégie de réessai en configurant les propriétés dans votre configuration `emrfs-site`. Vous pouvez ajuster votre stratégie de réessai de différentes manières. + Augmentez la limite maximale de tentatives pour la stratégie de backoff exponentiel par défaut. + Activez et configurez la stratégie de réessai additive-augmentation/diminution multiplicative (AIMD). AIMD est pris en charge pour Amazon EMR versions 6.4.0 et ultérieures. ## Utiliser la stratégie de backoff exponentiel par défaut Par défaut, EMRFS utilise une stratégie de backoff exponentiel pour réessayer les requêtes Amazon S3. La limite de tentatives EMRFS par défaut est de 15. Pour éviter une erreur S3 `503 Slow Down`, vous pouvez augmenter le nombre limite de tentatives lorsque vous créez un nouveau cluster, sur un cluster en cours d'exécution ou lors de l'exécution de l'application. Pour augmenter le nombre limite de tentatives, vous devez modifier la valeur de `fs.s3.maxRetries` dans votre configuration `emrfs-site`. L'exemple de configuration suivant définit `fs.s3.maxRetries` sur une valeur personnalisée de 30. ``` [ { "Classification": "emrfs-site", "Properties": { "fs.s3.maxRetries": "30" } } ] ``` Pour plus d'informations sur l'utilisation des objets de configuration, consultez [Configuration des applications](emr-configure-apps.md). ## Utiliser la stratégie de nouvelle tentative de l'AIMD Avec les versions 6.4.0 et ultérieures d'Amazon EMR, EMRFS prend en charge une stratégie de nouvelle tentative alternative basée sur un modèle d'augmentation/diminution multiplicative (AIMD). La stratégie de nouvelle tentative AIMD est particulièrement utile lorsque vous travaillez avec de grands clusters Amazon EMR. L'AIMD calcule un taux de demandes personnalisé en utilisant les données relatives aux récentes demandes réussies. Cette stratégie réduit le nombre de demandes limitées et le nombre total de tentatives requises par demande. Pour activer la stratégie de nouvelle tentative AIMD, vous devez définir la propriété `fs.s3.aimd.enabled` sur `true` dans votre configuration `emrfs-site`, comme dans l'exemple suivant. ``` [ { "Classification": "emrfs-site", "Properties": { "fs.s3.aimd.enabled": "true" } } ] ``` Pour plus d'informations sur l'utilisation des objets de configuration, consultez [Configuration des applications](emr-configure-apps.md). ## Paramètres de nouvelle tentative AIMD avancés Vous pouvez configurer les propriétés répertoriées dans le tableau suivant pour affiner le comportement des nouvelles tentatives lorsque vous utilisez la stratégie de nouvelle tentative AIMD. Dans la plupart des cas d'utilisation, nous vous recommandons d'utiliser les valeurs par défaut. **Propriétés avancées de la stratégie de nouvelle tentative AIMD** | Propriété | Valeur par défaut | Description | | --- | --- | --- | | fs.s3.aimd.increaseIncrement | 0.1 | Contrôle la rapidité avec laquelle le taux de demandes augmente lorsque des demandes consécutives aboutissent. | | fs.s3.aimd.reductionFactor | 2 | Contrôle la rapidité avec laquelle le taux de demandes diminue lorsqu'Amazon S3 renvoie une réponse 503. Le facteur par défaut de 2 réduit le taux de demandes de moitié. | | fs.s3.aimd.minRate | 0.1 | Définit la limite inférieure du taux de demandes lorsque les demandes sont soumises à une limitation soutenue par S3. | | fs.s3.aimd.initialRate | 5500 | Définit le taux de demande initial, qui change ensuite en fonction des valeurs que vous spécifiez pour fs.s3.aimd.increaseIncrement et fs.s3.aimd.reductionFactor.Le taux initial est également utilisé pour les requêtes GET et ajusté proportionnellement (3500/5500) pour les requêtes PUT. | | fs.s3.aimd.adjustWindow | 2 | Contrôle la fréquence à laquelle le taux de demandes est ajusté, mesuré en nombre de réponses. | | fs.s3.aimd.maxAttempts | 100 | Définit le nombre maximum de tentatives pour essayer une demande. | # Ajout d'une étape Spark Vous pouvez utiliser des étapes Amazon EMR pour envoyer des tâches à l'infrastructure Spark installée sur un cluster EMR. Pour plus d'informations, consultez [Étapes](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-overview.html#emr-overview-data-processing) dans le Guide de gestion d'Amazon EMR. Dans la console et l'interface de ligne de commande, vous faites cela en utilisant une étape d'application Spark, qui exécute le script `spark-submit` comme une étape en votre compte. Avec l'API, vous utilisez une étape pour appeler `spark-submit` à l'aide de `command-runner.jar`. Pour plus d'informations sur la soumission des applications à Spark, consultez la rubrique [Soumission d'applications](https://spark.apache.org/docs/latest/submitting-applications.html) dans la documentation Apache Spark. **Pour soumettre une étape Spark à l'aide de la console** 1. [Ouvrez la console Amazon EMR à l'adresse /emr. https://console.aws.amazon.com](https://console.aws.amazon.com/emr/) 1. Dans la **Liste de clusters**, choisissez le nom de votre cluster. 1. Faites défiler l'affichage jusqu'à la section **Étapes** et développez-la, puis choisissez **Ajouter une étape**. 1. Dans la boîte de dialogue **Ajouter une étape** : + Pour **Type d'étape**, choisissez **Spark application**. + Pour **Nom**, acceptez le nom par défaut (application Spark) ou saisissez un nouveau nom. + Pour le **Mode de déploiement**, choisissez **Client** ou **Cluster**. Le mode client lance le programme pilote sur l'instance principale du cluster, tandis que le mode cluster lance votre programme pilote sur le cluster. Pour le mode client, la sortie du journal du pilote apparaît dans les journaux d'étape, tandis que pour le mode cluster, la sortie du journal du pilote apparaît dans les journaux du premier conteneur YARN. Pour plus d'informations, consultez [Présentation du mode cluster](https://spark.apache.org/docs/latest/cluster-overview.html) dans la documentation Apache Spark. + Spécifiez le paramètre **Spark-submit options (Options Spark-envoi)** souhaité. Pour plus d'informations sur les options `spark-submit`, consultez [Lancement d'applications avec spark-submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit). + Pour **Application location (Emplacement d'application)**, spécifiez le chemin d'accès local d'URI local ou S3 de l'application. + Pour **Arguments**, laissez le champ vide. + Pour **Action sur échec**, acceptez l'option par défaut (**Continuer**). 1. Choisissez **Ajouter**. L'étape s'affiche dans la console avec le statut En suspens. 1. Le statut de l'étape passe de **Pending (En suspens)** à **Running (En cours d'exécution)** puis à **Completed (Terminé)**, au fur et à mesure de son exécution. Pour mettre à jour l'état, choisissez l'icône d'**Actualisation** au-dessus de la colonne **Actions**. 1. Les résultats de l'étape se trouvent sur la page Détails de cluster de la console Amazon EMR, à côté de l'étape elle-même et sous **Fichiers de journaux** si vous avez configuré la journalisation. Vous trouverez le cas échéant les informations sur l'étape dans le compartiment de journaux que vous avez configuré lorsque vous avez lancé le cluster. **Pour soumettre un travail à Spark à l'aide du AWS CLI** Soumettez une étape lorsque vous créez le cluster ou utilisez la sous-commande `aws emr add-steps` dans un cluster existant. 1. Utilisez `create-cluster` comme illustré dans l'exemple suivant. **Note** Les caractères de continuation de ligne Linux (\$1) sont inclus pour des raisons de lisibilité. Ils peuvent être supprimés ou utilisés dans les commandes Linux. Pour Windows, supprimez-les ou remplacez-les par un caret (^). ``` aws emr create-cluster --name "Add Spark Step Cluster" --release-label emr-7.12.0 --applications Name=Spark \ --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \ --steps Type=Spark,Name="Spark Program",ActionOnFailure=CONTINUE,Args=[--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/examples/jars/spark-examples.jar,10] --use-default-roles ``` Comme alternative, vous pouvez utiliser `command-runner.jar` comme illustré dans l'exemple suivant. ``` aws emr create-cluster --name "Add Spark Step Cluster" --release-label emr-7.12.0 \ --applications Name=Spark --ec2-attributes KeyName=myKey --instance-type m5.xlarge --instance-count 3 \ --steps Type=CUSTOM_JAR,Name="Spark Program",Jar="command-runner.jar",ActionOnFailure=CONTINUE,Args=[spark-example,SparkPi,10] --use-default-roles ``` **Note** Les caractères de continuation de ligne Linux (\$1) sont inclus pour des raisons de lisibilité. Ils peuvent être supprimés ou utilisés dans les commandes Linux. Pour Windows, supprimez-les ou remplacez-les par un caret (^). 1. Vous pouvez également ajouter des étapes à un cluster déjà en cours d'exécution. Utilisez `add-steps`. ``` aws emr add-steps --cluster-id j-2AXXXXXXGAPLF --steps Type=Spark,Name="Spark Program",ActionOnFailure=CONTINUE,Args=[--class,org.apache.spark.examples.SparkPi,/usr/lib/spark/examples/jars/spark-examples.jar,10] ``` Comme alternative, vous pouvez utiliser `command-runner.jar` comme illustré dans l'exemple suivant. ``` aws emr add-steps --cluster-id j-2AXXXXXXGAPLF --steps Type=CUSTOM_JAR,Name="Spark Program",Jar="command-runner.jar",ActionOnFailure=CONTINUE,Args=[spark-example,SparkPi,10] ``` **Pour soumettre un travail à Spark à l'aide du kit SDK pour Java** 1. L'exemple suivant montre comment ajouter une étape à un cluster avec Spark à l'aide de Java. ``` AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey); AmazonElasticMapReduce emr = new AmazonElasticMapReduceClient(credentials); StepFactory stepFactory = new StepFactory(); AmazonElasticMapReduceClient emr = new AmazonElasticMapReduceClient(credentials); AddJobFlowStepsRequest req = new AddJobFlowStepsRequest(); req.withJobFlowId("j-1K48XXXXXXHCB"); List stepConfigs = new ArrayList(); HadoopJarStepConfig sparkStepConf = new HadoopJarStepConfig() .withJar("command-runner.jar") .withArgs("spark-submit","--executor-memory","1g","--class","org.apache.spark.examples.SparkPi","/usr/lib/spark/examples/jars/spark-examples.jar","10"); StepConfig sparkStep = new StepConfig() .withName("Spark Step") .withActionOnFailure("CONTINUE") .withHadoopJarStep(sparkStepConf); stepConfigs.add(sparkStep); req.withSteps(stepConfigs); AddJobFlowStepsResult result = emr.addJobFlowSteps(req); ``` 1. Affichez les résultats de l'étape en examinant les journaux de l'étape. Vous pouvez le faire AWS Management Console si vous avez activé la journalisation en choisissant **Étapes**, en sélectionnant votre étape, puis, pour les **fichiers journaux**, en choisissant l'une `stdout` ou l'autre`stderr`. Choisissez **Afficher les journaux** pour afficher les journaux disponibles. ## Remplacement des paramètres de configuration par défaut de Spark Vous souhaiterez probablement remplacer les valeurs de configuration par défaut de Spark indépendamment pour chaque application. Vous pouvez faire cela lorsque vous soumettez des applications à l'aide d'une étape, ce qui transmet essentiellement des options à `spark-submit`. Par exemple, vous pouvez changer la mémoire allouée à un processus d'exécuteur en modifiant `spark.executor.memory`. Vous pouvez fournir le commutateur `--executor-memory` avec un argument tel que : ``` spark-submit --executor-memory 1g --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples.jar 10 ``` De même, vous pouvez ajuster `--executor-cores` et `--driver-memory`. Dans une étape, vous pouvez fournir les arguments suivants à l'étape : ``` --executor-memory 1g --class org.apache.spark.examples.SparkPi /usr/lib/spark/examples/jars/spark-examples.jar 10 ``` Vous pouvez également ajuster les paramètres qui n'ont peut-être pas de commutateur intégré à l'aide de l'option `--conf`. Pour plus d'informations sur les autres paramètres ajustables, consultez la rubrique [Chargement dynamique de propriétés Spark](https://spark.apache.org/docs/latest/configuration.html#dynamically-loading-spark-properties) dans la documentation Apache Spark. # Afficher l'historique de l'application Spark Vous pouvez consulter les détails de Spark, de l'application YARN et de l'interface utilisateur de Tez à l'aide de l'onglet **Interfaces utilisateur de l'application** de la page détaillée d'un cluster dans la console. Les interfaces utilisateur (UI) des applications Amazon EMR vous permettent de dépanner et d'analyser plus facilement les tâches actives et l'historique des tâches. Pour plus d'informations, consultez [Afficher l'historique de l'application](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-cluster-application-history.html) dans le *Guide de gestion Amazon EMR*. # Accédez au site Web Spark UIs Vous pouvez consulter le site Web Spark UIs en suivant les procédures pour créer un tunnel SSH ou créer un proxy dans la section intitulée « [Connect to the cluster](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node.html) » du guide de gestion Amazon EMR, puis en accédant au ResourceManager YARN correspondant à votre cluster. Choisissez le lien sous **Tracking UI (UI de suivi)** pour votre application. Si votre application est en cours d'exécution, vous voyez **ApplicationMaster**. Vous êtes dirigé vers l'interface utilisateur web du principal de l'application Spark sur le port 20888, quel que soit l'endroit où se trouve le pilote. Le pilote peut être situé sur le nœud primaire du cluster si vous l'exécutez en mode client YARN. Si vous exécutez une application en mode cluster YARN, le pilote se trouve dans le répertoire ApplicationMaster de l'application sur le cluster. Si votre application est terminée, **l'historique s'affiche**, qui vous permet d'accéder au numéro de port Spark HistoryServer UI 18080 du nœud principal du cluster EMR. Ceci s'applique aux applications déjà terminées. Vous pouvez également accéder à l' HistoryServer interface utilisateur de Spark directement à l'adresse http : *master-public-dns-name* //:18080/. Avec Amazon EMR version 5.25.0 et ultérieure, vous pouvez accéder à l'interface utilisateur du serveur d'historique Spark à partir de la console sans configurer un proxy web via une connexion SSH. Pour plus d'informations, consultez [Afficher les interfaces utilisateur d'application persistante](https://docs.aws.amazon.com/emr/latest/ManagementGuide/app-history-spark-UI.html). # Utilisation du connecteur Amazon Kinesis Data Streams pour le streaming structuré Spark Les versions 7.1.0 et supérieures d'Amazon EMR incluent un connecteur Amazon Kinesis Data Streams de streaming structuré Spark dans l'image de publication. Avec ce connecteur, vous pouvez utiliser Spark sur Amazon EMR pour traiter les données stockées dans Amazon Kinesis Data Streams. Le connecteur prend en charge à la fois les types de consommation `GetRecords` (débit partagé) et `SubscribeToShard` (ventilation améliorée). Cette intégration est basée sur le [https://github.com/awslabs/spark-sql-kinesis-connector](https://github.com/awslabs/spark-sql-kinesis-connector). Pour plus de détails sur la façon de commencer à utiliser le connecteur, consultez le [fichier README.](https://github.com/awslabs/spark-sql-kinesis-connector/blob/main/README.md) L'exemple suivant montre comment utiliser le connecteur pour lancer une application Spark avec Amazon EMR ``` spark-submit my_kinesis_streaming_script.py ``` # Utilisation de l'intégration d'Amazon Redshift pour Apache Spark avec Amazon EMR Avec Amazon EMR version 6.4.0 et versions ultérieures, chaque image de version inclut un connecteur entre [Apache Spark et Amazon Redshift](https://aws.amazon.com/emr/features/spark/). Avec ce connecteur, vous pouvez utiliser Spark sur Amazon EMR pour traiter les données stockées dans Amazon Redshift. Pour les versions 6.4.0 à 6.8.0 d'Amazon EMR, l'intégration est basée sur le [connecteur open source `spark-redshift`](https://github.com/spark-redshift-community/spark-redshift#readme). Pour les versions 6.9.0 et ultérieures d'Amazon EMR, l'[intégration Amazon Redshift pour Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) a été migrée de la version communautaire vers une intégration native. **Topics** + [Lancement d'une application Spark à l'aide de l'intégration Amazon Redshift pour Apache Spark](emr-spark-redshift-launch.md) + [Authentification avec l'intégration Amazon Redshift pour Apache Spark](emr-spark-redshift-auth.md) + [Lecture et écriture à partir de et vers Amazon Redshift](emr-spark-redshift-readwrite.md) + [Considérations et limites relatives à l’utilisation du connecteur Spark](emr-spark-redshift-considerations.md) # Lancement d'une application Spark à l'aide de l'intégration Amazon Redshift pour Apache Spark Pour les versions 6.4 à 6.9 d'Amazon EMR, vous devez utiliser l'option `--jars` ou `--packages` pour spécifier les fichiers JAR suivants que vous souhaitez utiliser. L'option `--jars` spécifie les dépendances stockées localement, dans HDFS ou à l'aide du protocole HTTP/S. Pour connaître les autres emplacements de fichiers pris en charge par l'option `--jars`, consultez la section [Gestion avancée des dépendances](https://spark.apache.org/docs/latest/submitting-applications.html#advanced-dependency-management) dans la documentation de Spark. L'option `--packages` spécifie les dépendances stockées dans le référentiel public de Maven. + `spark-redshift.jar` + `spark-avro.jar` + `RedshiftJDBC.jar` + `minimal-json.jar` Les versions 6.10.0 et supérieures d'Amazon EMR ne nécessitent pas la dépendance de `minimal-json.jar` et installent automatiquement les autres dépendances sur chaque cluster par défaut. Les exemples suivants montrent comment lancer une application Spark avec l'intégration Amazon Redshift pour Apache Spark. ------ #### [ Amazon EMR 6.10.0 \$1 ] L'exemple suivant montre comment lancer une application Spark avec le connecteur `spark-redshift` avec Amazon EMR versions 6.10 et supérieures. ``` spark-submit my_script.py ``` ------ #### [ Amazon EMR 6.4.0 - 6.9.x ] Pour lancer une application Spark avec le connecteur `spark-redshift` sur les versions 6.4 à 6.9 d'Amazon EMR, vous devez utiliser l'option `--jars` ou `--packages`, comme le montre l'exemple suivant. Notez que les chemins répertoriés avec l'option `--jars` sont les chemins par défaut des fichiers JAR. ``` spark-submit \ --jars /usr/share/aws/redshift/jdbc/RedshiftJDBC.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-redshift.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-avro.jar,/usr/share/aws/redshift/spark-redshift/lib/minimal-json.jar \ my_script.py ``` ------ # Authentification avec l'intégration Amazon Redshift pour Apache Spark ## Utilisation AWS Secrets Manager pour récupérer les informations d'identification et se connecter à Amazon Redshift L'exemple de code suivant montre comment récupérer les informations d'identification AWS Secrets Manager pour vous connecter à un cluster Amazon Redshift avec l' PySpark interface d'Apache Spark en Python. ``` from pyspark.sql import SQLContext import boto3 sc = # existing SparkContext sql_context = SQLContext(sc) secretsmanager_client = boto3.client('secretsmanager') secret_manager_response = secretsmanager_client.get_secret_value( SecretId='string', VersionId='string', VersionStage='string' ) username = # get username from secret_manager_response password = # get password from secret_manager_response url = "jdbc:redshift://redshifthost:5439/database?user=" + username + "&password=" + password # Read data from a table df = sql_context.read \ .format("io.github.spark_redshift_community.spark.redshift") \ .option("url", url) \ .option("dbtable", "my_table") \ .option("tempdir", "s3://path/for/temp/data") \ .load() ``` ## Utilisation d'IAM pour récupérer les informations d'identification et se connecter à Amazon Redshift Vous pouvez utiliser le JDBC version 2 fourni par Amazon Redshift pour vous connecter à Amazon Redshift avec le connecteur Spark. Pour utiliser Gestion des identités et des accès AWS (IAM), [configurez votre URL JDBC pour utiliser](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-iam-credentials-configure-jdbc-odbc.html) l'authentification IAM. Pour vous connecter à un cluster Redshift depuis Amazon EMR, vous devez donner à votre rôle IAM l'autorisation de récupérer des informations d'identification IAM temporaires. Attribuez les autorisations suivantes à votre rôle IAM pour qu'il puisse récupérer les informations d'identification et exécuter les opérations Amazon S3. + [Redshift : GetClusterCredentials](https://docs.aws.amazon.com/redshift/latest/APIReference/API_GetClusterCredentials.html) (pour les clusters Amazon Redshift provisionnés) + [Redshift : DescribeClusters](https://docs.aws.amazon.com/redshift/latest/APIReference/API_DescribeClusters.html) (pour les clusters Amazon Redshift provisionnés) + [Redshift : GetWorkgroup](https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_GetWorkgroup.html) (pour les groupes de travail Amazon Redshift Serverless) + [Redshift : GetCredentials](https://docs.aws.amazon.com/redshift-serverless/latest/APIReference/API_GetCredentials.html) (pour les groupes de travail Amazon Redshift Serverless) + [s3 : GetBucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_control_GetBucket.html) + [s3 : GetBucketLocation](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLocation.html) + [s3 : GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html) + [s3 : PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html) + [s3 : GetBucketLifecycleConfiguration](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html) Pour plus d'informations sur `GetClusterCredentials`, consultez [Stratégies de ressources pour `GetClusterCredentials`](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#redshift-policy-resources.getclustercredentials-resources). Vous devez également vous assurer qu'Amazon Redshift peut assumer le rôle IAM pendant les opérations `COPY` et `UNLOAD`. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "sts:AssumeRole" ], "Resource": "arn:aws:iam::123456789012:role/RedshiftServiceRole", "Sid": "AllowSTSAssumerole" } ] } ``` ------ L'exemple suivant utilise l'authentification IAM entre Spark et Amazon Redshift : ``` from pyspark.sql import SQLContext import boto3 sc = # existing SparkContext sql_context = SQLContext(sc) url = "jdbc:redshift:iam://redshift-host:redshift-port/db-name" iam_role_arn = "arn:aws:iam::account-id:role/role-name" # Read data from a table df = sql_context.read \ .format("io.github.spark_redshift_community.spark.redshift") \ .option("url", url) \ .option("aws_iam_role", iam_role_arn) \ .option("dbtable", "my_table") \ .option("tempdir", "s3a://path/for/temp/data") \ .mode("error") \ .load() ``` # Lecture et écriture à partir de et vers Amazon Redshift Les exemples de code suivants permettent de lire et PySpark d'écrire des exemples de données depuis et vers une base de données Amazon Redshift à l'aide de l'API de source de données et de SparkSQL. ------ #### [ Data source API ] PySpark À utiliser pour lire et écrire des exemples de données depuis et vers une base de données Amazon Redshift avec une API de source de données. ``` import boto3 from pyspark.sql import SQLContext sc = # existing SparkContext sql_context = SQLContext(sc) url = "jdbc:redshift:iam://redshifthost:5439/database" aws_iam_role_arn = "arn:aws:iam::accountID:role/roleName" df = sql_context.read \ .format("io.github.spark_redshift_community.spark.redshift") \ .option("url", url) \ .option("dbtable", "tableName") \ .option("tempdir", "s3://path/for/temp/data") \ .option("aws_iam_role", "aws_iam_role_arn") \ .load() df.write \ .format("io.github.spark_redshift_community.spark.redshift") \ .option("url", url) \ .option("dbtable", "tableName_copy") \ .option("tempdir", "s3://path/for/temp/data") \ .option("aws_iam_role", "aws_iam_role_arn") \ .mode("error") \ .save() ``` ------ #### [ SparkSQL ] PySpark À utiliser pour lire et écrire des exemples de données depuis et vers une base de données Amazon Redshift avec SparkSQL. ``` import boto3 import json import sys import os from pyspark.sql import SparkSession spark = SparkSession \ .builder \ .enableHiveSupport() \ .getOrCreate() url = "jdbc:redshift:iam://redshifthost:5439/database" aws_iam_role_arn = "arn:aws:iam::accountID:role/roleName" bucket = "s3://path/for/temp/data" tableName = "tableName" # Redshift table name s = f"""CREATE TABLE IF NOT EXISTS {tableName} (country string, data string) USING io.github.spark_redshift_community.spark.redshift OPTIONS (dbtable '{tableName}', tempdir '{bucket}', url '{url}', aws_iam_role '{aws_iam_role_arn}' ); """ spark.sql(s) columns = ["country" ,"data"] data = [("test-country","test-data")] df = spark.sparkContext.parallelize(data).toDF(columns) # Insert data into table df.write.insertInto(tableName, overwrite=False) df = spark.sql(f"SELECT * FROM {tableName}") df.show() ``` ------ # Considérations et limites relatives à l’utilisation du connecteur Spark + Nous vous recommandons d'activer le protocole SSL pour la connexion JDBC entre Spark sur Amazon EMR et Amazon Redshift. + À titre de bonne pratique, nous vous recommandons de gérer les informations d'identification du cluster Amazon Redshift dans AWS Secrets Manager . Voir [Utiliser AWS Secrets Manager pour récupérer les informations d'identification pour se connecter à Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration.html) pour un exemple. + Nous vous recommandons de transmettre un rôle IAM à l'aide du paramètre `aws_iam_role` pour le paramètre d'authentification Amazon Redshift. + L'URI `tempdir` renvoie à un emplacement Amazon S3. Ce répertoire temporaire n'est pas nettoyé automatiquement et peut donc entraîner des coûts supplémentaires. + Tenez compte des recommandations suivantes pour Amazon Redshift : + Nous vous recommandons de bloquer l'accès public au cluster Amazon Redshift. + Nous vous recommandons d'activer la [journalisation des audits d'Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/db-auditing.html). + Nous vous recommandons d'activer le [chiffrement au repos d'Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/security-server-side-encryption.html). + Tenez compte des recommandations suivantes pour Amazon S3 : + Nous vous recommandons de [bloquer l'accès public aux compartiments Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-control-block-public-access.html). + Nous vous recommandons d'utiliser le [chiffrement côté serveur Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html) pour chiffrer les compartiments Amazon S3 utilisés. + Nous vous recommandons d'utiliser les [politiques de cycle de vie d'Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html) pour définir les règles de conservation du compartiment Amazon S3. + Amazon EMR vérifie toujours le code importé à partir d'une source ouverte dans l'image. Pour des raisons de sécurité, nous ne prenons pas en charge les méthodes d'authentification suivantes de Spark vers Amazon S3 : + Configuration des clés AWS d'accès dans la classification `hadoop-env` de configuration + Encodage des clés AWS d'accès dans l'`tempdir`URI Pour plus d'informations sur l'utilisation du connecteur et les paramètres qu'il prend en charge, consultez les ressources suivantes : + [Intégration d'Amazon Redshift pour Apache Spark](https://docs.aws.amazon.com/redshift/latest/mgmt/spark-redshift-connector.html) dans le *Guide de gestion Amazon Redshift* + Le [référentiel communautaire `spark-redshift`](https://github.com/spark-redshift-community/spark-redshift#readme) sur Github # Historique des versions de Spark Le tableau suivant répertorie la version de Spark incluse dans chaque version d'Amazon EMR, ainsi que les composants installés avec l'application. Pour connaître les versions des composants de chaque version, consultez la rubrique Version des composants de votre version dans [Versions Amazon EMR 7.x](emr-release-7x.md), [Versions Amazon EMR 6.x](emr-release-6x.md) ou [Versions Amazon EMR 5.x](emr-release-5x.md). **Important** Apache Spark version 2.3.1, disponible à partir de la version 5.16.0 d'Amazon EMR, corrige [CVE-2018-8024](https://nvd.nist.gov/vuln/detail/CVE-2018-8024) et [CVE-2018-1334](https://nvd.nist.gov/vuln/detail/CVE-2018-1334). Nous vous recommandons de migrer les versions antérieures de Spark vers la version 2.3.1 ou ultérieure. **Informations sur la version de Spark** | Étiquette de version Amazon EMR | Version de Spark | Composants installés avec Spark | | --- | --- | --- | | emr-7,12.0 | 3,5,6-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.11.0 | 3,5,6-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-hdfs-zkfc, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.10.0 | 3,5,5-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.9.0 | 3,5,5-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7,8.0 | 3,5,4-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7,7.0 | 3.5.3-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.6.0 | 3.5.3-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.5.0 | 3.5.2-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.4.0 | 3.5.2-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.3.0 | 3.5.1-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.2.0 | 3.5.1-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.36.2 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.1.0 | 3.5.0-amzn-1 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-7.0.0 | 3.5.0-amzn-0 | delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.15.0 | 3.4.1-amzn-2 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.14.0 | 3.4.1-amzn-1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.13.0 | 3.4.1-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.12.0 | 3.4.0-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.11.1 | 3.3.2-amzn-0.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.11.0 | 3.3.2-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.10.1 | 3.3.1-amzn-0.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.10.0 | 3.3.1-amzn-0 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.9.1 | 3.3.0-amzn-1.1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.9.0 | 3.3.0-amzn-1 | aws-sagemaker-spark-sdk, delta, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.8.1 | 3.3.0-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.8.0 | 3.3.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.7.0 | 3.2.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.36.1 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.36.0 | 2.4.8-amzn-2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.6.0 | 3.2.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.35.0 | 2.4.8-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.5.0 | 3.1.2-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, iceberg, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.4.0 | 3.1.2-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.3.1 | 3.1.1-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.3.0 | 3.1.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.2.1 | 3.0.1-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.2.0 | 3.0.1-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.1.1 | 3.0.0-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.1.0 | 3.0.0-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.0.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-6.0.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.34.0 | 2.4.8-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.33.1 | 2.4.7-amzn-1.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.33.0 | 2.4.7-amzn-1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.32.1 | 2.4.7-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.32.0 | 2.4.7-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.31.1 | 2.4.6-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.31.0 | 2.4.6-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, hudi-spark, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.30.2 | 2.4.5-amzn-0.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.30.1 | 2.4.5-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.30.0 | 2.4.5-amzn-0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-notebook-env, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | mr-5.29.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.28.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.28.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, hudi, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.27.1 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.27.0 | 2.4.4 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.26.0 | 2.4.3 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.25.0 | 2.4.3 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.24.1 | 2.4.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.24.0 | 2.4.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.23.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.23.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.22.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.21.2 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.21.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.21.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.20.1 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.20.0 | 2.4.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.19.1 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.19.0 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.18.1 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.18.0 | 2.3.2 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, nginx, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.17.2 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.17.1 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.17.0 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, emr-s3-select, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.16.1 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.16.0 | 2.3.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.15.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.15.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.14.2 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.14.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.14.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.13.1 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.13.0 | 2.3.0 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, r, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.12.3 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.12.2 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.12.1 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.12.0 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.11.4 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.11.3 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.11.2 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.11.1 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.11.0 | 2.2.1 | aws-sagemaker-spark-sdk, emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.10.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.10.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, livy-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.9.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.9.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.8.3 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.8.2 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.8.1 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.8.0 | 2.2.0 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.7.1 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.7.0 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.6.1 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.6.0 | 2.1.1 | emrfs, emr-goodies, emr-ddb, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, hadoop-yarn-timeline-server, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.5.4 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.5.3 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.5.2 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.5.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.5.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.4.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.4.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.3.2 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.3.1 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.3.0 | 2.1.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.2.3 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.2.2 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.2.1 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.2.0 | 2.0.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.1.1 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.1.0 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.0.3 | 2.0.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.0.2 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.0.1 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-5.0.0 | 2.0.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.9.6 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.9.5 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.9.4 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.9.3 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.9.2 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.9.1 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.8.5 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.8.4 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.8.3 | 1.6.3 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.8.2 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.8.1 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.8.0 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.7.4 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.7.3 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.7.2 | 1.6.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.7.1 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.7.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-kms-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.6.1 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.6.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.5.0 | 1.6.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.4.0 | 1.6.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.3.0 | 1.6.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.2.0 | 1.5.2 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.1.0 | 1.5.0 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-library, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | | emr-4.0.0 | 1.4.1 | emrfs, emr-goodies, hadoop-client, hadoop-hdfs-datanode, hadoop-hdfs-namenode, hadoop-httpfs-server, hadoop-yarn-nodemanager, hadoop-yarn-resourcemanager, spark-client, spark-history-server, spark-on-yarn, spark-yarn-slave | # Utilisation de vues matérialisées avec Amazon EMR Les versions 7.12.0 et ultérieures d'Amazon EMR prennent en charge la création et la gestion de vues matérialisées Apache Iceberg dans le catalogue de données Glue. AWS Une vue matérialisée est une table gérée qui stocke le résultat précalculé d'une requête SQL au format Apache Iceberg et qui est mise à jour progressivement à mesure que les tables sources sous-jacentes changent. Vous pouvez utiliser des vues matérialisées pour simplifier les pipelines de transformation des données et accélérer les performances des requêtes pour les charges de travail analytiques complexes. Lorsque vous créez une vue matérialisée à l'aide de Spark sur Amazon EMR, la définition de la vue et les métadonnées sont stockées dans le catalogue de données AWS Glue. Les résultats précalculés sont stockés sous forme de tables Apache Iceberg dans des compartiments Amazon S3 Tables ou dans des compartiments à usage général Amazon S3 au sein de votre compte. AWS Le catalogue de données AWS Glue surveille automatiquement les tables sources et actualise les vues matérialisées à l'aide d'une infrastructure informatique gérée. **Topics** + [Comment fonctionnent les vues matérialisées avec Amazon EMR](#emr-spark-materialized-views-how-it-works) + [Conditions préalables](#emr-spark-materialized-views-prerequisites) + [Configuration de Spark pour utiliser des vues matérialisées](#emr-spark-materialized-views-configure) + [Création de vues matérialisées](#emr-spark-materialized-views-create) + [Interrogation de vues matérialisées](#emr-spark-materialized-views-query) + [Actualisation de vues matérialisées](#emr-spark-materialized-views-refresh) + [Gestion des vues matérialisées](#emr-spark-materialized-views-manage) + [Autorisations pour les vues matérialisées](#emr-spark-materialized-views-permissions) + [Surveillance des opérations de visualisation matérialisée](#emr-spark-materialized-views-monitoring) + [Exemple : flux de travail complet](#emr-spark-materialized-views-example) + [Considérations et restrictions](#emr-spark-materialized-views-limitations) ## Comment fonctionnent les vues matérialisées avec Amazon EMR Les vues matérialisées s'intègrent à Amazon EMR via le support Iceberg d'Apache Spark. Lorsque vous configurez votre session Spark pour utiliser le catalogue de données AWS Glue, vous pouvez créer des vues matérialisées à l'aide de la syntaxe SQL standard. L'optimiseur Spark peut automatiquement réécrire les requêtes pour utiliser des vues matérialisées lorsqu'elles offrent de meilleures performances, éliminant ainsi le besoin de modifier manuellement le code de l'application. Le catalogue de données AWS Glue gère tous les aspects opérationnels de la maintenance des vues matérialisées, notamment : + Détecter les modifications dans les tables sources à l'aide de la couche de métadonnées d'Apache Iceberg + Planification et exécution des opérations d'actualisation à l'aide du calcul géré par Spark + Déterminer s'il faut effectuer une actualisation complète ou incrémentielle en fonction des modifications apportées aux données + Stockage des résultats précalculés au format Apache Iceberg pour un accès multimoteur Vous pouvez interroger des vues matérialisées depuis Amazon EMR à l'aide des mêmes interfaces SQL Spark que celles que vous utilisez pour les tables classiques. Les données précalculées sont également accessibles depuis d'autres services, notamment Amazon Athena et Amazon Redshift. ## Conditions préalables Pour utiliser des vues matérialisées avec Amazon EMR, vous devez : + Un AWS compte + Un cluster Amazon EMR exécutant la version 7.12.0 ou ultérieure + Tables sources au format Apache Iceberg enregistrées dans le catalogue de données AWS Glue + AWS Autorisations de Lake Formation configurées pour les tables sources et les bases de données cibles + Un bucket S3 Tables ou un bucket S3 à usage général enregistré auprès de AWS Lake Formation pour le stockage de données de vues matérialisées ## Configuration de Spark pour utiliser des vues matérialisées Pour créer et gérer des vues matérialisées, configurez votre session Spark avec les extensions Iceberg et les paramètres de catalogue requis. La configuration varie selon que vos tables sources et vues matérialisées utilisent des compartiments S3 Tables ou des compartiments S3 à usage général. ### Configuration pour les tables S3 Lorsque vous utilisez des compartiments S3 Tables pour des vues matérialisées, configurez des références de catalogue distinctes pour vos tables sources et vos vues matérialisées : ``` spark-sql \ --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \ --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \ --conf spark.sql.catalog.glue_catalog.type=glue \ --conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \ --conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \ --conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \ --conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 \ --conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true \ --conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog \ --conf spark.sql.catalog.s3t_catalog.type=glue \ --conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket \ --conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 \ --conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true \ --conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse \ --conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 \ --conf spark.sql.defaultCatalog=s3t_catalog \ // turn on automatic query rewrite (optional) --conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true ``` ### Configuration pour les compartiments à usage général S3 Lorsque vous utilisez des buckets S3 à usage général, configurez une référence de catalogue unique : ``` spark-sql \ --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \ --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \ --conf spark.sql.catalog.glue_catalog.type=glue \ --conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \ --conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \ --conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \ --conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 \ --conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true \ --conf spark.sql.defaultCatalog=glue_catalog \ // turn on automatic query rewrite (optional) --conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true ``` ### Activation de l'actualisation incrémentielle Pour activer l'optimisation de l'actualisation incrémentielle, ajoutez les propriétés de configuration suivantes à votre session Spark : ``` spark-sql \ --conf spark.sql.optimizer.incrementalMVRefresh.enabled=true \ ``` ### Paramètres de configuration Les paramètres de configuration suivants contrôlent le comportement des vues matérialisées : + `spark.sql.extensions`— Active les extensions de session Iceberg Spark requises pour la prise en charge des vues matérialisées. + `spark.sql.optimizer.answerQueriesWithMVs.enabled`— Permet la réécriture automatique des requêtes pour utiliser des vues matérialisées. Définissez ce paramètre sur true pour activer cette optimisation. + `spark.sql.optimizer.incrementalMVRefresh.enabled`— Permet une optimisation de l'actualisation incrémentielle. Définissez cette valeur sur true pour traiter uniquement les données modifiées lors des opérations d'actualisation. ## Création de vues matérialisées Vous créez des vues matérialisées à l'aide de l'instruction SQL CREATE MATERIALIZED VIEW. La définition de la vue spécifie la logique de transformation sous la forme d'une requête SQL qui fait référence à une ou plusieurs tables sources. ### DLLs **Créer une vue** ``` { CREATE OR REPLACE MATERIALIZED VIEW | CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] } view_identifier [ view_clauses ] [ schedule_clauses ] AS [ select_statement ] view_clauses = { [ LOCATION location ] | [ PARTITIONED BY (col [, ...]) ] | [ COMMENT view_comment ] | [ SCHEDULE [ REFRESH ] schedule_clause ] } schedule_clause = { EVERY number { HOUR | HOURS | DAY | DAYS | WEEK | WEEKS } } ``` **Note** Les view\$1clauses doivent apparaître avant le select\$1statement. ### Création d'une vue matérialisée de base L'exemple suivant crée une vue matérialisée qui agrège les données de commande par client, utilise des noms de table complets avec une convention de dénomination en trois parties dans la définition de la vue : ``` CREATE MATERIALIZED VIEW customer_orders AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name; ``` ### Création d'une vue matérialisée avec actualisation automatique Pour configurer l'actualisation automatique, spécifiez un calendrier d'actualisation lors de la création de la vue en utilisant des noms de table complets avec une convention de dénomination en trois parties dans la définition de la vue : ``` CREATE MATERIALIZED VIEW customer_orders SCHEDULE REFRESH EVERY 1 HOUR AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name; ``` ### Création d'une vue matérialisée avec des références croisées à des catalogues Lorsque vos tables sources se trouvent dans un catalogue différent de celui de votre vue matérialisée, utilisez des noms de table complets avec une convention de dénomination en trois parties à la fois dans le nom de la vue et dans la définition de la vue : ``` CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name; ``` ## Interrogation de vues matérialisées Après avoir créé une vue matérialisée, vous pouvez l'interroger comme n'importe quelle autre table à l'aide des instructions SQL SELECT standard : ``` SELECT * FROM customer_orders; ``` ### Réécriture automatique des requêtes Lorsque la réécriture automatique des requêtes est activée, l'optimiseur Spark analyse vos requêtes et utilise automatiquement des vues matérialisées lorsqu'elles peuvent améliorer les performances. Par exemple, si vous exécutez la requête suivante : ``` SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name; ``` L'optimiseur Spark réécrit automatiquement cette requête pour utiliser la vue matérialisée customer\$1orders au lieu de traiter la table des commandes de base, à condition que la vue matérialisée soit à jour. ### Vérification de la réécriture automatique des requêtes Pour vérifier si une requête utilise la réécriture automatique des requêtes, utilisez la commande EXPLAIN EXTENDED : ``` EXPLAIN EXTENDED SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name; ``` Dans le plan d'exécution, recherchez le nom de la vue matérialisée dans l' BatchScanopération. Si le plan affiche BatchScan glue\$1catalog.analytics.customer\$1orders au lieu de glue\$1catalog.sales.orders, la requête a été automatiquement réécrite pour BatchScan utiliser la vue matérialisée. **Note** La réécriture automatique des requêtes nécessite du temps pour que le cache de métadonnées Spark soit rempli après la création d'une vue matérialisée. Ce processus se termine généralement en 30 secondes. ## Actualisation de vues matérialisées Vous pouvez actualiser les vues matérialisées à l'aide de deux méthodes : actualisation complète ou actualisation incrémentielle. L'actualisation complète recalcule l'intégralité de la vue matérialisée à partir de toutes les données de la table de base, tandis que l'actualisation incrémentielle traite uniquement les données modifiées depuis la dernière actualisation. ### Actualisation complète manuelle Pour actualiser complètement une vue matérialisée, procédez comme suit : ``` REFRESH MATERIALIZED VIEW customer_orders FULL; ``` Après avoir exécuté cette commande, interrogez la vue matérialisée pour vérifier les résultats mis à jour : ``` SELECT * FROM customer_orders; ``` ### Actualisation incrémentielle manuelle Pour effectuer une actualisation incrémentielle, assurez-vous que l'actualisation incrémentielle est activée dans la configuration de votre session Spark, puis exécutez : ``` REFRESH MATERIALIZED VIEW customer_orders; ``` Le catalogue de données AWS Glue détermine automatiquement si une actualisation incrémentielle est applicable en fonction de la définition de la vue et de la quantité de données modifiées. Si l'actualisation incrémentielle n'est pas possible, l'opération revient à une actualisation complète. ### Vérification de l'exécution de l'actualisation incrémentielle Pour vérifier que l'actualisation incrémentielle a bien été exécutée, vous pouvez vérifier les propriétés de la `lastRefreshType` table en exécutant les commandes suivantes : ``` SHOW TBLPROPERTIES ("lastRefreshType") ``` Cela peut également être réalisé en activant la journalisation du débogage en modifiant la configuration de votre journal Spark : 1. Ouvrez le fichier de configuration Spark log4j : ``` sudo vim /usr/lib/spark/conf/log4j2.properties ``` 1. Ajoutez les configurations d'enregistreur suivantes : ``` logger.spark.name = org.apache.spark.sql logger.spark.level = debug logger.inmemcache.name = org.apache.spark.sql.InMemMvMetadataCache logger.inmemcache.level = off ``` 1. Après avoir exécuté une opération d'actualisation, recherchez le message suivant dans la sortie de Spark : ``` DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh ``` ## Gestion des vues matérialisées Amazon EMR fournit des commandes SQL pour gérer le cycle de vie des vues matérialisées. ### Décrire une vue matérialisée Pour consulter les métadonnées relatives à une vue matérialisée, notamment sa définition, son état d'actualisation et l'horodatage de la dernière actualisation : ``` DESCRIBE EXTENDED customer_orders; ``` ### Modification d'une vue matérialisée Pour modifier le calendrier d'actualisation d'une vue matérialisée existante, procédez comme suit : ``` ALTER MATERIALIZED VIEW customer_orders ADD SCHEDULE REFRESH EVERY 2 HOURS; ``` Pour supprimer l'actualisation automatique, procédez comme suit : ``` ALTER MATERIALIZED VIEW customer_orders DROP SCHEDULE; ``` ### Supprimer une vue matérialisée Pour supprimer une vue matérialisée : ``` DROP MATERIALIZED VIEW customer_orders; ``` Cette commande supprime la définition de la vue matérialisée du catalogue de données AWS Glue et supprime les données de la table Iceberg sous-jacente de votre compartiment S3. ## Autorisations pour les vues matérialisées Pour créer et gérer des vues matérialisées, vous devez configurer les autorisations de AWS Lake Formation. Le rôle IAM qui crée la vue matérialisée (le rôle de définition) nécessite des autorisations spécifiques sur les tables sources et les bases de données cibles. ### Autorisations requises pour le rôle de définisseur Le rôle de définition doit disposer des autorisations Lake Formation suivantes : + Sur les tables sources : autorisations SELECT ou ALL sans filtres de ligne, de colonne ou de cellule + Sur la base de données cible : autorisation CREATE\$1TABLE + Sur le catalogue AWS de données Glue GetTable et les autorisations CreateTable d'API Lorsque vous créez une vue matérialisée, l'ARN du rôle de définition est stocké dans la définition de la vue. Le catalogue de données AWS Glue assume ce rôle lorsqu'il exécute des opérations d'actualisation automatique. Si le rôle de définition perd l'accès aux tables sources, les opérations d'actualisation échoueront tant que les autorisations ne seront pas restaurées. ### Octroi de l'accès aux vues matérialisées Pour autoriser d'autres utilisateurs à interroger une vue matérialisée, utilisez AWS Lake Formation pour accorder l'autorisation SELECT sur la table des vues matérialisées. Les utilisateurs peuvent interroger la vue matérialisée sans avoir besoin d'accéder directement aux tables sources sous-jacentes. Pour des informations détaillées sur la configuration des autorisations de Lake Formation, consultez la section Octroi et révocation d'autorisations sur les ressources du catalogue de données dans le guide du développeur de AWS Lake Formation. ## Surveillance des opérations de visualisation matérialisée Le AWS Glue Data Catalog publie des statistiques et des journaux pour les opérations d'actualisation des vues matérialisées sur Amazon CloudWatch. Vous pouvez surveiller l'état, la durée et le volume de données traités par le biais de CloudWatch métriques d'actualisation. ### Affichage des métriques d'actualisation Pour consulter les mesures d'actualisation des vues matérialisées : 1. Ouvrez la CloudWatch console. 1. Choisissez Metrics dans le volet de navigation. 1. Sélectionnez l'espace de noms Glue. 1. Filtrez les métriques en fonction du nom de la vue matérialisée. ### Configuration des alarmes Pour recevoir des notifications lorsque les opérations d'actualisation échouent ou dépassent la durée prévue, créez des CloudWatch alarmes sur les métriques des vues matérialisées. Vous pouvez également configurer les EventBridge règles Amazon pour déclencher des réponses automatisées afin d'actualiser les événements. ## Exemple : flux de travail complet L'exemple suivant illustre un flux de travail complet pour créer et utiliser une vue matérialisée sur Amazon EMR. 1. Connectez-vous au nœud principal de votre cluster EMR via SSH. 1. Créez une table de base avec des exemples de données : ``` spark-sql \ --conf spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions \ --conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog \ --conf spark.sql.catalog.glue_catalog.type=glue \ --conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse \ --conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 \ --conf spark.sql.catalog.glue_catalog.glue.id=111122223333 \ --conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 \ --conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true \ --conf spark.sql.defaultCatalog=glue_catalog \ --conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true CREATE DATABASE IF NOT EXISTS sales; USE sales; CREATE TABLE orders ( id INT, customer_name STRING, amount DECIMAL(10,2), order_date DATE ); INSERT INTO orders VALUES (1, 'John Doe', 150.00, DATE('2024-01-15')), (2, 'Jane Smith', 200.50, DATE('2024-01-16')), (3, 'Bob Johnson', 75.25, DATE('2024-01-17')); ``` 1. Créez une vue matérialisée : ``` CREATE MATERIALIZED VIEW customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name; ``` 1. Interrogez la vue matérialisée : ``` SELECT * FROM customer_summary; ``` 1. Insérez des données supplémentaires dans le tableau de base : ``` INSERT INTO orders VALUES (4, 'Jane Smith', 350.00, DATE('2024-01-18')), (5, 'Bob Johnson', 100.25, DATE('2024-01-19')); ``` 1. Actualisez la vue matérialisée : ``` REFRESH MATERIALIZED VIEW customer_summary FULL; ``` 1. Vérifiez les résultats mis à jour : ``` SELECT * FROM customer_summary; ``` ## Considérations et restrictions Tenez compte des points suivants lorsque vous utilisez des vues matérialisées avec Amazon EMR : + Les vues matérialisées nécessitent la version 7.12.0 ou ultérieure d'Amazon EMR. + Les tables sources doivent être des tables Apache Iceberg enregistrées dans le catalogue de données AWS Glue. Les tables Apache Hive, Apache Hudi et Linux Foundation Delta Lake ne sont pas prises en charge au lancement. + Les tables sources doivent résider dans la même AWS région et dans le même AWS compte que la vue matérialisée. + Toutes les tables sources doivent être régies par AWS Lake Formation. Les autorisations IAM uniquement et l'accès hybride ne sont pas pris en charge. + Les vues matérialisées ne peuvent pas faire référence aux vues AWS Glue Data Catalog, aux vues multidialectes ou à d'autres vues matérialisées en tant que tables sources. + Le rôle de définition de vues doit disposer d'un accès complet en lecture (autorisation SELECT ou ALL) sur toutes les tables sources sans appliquer de filtres de ligne, de colonne ou de cellule. + Les vues matérialisées sont finalement cohérentes avec les tables sources. Pendant la fenêtre d'actualisation, les requêtes peuvent renvoyer des données périmées. Exécutez une actualisation manuelle pour une cohérence immédiate. + L'intervalle d'actualisation automatique minimum est d'une heure. + L'actualisation incrémentielle prend en charge un sous-ensemble restreint d'opérations SQL. La définition de la vue doit être un seul bloc SELECT-FROM-WHERE-GROUP BY-HAVING et ne peut pas contenir d'opérations définies, de sous-requêtes, le mot clé DISTINCT dans SELECT ou de fonctions d'agrégation, de fonctions de fenêtre ou de jointures autres que INNER JOIN. + L'actualisation incrémentielle ne prend pas en charge les fonctions définies par l'utilisateur ni certaines fonctions intégrées. Seul un sous-ensemble des fonctions intégrées de Spark SQL est pris en charge. + La réécriture automatique des requêtes ne prend en compte que les vues matérialisées dont les définitions appartiennent à un sous-ensemble SQL restreint similaire aux restrictions d'actualisation incrémentielle. + Les opérations d'actualisation complète remplacent l'intégralité du tableau et rendent les instantanés précédents indisponibles. + Les identifiants contenant des caractères spéciaux autres que des caractères alphanumériques et des traits de soulignement ne sont pas pris en charge dans les requêtes CREATE MATERIALIZED VIEW. + Les colonnes de vues matérialisées commençant par le préfixe \$1\$1ivm sont réservées à l'utilisation du système. AWS se réserve le droit de modifier ou de supprimer ces colonnes dans les futures versions. + Les clauses SORT BY, LIMIT, OFFSET, CLUSTER BY et ORDER BY ne sont pas prises en charge dans les définitions de vues matérialisées. + Les tables sources entre régions et entre comptes ne sont pas prises en charge. + Les fonctions non déterministes telles que rand () ou current\$1timestamp () ne sont pas prises en charge dans les définitions de vues matérialisées.