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. # Utilisation d’Apache Spark dans Amazon Athena Amazon Athena facilite l'exécution interactive de l'analyse et de l'exploration des données à l'aide d'Apache Spark sans qu'il soit nécessaire de planifier, de configurer ou de gérer les ressources. Exécuter des applications Apache Spark sur Athena signifie soumettre du code Spark pour traitement et recevoir directement les résultats sans avoir besoin de configuration supplémentaire. Apache Spark fonctionne sur Amazon Athena sans serveur et offre une mise à l'échelle automatique et à la demande qui permet d'obtenir un calcul instantané pour répondre à l'évolution des volumes de données et des exigences de traitement. Dans la version finale[PySpark version du moteur 3](notebooks-spark-release-versions.md#notebooks-spark-release-versions-pyspark-3), vous pouvez utiliser l'expérience de bloc-notes simplifiée de la console Amazon Athena pour développer des applications Apache Spark à l'aide de Python ou d'Athena Notebook. APIs Dans la version finale[Apache Spark version 3.5](notebooks-spark-release-versions.md#notebooks-spark-release-versions-spark-35), vous pouvez exécuter du code Spark à partir de blocs-notes Amazon SageMaker Unified Studio ou de vos clients compatibles Spark Connect préférés. Amazon Athena offre les fonctionnalités suivantes : + **Utilisation de la console** — Soumettez vos applications Spark depuis la console Amazon Athena (version 3 de Pyspark Enginer uniquement). + **Création de scripts** – Créez et déboguez rapidement et de manière interactive des applications Apache Spark en Python. + **Dimensionnement dynamique** – Amazon Athena détermine automatiquement les ressources de calcul et de mémoire nécessaires à l'exécution d'une tâche et adapte en permanence ces ressources en conséquence jusqu'aux maximums que vous spécifiez. Ce dimensionnement dynamique réduit le coût sans affecter la vitesse. + **Expérience avec les blocs-notes** : utilisez les blocs-notes Amazon SageMaker AI Unified Studio pour créer, modifier et exécuter des calculs à l'aide d'une interface familière. Dans la version 3 du moteur Pyspark, vous pouvez utiliser les blocs-notes intégrés à la console Athena compatibles avec les ordinateurs portables Jupyter et contenant une liste de cellules exécutées dans l'ordre sous forme de calculs. Le contenu des cellules peut inclure du code, du texte, du Markdown, des mathématiques, des diagrammes et des médias enrichis. Pour plus d’informations, consultez les articles [Run Spark SQL on Amazon Athena Spark](https://aws.amazon.com/blogs/big-data/run-spark-sql-on-amazon-athena-spark/) et [Explore your data lake using Amazon Athena for Apache Spark](https://aws.amazon.com/blogs/big-data/explore-your-data-lake-using-amazon-athena-for-apache-spark/) sur le blog *AWS  Big Data Blog*. **Topics** + [Versions](notebooks-spark-release-versions.md) + [Considérations et restrictions](notebooks-spark-considerations-and-limitations.md) + [Mise en route](notebooks-spark-getting-started.md) + [Gestion des fichiers de bloc-notes](notebooks-spark-managing.md) + [Éditeur de bloc-notes](notebooks-spark-editor.md) + [Formats de table autres que Hive](notebooks-spark-table-formats.md) + [Prise en charge de la bibliothèque Python](notebooks-spark-python-library-support.md) + [Spécification d’une configuration personnalisée](notebooks-spark-custom-jar-cfg.md) + [Formats de données et de stockage pris en charge](notebooks-spark-data-and-storage-formats.md) + [Surveiller Apache Spark](notebooks-spark-metrics.md) + [Attribution des coûts](notebooks-spark-cost-attribution.md) + [Journalisation et surveillance](notebooks-spark-logging-monitoring.md) + [Accès à l'interface utilisateur Spark](notebooks-spark-ui-access.md) + [Spark Connect](notebooks-spark-connect.md) + [Activation des compartiments de type Paiement par le demandeur](notebooks-spark-requester-pays.md) + [Intégration de Lake Formation](notebooks-spark-lakeformation.md) + [Activation du chiffrement Spark](notebooks-spark-encryption.md) + [Accès intercompte au catalogue](spark-notebooks-cross-account-glue.md) + [Quotas de service](notebooks-spark-quotas.md) + [Athena Spark APIs](notebooks-spark-api-list.md) + [Dépannage](notebooks-spark-troubleshooting.md) # Versions Amazon Athena pour Apache Spark propose les versions de version suivantes : ## PySpark version du moteur 3 PySpark la version 3 inclut la version 3.2.1 d'Apache Spark. Avec cette version, vous pouvez exécuter du code Spark dans les blocs-notes intégrés à la console Athena. ## Apache Spark version 3.5 La version 3.5 d'Apache Spark est basée sur Amazon EMR 7.12 et intègre Apache Spark version 3.5.6. Avec cette version, vous pouvez exécuter du code Spark à partir du bloc-notes Amazon SageMaker AI Unified Studio ou de vos clients Spark compatibles préférés. Cette version ajoute des fonctionnalités clés pour améliorer l'expérience des charges de travail interactives : + **Secure Spark Connect** : ajoute Spark Connect en tant que point de AWS terminaison authentifié et autorisé. + **Attribution des coûts au niveau de la session** : les utilisateurs peuvent suivre les coûts par session interactive dans AWS Cost Explorer ou dans les rapports sur les coûts et l'utilisation. Pour de plus amples informations, veuillez consulter [Attribution des coûts au niveau de la session](notebooks-spark-cost-attribution.md). + Capacités de **débogage avancées** — Ajoute la prise en charge de l'interface utilisateur Spark en direct et du serveur Spark History pour le débogage des charges de travail à la fois depuis les ordinateurs portables et depuis APIs les ordinateurs portables. Pour de plus amples informations, veuillez consulter [Accès à l'interface utilisateur de Spark](notebooks-spark-ui-access.md#notebooks-spark-ui-access-methods). + prise en **charge de l'accès non filtré** : accédez aux tables de catalogue de AWS Glue données protégées pour lesquelles vous disposez d'autorisations complètes. Pour de plus amples informations, veuillez consulter [Utilisation de Lake Formation avec les groupes de travail Athena Spark](notebooks-spark-lakeformation.md). ### Propriétés par défaut de Spark Le tableau suivant répertorie les propriétés Spark et leurs valeurs par défaut appliquées aux sessions Athena SparkConnect . | Clé | Valeur par défaut | Description | | --- | --- | --- | | `spark.app.id` | `` | Cela n'est pas modifiable. | | `spark.app.name` | `default` | | | `spark.driver.cores` | `4` | Le nombre de cœurs utilisés par le pilote. Ceci n'est pas modifiable lors du lancement initial. | | `spark.driver.memory` | `10g` | Quantité de mémoire utilisée par chaque pilote. Ceci n'est pas modifiable lors du lancement initial. | | `spark.driver.memoryOverhead` | `6g` | Quantité de charge de mémoire affectée aux charges de travail Python et aux autres processus exécutés sur le pilote. Ceci n'est pas modifiable lors du lancement initial. | | `spark.cortex.driver.disk` | `64g` | Le disque du pilote Spark. Ceci n'est pas modifiable lors du lancement initial. | | `spark.executor.cores` | `4` | Le nombre de cœurs utilisés par chaque exécuteur. Ceci n'est pas modifiable lors du lancement initial. | | `spark.executor.memory` | `10g` | Quantité de mémoire utilisée par chaque pilote. | | `spark.executor.memoryOverhead` | `6g` | Quantité de charge de mémoire affectée aux charges de travail Python et aux autres processus exécutés sur l'exécuteur. Ceci n'est pas modifiable lors du lancement initial. | | `spark.cortex.executor.disk` | `64g` | Le disque exécuteur Spark. Ceci n'est pas modifiable lors du lancement initial. | | `spark.cortex.executor.architecture` | `AARCH_64` | Architecture de l'exécuteur testamentaire. | | `spark.driver.extraJavaOptions` | `-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false` | Options Java supplémentaires pour le pilote Spark. Ceci n'est pas modifiable lors du lancement initial. | | `spark.executor.extraJavaOptions` | `-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false` | Options Java supplémentaires pour l'exécuteur Spark. Ceci n'est pas modifiable lors du lancement initial. | | `spark.executor.instances` | `1` | Nombre de conteneurs d'exécuteurs Spark à allouer. | | `spark.dynamicAllocation.enabled` | `TRUE` | Option qui active l'allocation dynamique des ressources. Cette option augmente ou diminue le nombre d'exécuteurs enregistrés auprès de l'application, en fonction de la charge de travail. | | `spark.dynamicAllocation.minExecutors` | `0` | Limite inférieure du nombre d'exécuteurs si vous activez l'allocation dynamique. | | `spark.dynamicAllocation.maxExecutors` | `59` | Limite supérieure du nombre d'exécuteurs si vous activez l'allocation dynamique. | | `spark.dynamicAllocation.initialExecutors` | `1` | Le nombre initial d'exécuteurs à exécuter si vous activez l'allocation dynamique. | | `spark.dynamicAllocation.executorIdleTimeout` | `60s` | Durée pendant laquelle un exécuteur peut rester inactif avant que Spark ne le supprime. Cela ne s'applique que si vous activez l'allocation dynamique. | | `spark.dynamicAllocation.shuffleTracking.enabled` | `TRUE` | L'activation du DRA nécessite l'activation du suivi du shuffle. | | `spark.dynamicAllocation.sustainedSchedulerBacklogTimeout` | `1s` | Le délai d'attente définit la durée pendant laquelle le planificateur Spark doit observer un arriéré prolongé de tâches en attente avant de déclencher une demande au gestionnaire du cluster pour lancer de nouveaux exécuteurs. | | `spark.sql.catalogImplementation` | `hive` | | | `spark.hadoop.hive.metastore.client.factory.class` | `com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory` | La classe d'implémentation du AWS Glue metastore. | | `spark.hadoop.hive.metastore.glue.catalogid` | `` | AWS Glue AccountID du catalogue. | | `spark.sql.hive.metastore.sharedPrefixes` | `software.amazon.awssdk.services.dynamodb` | La propriété spécifie une liste séparée par des virgules de préfixes de package pour les classes qui doivent être chargées par l'application ClassLoader plutôt que la liste isolée ClassLoader créée pour le code du client Hive Metastore. | | `spark.hadoop.fs.s3.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Définit l'implémentation permettant au client S3 d'utiliser S3A. | | `spark.hadoop.fs.s3a.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Définit l'implémentation pour le client S3A (S3A). | | `spark.hadoop.fs.s3n.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Définit l'implémentation pour que le client S3 natif (S3N) utilise S3A. | | `spark.hadoop.fs.AbstractFileSystem.s3.impl` | `org.apache.hadoop.fs.s3a.S3A` | | | `spark.hadoop.fs.s3a.aws.credentials.provider` | `software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider` | | | `spark.hadoop.fs.s3.customAWSCredentialsProvider` | `com.amazonaws.auth.DefaultAWSCredentialsProviderChain` | | | `spark.hadoop.mapreduce.output.fs.optimized.committer.enabled` | `TRUE` | Cette propriété active un protocole de validation optimisé pour les tâches Spark lors de l'écriture de données sur Amazon S3. Lorsqu'il est défini sur true, il permet à Spark d'éviter les coûteuses opérations de renommage de fichiers, ce qui se traduit par des écritures atomiques plus rapides et plus fiables par rapport au committer Hadoop par défaut. | | `spark.hadoop.fs.s3a.endpoint.region` | `` | Cette configuration définit explicitement la AWS région du compartiment Amazon S3 accessible via le client S3A. | | `spark.hadoop.fs.s3.getObject.initialSocketTimeoutMilliseconds` | `2000` | Cela indique le délai d'expiration de la connexion au socket en millisecondes. | | `spark.hadoop.fs.s3a.committer.magic.enabled` | `TRUE` | Cela active le S3A « Magic » Committer, un protocole de validation très performant mais spécifique qui repose sur la prise en charge des chemins spéciaux par le gestionnaire de cluster sous-jacent. | | `spark.hadoop.fs.s3a.committer.magic.track.commits.in.memory.enabled` | `TRUE` | Pertinent uniquement lorsque le Magic Committer est activé, cela indique si la liste des fichiers validés par une tâche doit être suivie en mémoire au lieu d'être écrite sur des fichiers de disque temporaires. | | `spark.hadoop.fs.s3a.committer.name` | `magicv2` | Ce paramètre sélectionne explicitement l'algorithme S3A Output Committer spécifique à utiliser (par exemple, directory, partitioned ou magic). En spécifiant le nom, vous choisissez la stratégie qui gère les données temporaires, gère les échecs de tâches et effectue la validation atomique finale sur le chemin Amazon S3 cible. | | `spark.hadoop.fs.s3.s3AccessGrants.enabled` | `FALSE` | La propriété permet de prendre en charge les subventions d'accès Amazon S3 lors de l'accès aux données Amazon S3 via le client du système de fichiers S3A/EMRFS. | | `spark.hadoop.fs.s3.s3AccessGrants.fallbackToIAM` | `FALSE` | Lorsque les autorisations d'accès Amazon S3 sont activées, cette propriété détermine si le client Amazon S3 doit revenir aux informations d'identification IAM traditionnelles si la recherche des autorisations d'accès échoue ou ne fournit pas les autorisations suffisantes. | | `spark.pyspark.driver.python` | `/usr/bin/python3.11` | Chemin Python pour le pilote. | | `spark.pyspark.python` | `/usr/bin/python3.11` | Chemin Python pour l'exécuteur. | | `spark.python.use.daemon` | `TRUE` | Cette configuration contrôle si Spark utilise un processus démon de travail Python sur chaque exécuteur. Lorsqu'il est activé (vrai, valeur par défaut), l'exécuteur maintient le programme de travail Python en vie entre les tâches afin d'éviter la surcharge liée au lancement et à l'initialisation répétés d'un nouvel interpréteur Python pour chaque tâche, ce qui améliore considérablement les performances des PySpark applications. | | `spark.sql.execution.arrow.pyspark.enabled` | `TRUE` | Permet d'utiliser Apache Arrow pour optimiser le transfert de données entre les processus JVM et Python dans PySpark. | | `spark.sql.execution.arrow.pyspark.fallback.enabled` | `TRUE` | Propriété de configuration qui contrôle le comportement de Spark en cas d'erreur lors du transfert de données entre la JVM et Python à l'aide de l'optimisation Apache Arrow. | | `spark.sql.parquet.fs.optimized.committer.optimization-enabled` | `TRUE` | Propriété de configuration qui contrôle si Spark utilise un validateur de fichiers optimisé lors de l'écriture de fichiers Parquet dans certains systèmes de fichiers, en particulier les systèmes de stockage cloud tels qu'Amazon S3. | | `spark.sql.parquet.output.committer.class` | `com.amazon.emr.committer.EmrOptimizedSparkSqlParquetOutputCommitter` | Propriété de configuration Spark qui spécifie le nom de classe complet du Hadoop OutputCommitter à utiliser lors de l'écriture de fichiers Parquet. | | `spark.resourceManager.cleanupExpiredHost` | `TRUE` | Cette propriété contrôle si le pilote nettoie activement les ressources de l'application Spark associées aux exécuteurs exécutés sur des nœuds supprimés ou expirés. | | `spark.blacklist.decommissioning.enabled` | `TRUE` | La propriété permet à la logique de Spark de mettre automatiquement sur liste noire les exécuteurs actuellement en cours de mise hors service (arrêt progressif) par le gestionnaire de cluster. Cela empêche le planificateur d'envoyer de nouvelles tâches aux exécuteurs sur le point de quitter, ce qui améliore la stabilité des tâches lors de la réduction des ressources. | | `spark.blacklist.decommissioning.timeout` | `1h` | Durée maximale pendant laquelle Spark attendra qu'une tâche soit migrée avec succès depuis un exécuteur hors service avant de mettre l'hôte sur liste noire. | | `spark.stage.attempt.ignoreOnDecommissionFetchFailure` | `TRUE` | Demande à Spark d'être indulgent et de ne pas échouer une tentative d'étape complète si un échec de récupération survient lors de la lecture des données de shuffle depuis un exécuteur en cours de mise hors service. L'échec de récupération est considéré comme réparable, et Spark récupérera à nouveau les données depuis un autre emplacement (ce qui peut nécessiter un nouveau calcul), en donnant la priorité à l'achèvement du travail plutôt qu'à une gestion stricte des erreurs lors des arrêts progressifs. | | `spark.decommissioning.timeout.threshold` | `20` | Cette propriété est généralement utilisée en interne ou dans des configurations de gestionnaires de clusters spécifiques pour définir la durée totale maximale que Spark attend du processus de mise hors service d'un hôte. Si le temps de mise hors service réel dépasse ce seuil, Spark peut prendre des mesures agressives, comme mettre l'hôte sur liste noire ou demander la résiliation forcée, pour libérer la ressource. | | `spark.files.fetchFailure.unRegisterOutputOnHost` | `TRUE` | Lorsqu'une tâche ne parvient pas à récupérer les données shuffle ou RDD d'un hôte spécifique, la définition de cette valeur sur true indique à Spark de désenregistrer tous les blocs de sortie associés à l'application défaillante sur cet hôte. Cela empêche les tâches futures de tenter de récupérer des données depuis un hôte peu fiable, forçant Spark à recalculer les blocs nécessaires ailleurs et augmentant la robustesse des tâches face aux problèmes de réseau intermittents. | # Considérations et restrictions ## Apache Spark version 3.5 Voici les considérations et les limites relatives à la version finale d'Apache Spark version 3.5 : + Cette version est disponible dans les versions suivantes Régions AWS : + Asie-Pacifique (Mumbai) + Asie-Pacifique (Séoul) + Asie-Pacifique (Singapour) + Asie-Pacifique (Sydney) + Asie-Pacifique (Tokyo) + Canada (Centre) + Europe (Francfort) + Europe (Irlande) + Europe (Londres) + Europe (Paris) + Europe (Stockholm) + Amérique du Sud (São Paulo) + USA Est (Virginie du Nord) + USA Est (Ohio) + USA Ouest (Oregon) + Cette version du moteur ne prend pas en charge les blocs-notes intégrés à la console ou les blocs-notes Athena. APIs Cette version est plutôt intégrée aux blocs-notes Amazon SageMaker AI Unified Studio. Vous pouvez également utiliser des clients Spark Connect compatibles. + Les calculs APIs - `ListCalculationExecutions` et `StartCalculationExecution``GetCalculationExecution`, ne sont pas pris en charge dans cette version. + Vous ne pouvez pas mettre à niveau un groupe de travail de la version 3 PySpark du moteur vers la version 3.5 d'Apache Spark. ## Version 3 du moteur Pyspark Voici les considérations et les limites relatives à la version finale du moteur Pyspark version 3 : + Cette version est disponible dans les versions suivantes Régions AWS : + Asie-Pacifique (Mumbai) + Asie-Pacifique (Singapour) + Asie-Pacifique (Sydney) + Asie-Pacifique (Tokyo) + Europe (Francfort) + Europe (Irlande) + USA Est (Virginie du Nord) + USA Est (Ohio) + USA Ouest (Oregon) + AWS Lake Formation n'est pas pris en charge. + Les tables qui utilisent la projection de partitions ne sont pas prises en charge. + Les groupes de travail compatibles avec Apache Spark peuvent utiliser l'éditeur de bloc-notes Athena, mais pas l'éditeur de requêtes Athena. Seuls les groupes de travail Athena SQL peuvent utiliser l'éditeur de requêtes Athena. + Les requêtes de vue inter-moteurs ne sont pas prises en charge. Les vues créées par Athena SQL ne sont pas interrogeables par Athena pour Spark. Les vues des deux moteurs étant implémentées différemment, elles ne sont pas compatibles pour une utilisation inter-moteurs. + MLlib (bibliothèque d'apprentissage automatique Apache Spark) et le `pyspark.ml` package ne sont pas pris en charge. Pour obtenir la liste des bibliothèques Python prises en charge, voir [Liste des bibliothèques Python préinstallées](notebooks-spark-preinstalled-python-libraries.md). + `pip install` n’est actuellement pas pris en charge dans les sessions Athena pour Spark. + Une seule session active par bloc-notes est autorisée. + Lorsque plusieurs utilisateurs utilisent la console pour ouvrir une session existante dans un groupe de travail, ils accèdent au même bloc-notes. Pour éviter toute confusion, n’ouvrez que les sessions que vous créez vous-même. + Les domaines d'hébergement pour les applications Apache Spark que vous pouvez utiliser avec Amazon Athena (par exemple `analytics-gateway.us-east-1.amazonaws.com`) sont enregistrés dans la [liste des suffixes publics (PSL)](https://publicsuffix.org/list/public_suffix_list.dat) Internet. Si vous devez définir des cookies sensibles dans vos domaines, nous vous recommandons d'utiliser des cookies avec un préfixe `__Host-` pour protéger votre domaine contre les tentatives CSRF (cross-site request forgery). Pour plus d'informations, veuillez consulter la page [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) de la documentation pour les développeurs de Mozilla.org (langue française non garantie). + Pour plus d'informations sur la résolution des problèmes liés aux blocs-notes, sessions et groupes de travail Spark dans Athena, voir [Résolution des problèmes liés à Athena pour Spark](notebooks-spark-troubleshooting.md). # Prise en main d’Apache Spark dans Amazon Athena **Note** Pour la version finale d'Apache Spark version 3.5, suivez le guide de démarrage dans [SageMaker Notebooks](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html). Utilisez ce guide pour la version finale du moteur Pyspark version 3. Pour commencer à utiliser Apache Spark sur Amazon Athena, vous devez d'abord créer un groupe de travail compatible avec Spark. Après être passé dans le groupe de travail, vous pouvez créer un bloc-notes ou ouvrir un bloc-notes existant. Lorsque vous ouvrez un bloc-notes dans Athena, une nouvelle session est automatiquement lancée pour celui-ci et vous pouvez travailler avec lui directement dans l'éditeur de blocs-notes d'Athena. **Note** Assurez-vous de créer un groupe de travail compatible avec Spark avant de tenter de créer un bloc-notes. ## Étape 1 : Création d’un groupe de travail compatible avec Spark dans Athena Vous pouvez utiliser des [groupes de travail](workgroups-manage-queries-control-costs.md) dans Athena pour regrouper des utilisateurs, des équipes, des applications ou des charges de travail, et pour suivre les coûts. Pour utiliser Apache Spark dans Amazon Athena, vous devez créer un groupe de travail Amazon Athena qui utilise un moteur Spark. **Note** Les groupes de travail compatibles avec Apache Spark peuvent utiliser l'éditeur de bloc-notes Athena, mais pas l'éditeur de requêtes Athena. Seuls les groupes de travail Athena SQL peuvent utiliser l'éditeur de requêtes Athena. **Créer un groupe de travail compatible avec Spark dans Athena** 1. Ouvrez la console Athena à l'adresse [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home) 1. Si le panneau de navigation de la console n'est pas visible, choisissez le menu d'extension sur la gauche. ![\[Choisissez le menu d'expansion.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/nav-pane-expansion.png) 1. Dans le panneau de navigation, choisissez **Workgroups (Groupes de travail)**. 1. Sur la page **Workgroups** (Groupes de travail), choisissez **Create workgroup** (Créer un groupe de travail). 1. Dans le champ **Workgroup name** (Nom du groupe de travail), saisissez un nom pour votre groupe de travail Apache Spark. 1. (Facultatif) Dans le champ **Description**, saisissez une description de votre groupe de travail. 1. Dans le champ **Analytics engine** (Moteur d'analyse), choisissez **Apache Spark**. **Note** Une fois que vous avez créé un groupe de travail, le type de moteur d'analyse du groupe de travail ne peut pas être modifié. Par exemple, un groupe de travail du moteur Athena version 3 ne peut pas être remplacé par un groupe de travail PySpark du moteur version 3. 1. Pour les besoins de ce tutoriel, sélectionnez **Turn on example notebook** (Activer l'exemple de bloc-notes). Cette fonctionnalité facultative ajoute un exemple de bloc-notes portant le nom `example-notebook-random_string` de votre groupe de travail et ajoute les autorisations AWS Glue associées que le bloc-notes utilise pour créer, afficher et supprimer des bases de données et des tables spécifiques de votre compte, ainsi que des autorisations de lecture dans Amazon S3 pour l'exemple de jeu de données. Pour voir les autorisations ajoutées, choisissez **View additional permissions details** (Afficher les détails des autorisations supplémentaires). **Note** L'exécution de l'exemple de bloc-notes peut entraîner des coûts supplémentaires. 1. Dans **Paramètres de résultat du calcul**, choisissez l’une des options suivantes : + **Create a new S3 bucket** (Créer un nouveau compartiment S3) – Cette option crée un compartiment Amazon S3 dans votre compte pour les résultats de vos calculs. Le nom du bucket a le format `account_id-region-athena-results-bucket-alphanumeric_id` et utilise les paramètres ACLs désactivés, l'accès public bloqué, le versionnement désactivé et le propriétaire du bucket appliqué. + **Choose an existing S3 location** (Choisir un emplacement S3 existant) – Pour cette option, procédez comme suit : + Saisissez le chemin d'un emplacement S3 existant dans la zone de recherche, ou choisissez **Browse S3** (Parcourir S3) pour choisir un compartiment dans une liste. **Note** Lorsque vous sélectionnez un emplacement existant dans Amazon S3, n'ajoutez pas de barre oblique (`/`) à cet emplacement. Ainsi, le lien vers l'emplacement des résultats du calcul sur la [page des détails du calcul](#notebooks-spark-getting-started-viewing-session-and-calculation-details) pointe vers un répertoire incorrect. Si cela se produit, modifiez l'emplacement des résultats du groupe de travail pour supprimer la barre oblique de fin de ligne. + (Facultatif) Choisissez **View** (Afficher) pour ouvrir la page **Buckets** (Compartiments) de la console Amazon S3 où vous pouvez voir plus d'informations sur le compartiment existant que vous avez choisi. + (Facultatif) Dans le **champ Propriétaire attendu du bucket**, entrez l'ID de AWS compte que vous pensez être le propriétaire du bucket d'emplacement de sortie des résultats de votre requête. Nous vous recommandons de choisir cette option comme mesure de sécurité supplémentaire lorsque cela est possible. Si l'ID du compte du propriétaire du compartiment ne correspond pas à l'ID que vous avez spécifié, les tentatives de sortie vers le compartiment échoueront. Pour obtenir des informations détaillées, consultez [Vérification de la propriété du compartiment avec la condition de propriétaire du compartiment](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html) dans le *Guide de l'utilisateur Simple Storage Service (Amazon S3)*. + (Facultatif) Sélectionnez **Assign bucket owner full control over query results** (Attribuer au propriétaire du compartiment le contrôle total des résultats de la requête) si l'emplacement des résultats de votre calcul est détenu par un autre compte et si vous voulez accorder à cet autre compte le contrôle total des résultats de votre requête. 1. (Facultatif) Choisissez **Chiffrer les résultats de requêtes** si vous souhaitez chiffrer les résultats des requêtes. + Dans **Type de chiffrement**, choisissez l’une des options suivantes : + **SSE\$1S3** : cette option utilise le chiffrement côté serveur (SSE) avec des clés de chiffrement gérées par Amazon S3. + **SSE\$1KMS** — Cette option utilise le chiffrement côté serveur (SSE) avec des clés gérées. AWS KMS Pour **Choisir une AWS KMS clé**, choisissez l'une des options suivantes. + **Utiliser la clé AWS détenue** — La AWS KMS clé est détenue et gérée par AWS. Aucun frais supplémentaire ne vous est facturé pour l’utilisation de cette clé. + **Choisissez une autre AWS KMS clé (avancée)** : pour cette option, effectuez l'une des opérations suivantes : + Pour utiliser une clé existante, utilisez le champ de recherche pour choisir AWS KMS ou saisir un ARN de clé. + Pour créer une clé dans la AWS KMS console, choisissez **Créer une AWS KMS clé**. Votre rôle d'exécution doit avoir l'autorisation d'utiliser la clé que vous créez. Après avoir créé la clé dans la console KMS, retournez à la page **Créer un groupe de travail** dans la console Athena, puis utilisez **le champ de recherche Choisissez AWS KMS une clé ou entrez un ARN** pour choisir la clé que vous venez de créer. **Important** Lorsque vous modifiez la [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) pour un groupe de travail, les blocs-notes gérés avant la mise à jour font toujours référence à l'ancienne clé KMS. Les blocs-notes gérés après la mise à jour utilisent la nouvelle clé KMS. Pour mettre à jour les anciens blocs-notes afin de faire référence à la nouvelle clé KMS, exportez puis importez chacun des anciens blocs-notes. Si vous supprimez l'ancienne clé KMS avant de mettre à jour les références des anciens blocs-notes avec la nouvelle clé KMS, les anciens blocs-notes ne sont plus déchiffrables et ne peuvent pas être récupérés. Ce comportement s'applique également aux mises à jour des [alias](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html), qui sont des noms conviviaux pour les clés KMS. Lorsque vous mettez à jour un alias de clé KMS pour pointer vers une nouvelle clé KMS, les blocs-notes gérés avant la mise à jour de l'alias font toujours référence à l'ancienne clé KMS, et les blocs-notes gérés après la mise à jour de l'alias utilisent la nouvelle clé KMS. Tenez compte des points suivants avant de mettre à jour vos clés ou alias  KMS. 1. Dans **Configurations supplémentaires**, choisissez **Utiliser les valeurs par défaut**. Il s’agit de l’option par défaut, qui facilitera la prise en main de votre groupe de travail compatible avec Spark. Lorsque vous utilisez les valeurs par défaut, Athena crée pour vous un rôle IAM et un emplacement pour les résultats de calcul dans Amazon S3. Le nom du rôle IAM et l'emplacement du compartiment S3 à créer s'affichent dans la case située sous le titre **Additional configurations** (Configurations supplémentaires). Si vous n’utilisez pas les valeurs par défaut, suivez les étapes de la section [(Facultatif) Spécification de vos propres configurations de groupe de travail](#notebooks-spark-getting-started-workgroup-configuration) pour configurer manuellement votre groupe de travail. 1. (Facultatif) **Étiquettes** – Utilisez cette option pour ajouter des étiquettes à votre groupe de travail. Pour de plus amples informations, veuillez consulter [Balisage des ressources Athena](tags.md). 1. Choisissez **Créer un groupe de travail**. Un message vous informe que le groupe de travail a été créé avec succès et qu'il apparaît dans la liste des groupes de travail. ### (Facultatif) Spécification de vos propres configurations de groupe de travail Si vous souhaitez spécifier votre propre rôle IAM et l'emplacement des résultats de calcul pour votre bloc-notes, suivez les étapes de cette rubrique. Si vous avez sélectionné **Use defaults** (Utiliser les valeurs par défaut) pour l'option **Additional configurations** (Configurations supplémentaires), ignorez cette rubrique et passez directement à [Étape 2 : Ouverture de l’explorateur de blocs-notes et changement de groupe de travail](#notebooks-spark-getting-started-switching-workgroups-and-opening-notebook-explorer). La procédure suivante suppose que vous avez terminé les étapes 1 à 9 de la procédure **Créer un groupe de travail compatible avec Spark dans Athena** décrite à la rubrique précédente. **Spécifier vos propres configurations de groupe de travail** 1. Si vous souhaitez créer ou utiliser votre propre rôle IAM ou configurer le chiffrement des blocs-notes, développez la **configuration des rôles IAM**. + Dans **Fonction du service pour autoriser Athena**, sélectionnez l’une des options suivantes : + **Créer et utiliser une nouvelle fonction du service** : choisissez cette option si vous souhaitez qu’Athena crée un rôle de service pour vous. Pour voir les autorisations accordées par le rôle, choisissez **View permission details** (Afficher les détails des autorisations). + **Utiliser une fonction du service existante** : choisissez un rôle existant dans le menu déroulant. Le rôle que vous choisissez doit inclure les autorisations de la première option. Pour plus d'informations sur les autorisations pour les groupes de travail avec bloc-notes, voir [Résolution des problèmes liés aux groupes de travail compatibles avec Spark](notebooks-spark-troubleshooting-workgroups.md). + Pour **Notebook and calculation code encryption key management** (Gestion des clés de chiffrement du bloc-notes et du code de calcul), choisissez l'une des options suivantes : + **Chiffrer AWS à l'aide d'une clé détenue (par défaut)** : la AWS KMS clé est détenue et gérée par AWS. Aucun frais supplémentaire ne vous est facturé pour l’utilisation de cette clé. + **Chiffrez à l’aide de votre propre clé AWS KMS ** : si vous choisissez cette option, effectuez l’une des opérations suivantes : + Pour utiliser une clé existante, utilisez le champ de recherche pour choisir AWS KMS ou saisir un ARN de clé. + Pour créer une clé dans la AWS KMS console, choisissez **Créer une AWS KMS clé**. Votre rôle d'exécution doit avoir l'autorisation d'utiliser la clé que vous créez. Après avoir créé la clé dans la console KMS, retournez à la page **Créer un groupe de travail** dans la console Athena, puis utilisez **le champ de recherche Choisissez AWS KMS une clé ou entrez un ARN** pour choisir la clé que vous venez de créer. **Important** Lorsque vous modifiez la [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) pour un groupe de travail, les blocs-notes gérés avant la mise à jour font toujours référence à l'ancienne clé KMS. Les blocs-notes gérés après la mise à jour utilisent la nouvelle clé KMS. Pour mettre à jour les anciens blocs-notes afin de faire référence à la nouvelle clé KMS, exportez puis importez chacun des anciens blocs-notes. Si vous supprimez l'ancienne clé KMS avant de mettre à jour les références des anciens blocs-notes avec la nouvelle clé KMS, les anciens blocs-notes ne sont plus déchiffrables et ne peuvent pas être récupérés. Ce comportement s'applique également aux mises à jour des [alias](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html), qui sont des noms conviviaux pour les clés KMS. Lorsque vous mettez à jour un alias de clé KMS pour pointer vers une nouvelle clé KMS, les blocs-notes gérés avant la mise à jour de l'alias font toujours référence à l'ancienne clé KMS, et les blocs-notes gérés après la mise à jour de l'alias utilisent la nouvelle clé KMS. Tenez compte des points suivants avant de mettre à jour vos clés ou alias  KMS. 1. (Facultatif) **Autres paramètres** : développez cette option pour activer ou désactiver l'option **Publier CloudWatch les métriques** pour le groupe de travail. Ce champ est sélectionné par défaut. Pour de plus amples informations, veuillez consulter [Surveillez Apache Spark à l'aide de CloudWatch métriques](notebooks-spark-metrics.md). 1. (Facultatif) **Étiquettes** – Utilisez cette option pour ajouter des étiquettes à votre groupe de travail. Pour de plus amples informations, veuillez consulter [Balisage des ressources Athena](tags.md). 1. Choisissez **Créer un groupe de travail**. Un message vous informe que le groupe de travail a été créé avec succès et qu'il apparaît dans la liste des groupes de travail. ## Étape 2 : Ouverture de l’explorateur de blocs-notes et changement de groupe de travail Pour pouvoir utiliser le groupe de travail compatible avec Spark que vous venez de créer, vous devez passer au groupe de travail. Pour changer de groupe de travail compatible avec Spark, vous pouvez utiliser l'option **Workgroup** (Groupe de travail) dans l'explorateur ou l'éditeur de blocs-notes. **Note** Avant de commencer, vérifiez que votre navigateur ne bloque pas les cookies tiers. Tout navigateur qui bloque les cookies tiers par défaut ou en tant que paramètre activé par l'utilisateur empêchera le lancement des bloc-notes. Pour en savoir plus sur la gestion des cookies, voir : [Chrome](https://support.alertlogic.com/hc/en-us/articles/360018127132-Turn-Off-Block-Third-Party-Cookies-in-Chrome-for-Windows) [Firefox](https://support.mozilla.org/en-US/kb/third-party-cookies-firefox-tracking-protection) [Safari](https://support.apple.com/guide/safari/manage-cookies-sfri11471/mac) **Ouvrir l'explorateur de blocs-notes et changer de groupe de travail** 1. Dans le volet de navigation, choisissez **Notebook explorer** (Explorateur de bloc-notes). 1. Utilisez l'option **Workgroup** (Groupe de travail) en haut à droite de la console pour choisir le groupe de travail compatible avec Spark que vous avez créé. L'exemple de bloc-notes est affiché dans la liste des blocs-notes. Vous pouvez utiliser l'explorateur de bloc-notes de la manière suivante : + Choisissez le nom associé d'un bloc-notes pour ouvrir le bloc-notes dans une nouvelle session. + Pour renommer, supprimer ou exporter votre bloc-notes, utilisez le menu **Actions**. + Pour importer un fichier de bloc-notes, sélectionnez **Import file** (Importer un fichier). + Pour créer un bloc-notes, sélectionnez **Create notebook** (Créer un bloc-notes). ## Étape 3 : Exécution de l’exemple de bloc-notes L'exemple de bloc-notes interroge les données d'un jeu de données disponible publiquement sur les trajets en taxi dans la ville de New York. Le bloc-notes contient des exemples qui montrent comment utiliser Spark DataFrames, Spark SQL et le AWS Glue Data Catalog. **Exécuter l'exemple de bloc-notes** 1. Dans l'explorateur de blocs-notes, choisissez le nom associé à l'exemple de bloc-notes. Cela démarre une session de bloc-notes avec les paramètres par défaut et ouvre le bloc-notes dans l'éditeur de blocs-notes. Un message vous informe qu'une nouvelle session Apache Spark a été démarrée en utilisant les paramètres par défaut (20 maximum DPUs). 1. Pour exécuter les cellules dans l'ordre et observer les résultats, cliquez une fois sur le bouton **Run** (Exécuter) pour chaque cellule du bloc-notes. + Faites défiler vers le bas pour voir les résultats et faire apparaître de nouvelles cellules. + Pour les cellules qui comportent un calcul, une barre de progression indique le pourcentage achevé, le temps écoulé et le temps restant. + L'exemple de bloc-notes crée une base de données et une table dans votre compte. La dernière cellule les supprime lors d'une étape de nettoyage. **Note** Si vous modifiez les noms de dossier, de table ou de base de données dans l'exemple de bloc-notes, assurez-vous que ces modifications sont reflétées dans les rôles IAM que vous utilisez. Sinon, le bloc-notes risque de ne pas fonctionner en raison d'autorisations insuffisantes. ## Étape 4 : Modification des détails de la session Après avoir démarré une session de bloc-notes, vous pouvez modifier les détails de la session tels que le format des tables, le chiffrement, le délai d'inactivité de la session et le nombre maximal d'unités de traitement de données (DPUs) simultanées que vous souhaitez utiliser. Un DPU est une mesure relative de la puissance de traitement composée de 4 V de capacité CPUs de calcul et de 16 Go de mémoire. **Modifier les détails de la session** 1. Dans l'éditeur de bloc-notes, dans le menu **Session** en haut à droite, choisissez **Edit session** (Modifier la session). 1. Dans la boîte de dialogue **Modifier les détails de la session**, dans la section **Propriétés Spark**, choisissez ou saisissez des valeurs pour les options suivantes : + **Format de table supplémentaire** : choisissez **Linux Foundation Delta Lake**, **Apache Hudi**, **Apache Iceberg** ou **Personnalisé**. + Pour les options de table **Delta**, **Hudi** ou **Iceberg**, les options **Modifier dans la table** et **Modifier dans JSON** fournissent automatiquement les propriétés de table requises pour le format de table correspondant. Pour plus d'informations sur l'utilisation de ces formats de table, consultez [Utilisation de formats de table autres que Hive dans Athena pour Spark](notebooks-spark-table-formats.md). + Pour ajouter ou supprimer des propriétés de table pour le type de table **personnalisé** ou pour d'autres types de table, utilisez les options **Modifier dans la table** et **Modifier dans JSON**. + Pour l'option **Modifier dans la table**, choisissez **Ajouter une propriété** pour ajouter une propriété, ou choisissez **Supprimer** pour supprimer une propriété. Utilisez les champs **Clé** et **Valeur** pour saisir les noms des propriétés et leurs valeurs. + Pour l'option **Modifier dans JSON**, utilisez l'éditeur de texte JSON pour modifier directement la configuration. + Choisissez **Copier** pour copier le texte JSON dans le presse-papier. + Choisissez **Effacer** pour supprimer tout le texte de l'éditeur JSON. + Choisissez l'icône des paramètres (engrenage) pour configurer l'encapsulage des lignes ou choisissez un thème de couleur pour l'éditeur JSON. + **Activer le chiffrement Spark** : sélectionnez cette option pour chiffrer les données écrites sur le disque et envoyées via les nœuds du réseau Spark. Pour de plus amples informations, veuillez consulter [Activation du chiffrement Apache Spark](notebooks-spark-encryption.md). 1. Dans la section **Paramètres de la session**, choisissez ou saisissez des valeurs pour les options suivantes : + **Session idle timeout** (Délai d'inactivité de la session) – Choisissez ou saisissez une valeur comprise entre 1 et 480 minutes. La valeur par défaut est de 20. + **Coordinator size** (Taille du coordinateur) – Le *coordinateur* est un exécuteur spécial qui orchestre le travail de traitement et gère les autres exécuteurs d'une session de bloc-notes. Actuellement, 1 DPU est la valeur par défaut et la seule valeur possible. + **Executor size** (Taille de l'exécuteur) – L'*exécuteur* est la plus petite unité de calcul qu'une session de bloc-notes peut demander à Athena. Actuellement, 1 DPU est la valeur par défaut et la seule valeur possible. + **Valeur simultanée maximale** : nombre maximal de machines DPUs pouvant être exécutées simultanément. La valeur par défaut est 20, le minimum est 3 et le maximum est 60. L'augmentation de cette valeur n'entraîne pas automatiquement l'allocation de ressources supplémentaires, mais Athena tentera d'allouer jusqu'au maximum spécifié lorsque la charge de calcul le nécessite et que des ressources sont disponibles. 1. Choisissez **Enregistrer**. 1. À l'invite **Confirm edit** (Confirmer la modification), choisissez **Confirm** (Confirmer). Athena enregistre votre bloc-notes et démarre une nouvelle session avec les paramètres que vous avez spécifiés. Une bannière dans l'éditeur de bloc-notes vous informe qu'une nouvelle session a commencé avec les paramètres modifiés. **Note** Athena mémorise les paramètres de votre session pour le bloc-notes. Si vous modifiez les paramètres d'une session et que vous mettez ensuite fin à la session, Athena utilise les paramètres de session que vous avez configurés la prochaine fois que vous démarrez une session pour le bloc-notes. ## Étape 5 : Affichage des détails de la session et des calculs Après avoir exécuté le bloc-notes, vous pouvez consulter les détails de votre session et de vos calculs. **Afficher les détails de la session et des calculs** 1. Dans le menu **Session** en haut à droite, choisissez **View details** (Afficher les détails). + L'onglet **Current session** (Session en cours) affiche des informations sur la session en cours, notamment l'ID de la session, l'heure de création, l'état et le groupe de travail. + L'onglet **Historique** répertorie IDs les sessions précédentes. Pour afficher les détails d'une session précédente, sélectionnez l'onglet **History** (Historique), puis choisissez un ID de session dans la liste. + La section **Calculations** (Calculs) affiche une liste des calculs effectués au cours de la session. 1. Pour afficher les détails d'un calcul, choisissez l'ID du calcul. 1. Sur la page **Calculation details** (Détails du calcul), vous pouvez effectuer les opérations suivantes : + Pour consulter le code du calcul, voir la section **Code**. + Pour voir les résultats du calcul, choisissez l'onglet **Results** (Résultats). + Pour télécharger les résultats que vous voyez en format texte, sélectionnez **Download results** (Télécharger les résultats). + Pour afficher les informations sur les résultats du calcul dans Amazon S3, choisissez **View in S3** (Afficher dans S3). ## Étape 6 : Fin de la session **Pour mettre fin à la session de bloc-notes** 1. Dans l'éditeur de bloc-notes, dans le menu **Session** en haut à droite, choisissez **Terminate** (Terminer). 1. À l'invite **Confirm session termination** (Confirmer la fin de la session), choisissez **Confirm** (Confirmer). Votre bloc-notes est enregistré et vous êtes renvoyé à l'éditeur de blocs-notes. **Note** La fermeture d'un onglet de bloc-notes dans l'éditeur de bloc-notes ne met pas automatiquement fin à la session d'un bloc-notes actif. Si vous voulez vous assurer que la session est terminée, utilisez l'option **Session**, **Terminate** (Terminer). ## Étape 7 : Création de votre propre bloc-notes Une fois que vous avez créé un groupe de travail Athena compatible avec Spark, vous pouvez créer votre propre bloc-notes. **Pour créer un bloc-notes** 1. Si le panneau de navigation de la console n'est pas visible, choisissez le menu d'extension sur la gauche. 1. Dans le volet de navigation de la console Athena, choisissez **Notebook Explorer** (Explorateur de bloc-notes) ou **Notebook Editor** (Éditeur de bloc-notes). 1. Effectuez l’une des actions suivantes : + Dans **Notebook explorer** (Explorateur de blocs-notes), choisissez **Create notebook** (Créer un bloc-notes). + Dans **Notebook editor** (Éditeur de bloc-notes), choisissez **Create notebook** (Créer un bloc-notes) ou cliquez sur l'icône plus (**\$1**) pour ajouter un bloc-notes. 1. Dans la boîte de dialogue **Create notebook** (Créer un bloc-notes), saisissez un nom dans le champ **Notebook name** (Nom du bloc-notes). 1. (Facultatif) Développez **Propriétés Spark**, puis choisissez ou saisissez des valeurs pour les options suivantes : + **Format de table supplémentaire** : choisissez **Linux Foundation Delta Lake**, **Apache Hudi**, **Apache Iceberg** ou **Personnalisé**. + Pour les options de table **Delta**, **Hudi** ou **Iceberg**, les options **Modifier dans la table** et **Modifier dans JSON** fournissent automatiquement les propriétés de table requises pour le format de table correspondant. Pour plus d'informations sur l'utilisation de ces formats de table, consultez [Utilisation de formats de table autres que Hive dans Athena pour Spark](notebooks-spark-table-formats.md). + Pour ajouter ou supprimer des propriétés de table pour le type de table **personnalisé** ou pour d'autres types de table, utilisez les options **Modifier dans la table** et **Modifier dans JSON**. + Pour l'option **Modifier dans la table**, choisissez **Ajouter une propriété** pour ajouter une propriété, ou choisissez **Supprimer** pour supprimer une propriété. Utilisez les champs **Clé** et **Valeur** pour saisir les noms des propriétés et leurs valeurs. + Pour l'option **Modifier dans JSON**, utilisez l'éditeur de texte JSON pour modifier directement la configuration. + Choisissez **Copier** pour copier le texte JSON dans le presse-papier. + Choisissez **Effacer** pour supprimer tout le texte de l'éditeur JSON. + Choisissez l'icône des paramètres (engrenage) pour configurer l'encapsulage des lignes ou choisissez un thème de couleur pour l'éditeur JSON. + **Activer le chiffrement Spark** : sélectionnez cette option pour chiffrer les données écrites sur le disque et envoyées via les nœuds du réseau Spark. Pour de plus amples informations, veuillez consulter [Activation du chiffrement Apache Spark](notebooks-spark-encryption.md). 1. (Facultatif) Développez **Session parameters** (Paramètres de session), puis choisissez ou saisissez des valeurs pour les options suivantes : + **Session idle timeout** (Délai d'inactivité de la session) – Choisissez ou saisissez une valeur comprise entre 1 et 480 minutes. La valeur par défaut est de 20. + **Coordinator size** (Taille du coordinateur) – Le *coordinateur* est un exécuteur spécial qui orchestre le travail de traitement et gère les autres exécuteurs d'une session de bloc-notes. Actuellement, 1 DPU est la valeur par défaut et la seule valeur possible. Une DPU (unité de traitement des données) est une mesure relative de la puissance de traitement composée de 4 V CPUs de capacité de calcul et de 16 Go de mémoire. + **Executor size** (Taille de l'exécuteur) – L'*exécuteur* est la plus petite unité de calcul qu'une session de bloc-notes peut demander à Athena. Actuellement, 1 DPU est la valeur par défaut et la seule valeur possible. + **Valeur simultanée maximale** : nombre maximal de machines DPUs pouvant être exécutées simultanément. La valeur par défaut est 20 et la valeur maximale est 60. L'augmentation de cette valeur n'entraîne pas automatiquement l'allocation de ressources supplémentaires, mais Athena tentera d'allouer jusqu'au maximum spécifié lorsque la charge de calcul le nécessite et que des ressources sont disponibles. 1. Choisissez **Créer**. Votre bloc-notes s'ouvre dans une nouvelle session dans l'éditeur de bloc-notes. Pour plus d’informations sur la gestion de vos fichiers de bloc-notes, consultez [Gestion des fichiers de bloc-notes](notebooks-spark-managing.md). # Gestion des fichiers de bloc-notes **Note** L'éditeur de bloc-notes Athena est pris en charge dans la version 3 du moteur Pyspark. Pour utiliser des blocs-notes avec Apache Spark version 3.5, voir [SageMaker Notebooks](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html). Vous pouvez utiliser l’explorateur de blocs-notes pour [créer](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) des blocs-notes, mais aussi pour ouvrir, renommer, supprimer, exporter ou importer des blocs-notes, ou encore pour consulter l’historique des sessions d’un bloc-notes. **Pour ouvrir un bloc-notes créé précédemment** 1. Si le panneau de navigation de la console n'est pas visible, choisissez le menu d'extension sur la gauche. 1. Dans le volet de navigation de la console Athena, choisissez **Notebook editor** (Éditeur de bloc-notes) ou **Notebook explorer** (Explorateur de bloc-notes). 1. Effectuez l’une des actions suivantes : + Dans **Notebook editor** (Éditeur de bloc-notes), choisissez un bloc-notes dans la liste **Recent notebooks** (Blocs-notes récents) ou **Saved notebooks** (Blocs-notes enregistrés). Le bloc-notes s'ouvre dans une nouvelle session. + Dans **Notebook explorer** (Explorateur de blocs-notes), choisissez le nom d'un bloc-notes dans la liste. Le bloc-notes s'ouvre dans une nouvelle session. **Renommer un bloc-notes** 1. [Terminez](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) toutes les sessions actives du bloc-notes que vous voulez renommer. Les sessions actives du bloc-notes doivent être terminées pour pouvoir le renommer. 1. Ouvrez **Notebook explorer** (Explorateur de bloc-notes). 1. Dans la liste des **blocs-notes**, sélectionnez le bouton d'option correspondant au bloc-notes que vous souhaitez renommer. 1. Dans le menu **Actions**, sélectionnez **Rename** (Renommer). 1. À l'invite **Rename notebook** (Renommer le bloc-notes), saisissez le nouveau nom, puis sélectionnez **Save** (Enregistrer). Le nouveau nom du bloc-notes apparaît dans la liste des blocs-notes. **Supprimer un bloc-notes** 1. [Terminez](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) toutes les sessions actives du bloc-notes que vous voulez supprimer. Les sessions actives du bloc-notes doivent être terminées pour pouvoir le supprimer. 1. Ouvrez **Notebook explorer** (Explorateur de bloc-notes). 1. Dans la liste des **blocs-notes**, sélectionnez le bouton d'option correspondant au bloc-notes que vous souhaitez supprimer. 1. Dans le menu **Actions**, choisissez **Delete (Supprimer)**. 1. À l'invite **Delete notebook?** (Supprimer le bloc-notes ?), saisissez le nom du bloc-notes, puis choisissez **Delete** (Supprimer) pour confirmer la suppression. Le nom du bloc-notes est supprimé de la liste des blocs-notes. **Exporter un bloc-notes** 1. Ouvrez **Notebook explorer** (Explorateur de bloc-notes). 1. Dans la liste des **blocs-notes**, sélectionnez le bouton d'option correspondant au bloc-notes que vous souhaitez exporter. 1. Dans le menu **Actions**, sélectionnez **Export file** (Exporter un fichier). **Importer un bloc-notes** 1. Ouvrez **Notebook explorer** (Explorateur de bloc-notes). 1. Choisissez **Import file** (Importer un fichier). 1. Accédez à l'emplacement du fichier que vous voulez importer sur votre ordinateur local, puis choisissez **Open** (Ouvrir). Le bloc-notes importé apparaît dans la liste des blocs-notes. **Consulter l'historique des sessions d'un bloc-notes** 1. Ouvrez **Notebook explorer** (Explorateur de bloc-notes). 1. Dans la liste des **blocs-notes**, sélectionnez le bouton d'option du bloc-notes dont vous voulez consulter l'historique des sessions. 1. Dans le menu **Actions**, choisissez **Session history** (Historique des sessions). 1. Dans l'onglet **History** (Historique), choisissez un **Session ID** (ID de session) pour en consulter les informations sur la session et ses calculs. # Utilisation de l’éditeur de bloc-notes Athena **Note** L'éditeur de bloc-notes Athena est pris en charge dans la version 3 du moteur Pyspark. Pour utiliser des blocs-notes avec Apache Spark version 3.5, voir [SageMaker Notebooks](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html). Vous gérez vos blocs-notes dans l'explorateur de blocs-notes Athena et vous les modifiez et les exécutez dans des sessions à l'aide de l'éditeur de blocs-notes Athena. Vous pouvez configurer l'utilisation des DPU pour vos sessions de bloc-notes en fonction de vos besoins. Lorsque vous arrêtez un bloc-notes, vous terminez la session associée. Tous les fichiers sont sauvegardés, mais les changements en cours dans les variables, fonctions et classes déclarées sont perdus. Lorsque vous redémarrez le bloc-notes, Athena recharge les fichiers du bloc-notes et vous pouvez réexécuter votre code. L'éditeur de bloc-notes Athena est un environnement interactif permettant d'écrire et d'exécuter du code. Les sections suivantes décrivent les caractéristiques de l'environnement. ## Présentation des sessions et des calculs du bloc-notes Chaque bloc-notes est associé à un seul noyau Python et exécute du code Python. Un bloc-notes peut contenir une ou plusieurs cellules contenant des commandes. Pour exécuter les cellules d'un bloc-notes, vous devez d'abord créer une session pour le bloc-notes. Les sessions permettent de suivre les variables et l'état des blocs-notes. L'exécution d'une cellule dans un bloc-notes signifie exécuter un calcul dans la session en cours. Les calculs font progresser l'état du bloc-notes et peuvent effectuer des tâches telles que la lecture depuis Amazon S3 ou l'écriture dans d'autres magasins de données. Tant qu'une session est en cours d'exécution, les calculs utilisent et modifient l'état conservé pour le bloc-notes. Lorsque vous n'avez plus besoin de l'état, vous pouvez mettre fin à la session. Lorsque vous mettez fin à une session, le bloc-notes est conservé, mais les variables et autres informations d'état sont détruites. Si vous devez travailler sur plusieurs projets en même temps, vous pouvez créer une session pour chaque projet, et les sessions seront indépendantes les unes des autres. Les sessions disposent d'une capacité de calcul dédiée, mesurée en DPU. Lorsque vous créez une session, vous pouvez lui attribuer un numéro de DPUs. Les différentes sessions peuvent avoir des capacités différentes en fonction des exigences de la tâche. ## Basculement entre les modes commande et édition L'éditeur de bloc-notes possède une interface utilisateur modale : un mode édition pour saisir du texte dans une cellule, et un mode commande pour envoyer des commandes à l'éditeur lui-même, comme copier, coller ou exécuter. Pour utiliser le mode édition et le mode commande, vous pouvez effectuer les tâches suivantes : + Pour passer en mode édition, appuyez sur **ENTER** ou choisissez une cellule. Lorsqu'une cellule est en mode édition, elle présente une marge gauche verte. + Pour passer en mode commande, appuyez sur **ESC** ou cliquez à l'extérieur d'une cellule. Notez que les commandes s'appliquent généralement uniquement à la cellule actuellement sélectionnée, et non à toutes les cellules. Lorsque l'éditeur est en mode commande, la cellule présente une marge gauche bleue. + En mode commande, vous pouvez utiliser les raccourcis clavier et le menu situé au-dessus de l'éditeur, mais vous ne pouvez pas saisir de texte dans des cellules individuelles. + Pour sélectionner une cellule, choisissez-la. + Pour sélectionner toutes les cellules, appuyez sur **Ctrl\$1A** (Windows) ou sur **Cmd\$1A** (Mac). ## Utilisation des actions du menu de l’éditeur de bloc-notes Les icônes du menu situé en haut de l'éditeur de bloc-notes offrent les options suivantes : + **Enregistrer** – Permet d'enregistrer l'état actuel du bloc-notes. + **Insérer une cellule en dessous** – Permet d'ajouter une nouvelle cellule (vide) en dessous de la cellule actuellement sélectionnée. + **Couper les cellules sélectionnées** – Permet de supprimer la cellule sélectionnée de son emplacement actuel et de la copier dans la mémoire. + **Copier les cellules sélectionnées** – Permet de copier la cellule sélectionnée dans la mémoire. + **Coller les cellules en dessous** – Permet de coller la cellule copiée en dessous de la cellule actuelle. + **Déplacer les cellules sélectionnées vers le haut** – Permet de déplacer la cellule actuelle au-dessus de la cellule située au-dessus. + **Déplacer les cellules sélectionnées vers le bas** – Permet de déplacer la cellule actuelle sous la cellule située en dessous. + **Exécuter** – Permet d'exécuter la cellule actuelle (sélectionnée). La sortie s'affiche immédiatement sous la cellule actuelle. + **Tout exécuter** – Permet d'exécuter toutes les cellules du bloc-notes. Le résultat de chaque cellule s'affiche immédiatement sous la cellule. + **Stop (Interrompre le noyau)** – Permet d'arrêter le bloc-notes actuel en interrompant le noyau. + **Option de format** – Permet de sélectionner le format de cellule, qui peut être l'un des suivants : + **Code** – À utiliser pour le code Python (par défaut). + **Markdown — À** utiliser pour saisir du texte au format [Markdown de GitHub style -style](https://docs.github.com/en/get-started/writing-on-github). Pour afficher le format Markdown, exécutez la cellule. + **Raw NBConvert** — À utiliser pour saisir du texte sous une forme non modifiée. Les cellules marquées comme **brutes NBConvert** peuvent être converties dans un format différent, tel que le HTML, à l'aide de l'outil de ligne de commande Jupyter [nbconvert](https://nbconvert.readthedocs.io/en/latest/usage.html). + **Titre** – Permet de modifier le niveau de titre de la cellule. + **Palette de commandes** – Contient les commandes du bloc-notes Jupyter et leurs raccourcis clavier. Pour plus d'informations sur les raccourcis clavier, voir les rubriques suivantes du présent document. + **Session** – Utilisez les options de ce menu pour [afficher](notebooks-spark-getting-started.md#notebooks-spark-getting-started-viewing-session-and-calculation-details) les détails d'une session, [modifier les paramètres de session](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) ou [mettre fin](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) à la session. ## Utilisation des raccourcis clavier du mode commande pour gagner en rapidité Voici quelques raccourcis clavier courants du mode commande de l'éditeur de bloc-notes. Ces raccourcis sont disponibles après avoir appuyé sur **ESC** pour passer en mode commande. Pour consulter la liste complète des commandes disponibles dans l'éditeur, appuyez sur **ESC \$1 H**. **** | Clé | Action | | --- | --- | | 1 - 6 | Passer le type de cellule au format Markdown et définir le niveau de titre au numéro saisi | | a | Créer une cellule au-dessus de la cellule actuelle | | b | Créer une cellule en dessous de la cellule actuelle | | c | Copier la cellule actuelle dans la mémoire | | d d | Supprimer la cellule actuelle | | h | Afficher l'écran d'aide des raccourcis clavier | | j | Descendre d'une cellule | | k | Monter d'une cellule | | m | Changer le format actuel des cellules en format Markdown | | r | Changer le format actuel des cellules en format brut | | s | Enregistrer le bloc-notes | | v | Coller le contenu de la mémoire sous la cellule actuelle | | x | Couper la ou les cellules sélectionnées | | y | Changer le format de la cellule en code | | z | Annuler | | Ctrl\$1Enter | Exécuter la cellule actuelle et passer en mode commande | | Shift\$1Enter ou Alt\$1Enter | Exécuter la cellule actuelle et créer une nouvelle cellule sous la sortie, puis passer la nouvelle cellule en mode édition | | Space | Page avant | | Shift\$1Space | Page arrière | | Shift \$1 L | Activer ou désactiver la visibilité des numéros de ligne dans les cellules | ## Personnalisation des raccourcis du mode commande L'éditeur de bloc-notes dispose d'une option permettant de personnaliser les raccourcis clavier du mode commande. **Modifier les raccourcis clavier du mode commande** 1. Dans le menu de l'éditeur de bloc-notes, choisissez la **palette de commandes**. 1. Dans la palette de commandes, choisissez la commande **Edit command mode keyboard shortcuts** (Modifier les raccourcis clavier du mode de commande). 1. Utilisez l'interface **Edit command mode shortcuts** (Modifier les raccourcis clavier du mode de commande) pour mapper ou remapper les commandes que vous souhaitez sur le clavier. Pour voir les instructions de modification des raccourcis clavier du mode commande, faites défiler jusqu'au bas de l'écran **Edit command mode shortcuts** (Modifier les raccourcis clavier du mode de commande). Pour plus d'informations sur l'utilisation des commandes magiques dans Athena pour Apache Spark, consultez [Utilisation des commandes magiques](notebooks-spark-magics.md). **Topics** + [Présentation des sessions et des calculs du bloc-notes](#notebooks-spark-sessions-and-calculations) + [Basculement entre les modes commande et édition](#notebooks-spark-command-mode-vs-edit-mode) + [Utilisation des actions du menu de l’éditeur de bloc-notes](#notebooks-spark-notebook-editor-menu) + [Utilisation des raccourcis clavier du mode commande pour gagner en rapidité](#notebooks-spark-command-mode-keyboard-shortcuts) + [Personnalisation des raccourcis du mode commande](#notebooks-spark-editing-command-mode-shortcuts) + [Utilisation des commandes magiques](notebooks-spark-magics.md) # Utilisation des commandes magiques Les commandes magiques, ou magies, sont des commandes spéciales que vous pouvez exécuter dans une cellule de bloc-notes. Par exemple, `%env` affiche les variables d'environnement dans une session de bloc-notes. Athena prend en charge les fonctions magiques de la version 6.0.3. IPython Cette section présente certaines commandes magiques clés d'Athena pour Apache Spark. + Pour consulter la liste des commandes magiques d'Athena, exécutez la commande **%lsmagic** dans une cellule de bloc-notes. + Pour plus d'informations sur l'utilisation des magies pour créer des graphiques dans les blocs-notes Athena, consultez [Utilisation de commandes magiques pour créer des graphiques de données](notebooks-spark-magics-graphs.md). + Pour plus d'informations sur les commandes magiques supplémentaires, consultez la section [Commandes magiques intégrées](https://ipython.readthedocs.io/en/stable/interactive/magics.html) dans la IPython documentation. **Note** Actuellement, l'exécution de la commande `%pip` échoue. Il s'agit d'un problème connu. **Topics** + [Magies cellulaires](notebooks-spark-magics-cell-magics.md) + [Magies linéaires](notebooks-spark-magics-line-magics.md) + [Magies graphiques](notebooks-spark-magics-graphs.md) # Utilisation de la magie cellulaire Les magies qui sont écrites sur plusieurs lignes sont précédées d'un double signe de pourcentage (`%%`) et sont appelées fonctions de magie cellulaire ou magies cellulaires. ## %%sql Cette magie cellulaire permet d'exécuter des instructions SQL directement sans avoir à la décorer avec des instructions SQL Spark. La commande affiche également la sortie en appelant implicitement `.show()` sur le cadre de données renvoyé. ![\[Utilisation de %%sql.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-1.png) La commande `%%sql` tronque automatiquement les sorties de colonne à une largeur de 20 caractères. Actuellement, ce paramètre n'est pas configurable. Pour contourner cette limite, utilisez la syntaxe complète suivante et modifiez les paramètres de la méthode `show` en conséquence. ``` spark.sql("""YOUR_SQL""").show(n=number, truncate=number, vertical=bool) ``` + **n** `int`, facultatif. Nombre de lignes à afficher. + **tronquer** – `bool` ou`int`, facultatif : si `true`, tronque les chaînes de plus de 20 caractères. Lorsqu'il est défini sur un nombre supérieur à 1, tronque les chaînes longues à la longueur spécifiée et aligne les cellules à droite. + **vertical** – `bool`, facultatif. Si `true`, imprime les lignes de sortie verticalement (une ligne par valeur de colonne). # Utilisation de la magie linéaire Les magies qui se trouvent sur une seule ligne sont précédées d'un signe de pourcentage (`%`) et sont appelées fonctions de magie linéaire ou magies linéaires. ## %help Affiche les descriptions des commandes magiques disponibles. ![\[Utilisation de %help.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-2.png) ## %list\$1sessions Répertorie les sessions associées au bloc-notes. Les informations relatives à chaque session incluent l'ID de session, l'état de la session, ainsi que la date et l'heure de début et de fin de la session. ![\[Utilisation de %list_sessions.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-3.png) ## %session\$1id Récupère l'ID de session en cours. ![\[Utilisation de session_id.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-4.png) ## %set\$1log\$1level Définit ou réinitialise l'enregistreur pour qu'il utilise le niveau de journalisation spécifié. Les valeurs admises sont `DEBUG`, `ERROR`, `FATAL`, `INFO` et  `WARN` ou `WARNING`. Les valeurs doivent être en majuscules et ne doivent pas être entre guillemets simples ou doubles. ![\[Utilisation de %set_log_level.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-5.png) ## %status Décrit la session en cours. La sortie inclut l'ID de session, l'état de la session, le nom du groupe de travail, la version PySpark du moteur et l'heure de début de session. Cette commande magique nécessite une session active pour récupérer les détails de la session. Voici les valeurs d'état possibles : **EN COURS DE CRÉATION** : la session est en cours de démarrage, y compris l'acquisition de ressources. **CRÉÉE** : la session a été démarrée. **INACTIVE** : la session est en mesure d'accepter un calcul. **OCCUPÉE** : La session est en train de traiter une autre tâche et n'est pas en mesure d'accepter un calcul. **EN COURS D'ARRÊT** : la session est en cours d'arrêt. **ARRÊTÉE** : la session et ses ressources ne sont plus en cours d'exécution. **DÉGRADÉE** : la session ne compte aucun coordinateur sain. **ÉCHEC** : en raison d'un échec, la session et ses ressources ne sont plus en cours d'exécution. ![\[Utilisation de %status.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-6.png) # Utilisation de commandes magiques pour créer des graphiques de données Les magies linéraires présentées dans cette section sont spécialisés dans le rendu de données pour des types de données particuliers ou en association avec des bibliothèques graphiques. ## %table Vous pouvez utiliser la commande magique `%table` pour afficher les données du cadre de données sous forme de table. L'exemple suivant crée un cadre de données comptant deux colonnes et trois lignes de données, puis affiche les données sous forme de table. ![\[Utilisation de la commande magique %table.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-graphs-1.png) ## %matplot [Matplotlib](https://matplotlib.org/) est une bibliothèque complète permettant de créer des visualisations statiques, animées et interactives dans Python. Vous pouvez utiliser la commande magique `%matplot` pour créer un graphique après avoir importé la bibliothèque matplotlib dans une cellule de bloc-notes. L'exemple suivant importe la bibliothèque matplotlib, crée un ensemble de coordonnées x et y, puis utilise la commande magique `%matplot` pour créer un graphique des points. ``` import matplotlib.pyplot as plt x=[3,4,5,6,7,8,9,10,11,12] y= [9,16,25,36,49,64,81,100,121,144] plt.plot(x,y) %matplot plt ``` ![\[Utilisation de la commande magique %matplot.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-graphs-2.png) ### Utilisation conjointe des bibliothèques matplotlib et seaborn [Seaborn](https://seaborn.pydata.org/tutorial/introduction) est une bibliothèque permettant de créer des graphiques statistiques dans Python. Elle s'appuie sur matplotlib et s'intègre étroitement aux structures de données [pandas](https://pandas.pydata.org/) (analyse de données Python). Vous pouvez également utiliser la commande magique `%matplot` pour afficher les données Seaborn. L'exemple suivant utilise à la fois les bibliothèques matplotlib et seaborn pour créer un graphique à barres simple. ``` import matplotlib.pyplot as plt import seaborn as sns x = ['A', 'B', 'C'] y = [1, 5, 3] sns.barplot(x, y) %matplot plt ``` ![\[Utilisation de %matplot pour afficher les données Seaborn.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-graphs-3.png) ## %plotly [Plotly](https://plotly.com/python/) est une bibliothèque graphique open source pour Python que vous pouvez utiliser pour créer des graphiques interactifs. Vous utilisez la commande magique `%ploty` pour afficher les données Plotly. L'exemple suivant utilise les bibliothèques [StringIO](https://docs.python.org/3.13/library/io.html#io.StringIO), plotly et pandas sur les données sur les cours des actions pour créer un graphique de l'action entre février et mars 2015. ``` from io import StringIO csvString = """ Date,AAPL.Open,AAPL.High,AAPL.Low,AAPL.Close,AAPL.Volume,AAPL.Adjusted,dn,mavg,up,direction 2015-02-17,127.489998,128.880005,126.919998,127.830002,63152400,122.905254,106.7410523,117.9276669,129.1142814,Increasing 2015-02-18,127.629997,128.779999,127.449997,128.720001,44891700,123.760965,107.842423,118.9403335,130.0382439,Increasing 2015-02-19,128.479996,129.029999,128.330002,128.449997,37362400,123.501363,108.8942449,119.8891668,130.8840887,Decreasing 2015-02-20,128.619995,129.5,128.050003,129.5,48948400,124.510914,109.7854494,120.7635001,131.7415509,Increasing 2015-02-23,130.020004,133,129.660004,133,70974100,127.876074,110.3725162,121.7201668,133.0678174,Increasing 2015-02-24,132.940002,133.600006,131.169998,132.169998,69228100,127.078049,111.0948689,122.6648335,134.2347981,Decreasing 2015-02-25,131.559998,131.600006,128.149994,128.789993,74711700,123.828261,113.2119183,123.6296667,134.0474151,Decreasing 2015-02-26,128.789993,130.869995,126.610001,130.419998,91287500,125.395469,114.1652991,124.2823333,134.3993674,Increasing 2015-02-27,130,130.570007,128.240005,128.460007,62014800,123.510987,114.9668484,124.8426669,134.7184854,Decreasing 2015-03-02,129.25,130.279999,128.300003,129.089996,48096700,124.116706,115.8770904,125.4036668,134.9302432,Decreasing 2015-03-03,128.960007,129.520004,128.089996,129.360001,37816300,124.376308,116.9535132,125.9551669,134.9568205,Increasing 2015-03-04,129.100006,129.559998,128.320007,128.539993,31666300,123.587892,118.0874253,126.4730002,134.8585751,Decreasing 2015-03-05,128.580002,128.75,125.760002,126.410004,56517100,121.539962,119.1048311,126.848667,134.5925029,Decreasing 2015-03-06,128.399994,129.369995,126.260002,126.599998,72842100,121.722637,120.190797,127.2288335,134.26687,Decreasing 2015-03-09,127.959999,129.570007,125.059998,127.139999,88528500,122.241834,121.6289771,127.631167,133.6333568,Decreasing 2015-03-10,126.410004,127.220001,123.800003,124.510002,68856600,119.71316,123.1164763,127.9235004,132.7305246,Decreasing """ csvStringIO = StringIO(csvString) from io import StringIO import plotly.graph_objects as go import pandas as pd from datetime import datetime df = pd.read_csv(csvStringIO) fig = go.Figure(data=[go.Candlestick(x=df['Date'], open=df['AAPL.Open'], high=df['AAPL.High'], low=df['AAPL.Low'], close=df['AAPL.Close'])]) %plotly fig ``` ![\[Utilisation de la commande magique %ploty.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-magics-graphs-4.png) # Utilisation de formats de table autres que Hive dans Athena pour Spark **Note** Cette page fait référence à l'utilisation des bibliothèques Python dans la version finale du moteur Pyspark version 3. Consultez [Amazon EMR 7.12](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html) pour connaître les versions de format de tableau ouvert prises en charge. Lorsque vous travaillez avec des sessions et des blocs-notes dans Athena pour Spark, vous pouvez utiliser les tables Linux Foundation Delta Lake, Apache Hudi et Apache Iceberg, en plus des tables Apache Hive. ## Considérations et restrictions Lorsque vous utilisez des formats de table autres qu'Apache Hive avec Athena pour Spark, tenez compte des points suivants : + Outre Apache Hive, un seul format de table est pris en charge par bloc-notes. Pour utiliser plusieurs formats de table dans Athena pour Spark, créez un bloc-notes distinct pour chaque format de table. Pour plus d'informations sur la création de blocs-notes dans Athena pour Spark, consultez [Étape 7 : Création de votre propre bloc-notes](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook). + Les formats de table Delta Lake, Hudi et Iceberg ont été testés sur Athena pour Spark en les utilisant AWS Glue comme métastore. Vous pouvez peut-être utiliser d'autres métastores, mais cette utilisation n'est actuellement pas prise en charge. + Pour utiliser les formats de table supplémentaires, remplacez la propriété `spark_catalog` par défaut, comme indiqué dans la console Athena et dans cette documentation. Ces catalogues autres que Hive peuvent lire les tables Hive, en plus de leurs propres formats de table. ## Versions de table Le tableau suivant reprend les versions de table autres que Hive prises en charge dans Amazon Athena pour Apache Spark. **** | Format de table | Version prise en charge | | --- | --- | | Apache Iceberg | 1.2.1 | | Apache Hudi | 0,13 | | Linux Foundation Delta Lake | 2.0.2 | Dans Athena pour Spark, ces fichiers `.jar` de format de table et leurs dépendances sont chargés dans le chemin de classe des pilotes et exécuteurs Spark. Pour plus d’informations sur l’utilisation des formats de table Iceberg, Hudi et Delta Lake à l’aide de Spark SQL dans les blocs-notes Amazon Athena, consultez l’article [Use Amazon Athena with Spark SQL for your open-source transactional table formats](https://aws.amazon.com/blogs/big-data/use-amazon-athena-with-spark-sql-for-your-open-source-transactional-table-formats/) sur le blog *AWS  Big Data Blog*. **Topics** + [Considérations et restrictions](#notebooks-spark-table-formats-considerations-and-limitations) + [Versions de table](#notebooks-spark-table-formats-versions) + [Iceberg](notebooks-spark-table-formats-apache-iceberg.md) + [Hudi](notebooks-spark-table-formats-apache-hudi.md) + [Delta Lake](notebooks-spark-table-formats-linux-foundation-delta-lake.md) # Utilisation de tables Apache Iceberg dans Athena pour Spark. [Apache Iceberg](https://iceberg.apache.org/) est un format de table ouvert pour les jeux de données volumineux dans Amazon Simple Storage Service (Amazon S3). Il vous fournit des performances de requête rapides sur de grandes tables, des validations atomiques, des écritures simultanées et une évolution de table compatible avec SQL. Pour utiliser les tables Apache Iceberg dans Athena pour Spark, configurez les propriétés Spark suivantes. Ces propriétés sont configurées pour vous par défaut dans la console Athena pour Spark lorsque vous choisissez Apache Iceberg comme format de table. Pour les étapes, consultez [Étape 4 : Modification des détails de la session](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) ou [Étape 7 : Création de votre propre bloc-notes](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook). ``` "spark.sql.catalog.spark_catalog": "org.apache.iceberg.spark.SparkSessionCatalog", "spark.sql.catalog.spark_catalog.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog", "spark.sql.catalog.spark_catalog.io-impl": "org.apache.iceberg.aws.s3.S3FileIO", "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions" ``` La procédure suivante explique comment utiliser une table Apache Iceberg dans un bloc-notes Athena pour Spark. Exécutez chaque étape dans une nouvelle cellule du bloc-notes. **Pour utiliser une table Apache Iceberg dans Athena pour Spark.** 1. Définissez les constantes à utiliser dans le bloc-notes. ``` DB_NAME = "NEW_DB_NAME" TABLE_NAME = "NEW_TABLE_NAME" TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket" ``` 1. Créez un Apache Spark [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html). ``` columns = ["language","users_count"] data = [("Golang", 3000)] df = spark.createDataFrame(data, columns) ``` 1. Créez une base de données. ``` spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION)) ``` 1. Créez une table Apache Iceberg vide. ``` spark.sql(""" CREATE TABLE {}.{} ( language string, users_count int ) USING ICEBERG """.format(DB_NAME, TABLE_NAME)) ``` 1. Insérez une ligne de données dans la table. ``` spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME, TABLE_NAME)) ``` 1. Confirmez que vous pouvez interroger la nouvelle table. ``` spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show() ``` Pour plus d'informations et des exemples sur l'utilisation des tables Spark DataFrames et Iceberg, consultez la section [Spark Queries](https://iceberg.apache.org/docs/latest/spark-queries/) dans la documentation d'Apache Iceberg. # Utilisation de tables Apache Hudi dans Athena pour Spark. [https://hudi.apache.org/](https://hudi.apache.org/) est un cadre de gestion de données open source qui simplifie le traitement incrémentiel des données. Les actions d'insertion, de mise à jour, de mise à jour/insertion et de suppression au niveau de l'enregistrement sont traitées avec une plus grande précision, ce qui réduit la surcharge. Pour utiliser les tables Apache Hudi dans Athena pour Spark, configurez les propriétés Spark suivantes. Ces propriétés sont configurées pour vous par défaut dans la console Athena pour Spark lorsque vous choisissez Apache Hudi comme format de table. Pour les étapes, consultez [Étape 4 : Modification des détails de la session](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) ou [Étape 7 : Création de votre propre bloc-notes](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook). ``` "spark.sql.catalog.spark_catalog": "org.apache.spark.sql.hudi.catalog.HoodieCatalog", "spark.serializer": "org.apache.spark.serializer.KryoSerializer", "spark.sql.extensions": "org.apache.spark.sql.hudi.HoodieSparkSessionExtension" ``` La procédure suivante explique comment utiliser une table Apache Hudi dans un bloc-notes Athena pour Spark. Exécutez chaque étape dans une nouvelle cellule du bloc-notes. **Pour utiliser une table Apache Hudi dans Athena pour Spark.** 1. Définissez les constantes à utiliser dans le bloc-notes. ``` DB_NAME = "NEW_DB_NAME" TABLE_NAME = "NEW_TABLE_NAME" TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket" ``` 1. Créez un Apache Spark [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html). ``` columns = ["language","users_count"] data = [("Golang", 3000)] df = spark.createDataFrame(data, columns) ``` 1. Créez une base de données. ``` spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION)) ``` 1. Créez une table Apache Hudi vide. ``` spark.sql(""" CREATE TABLE {}.{} ( language string, users_count int ) USING HUDI TBLPROPERTIES ( primaryKey = 'language', type = 'mor' ); """.format(DB_NAME, TABLE_NAME)) ``` 1. Insérez une ligne de données dans la table. ``` spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME,TABLE_NAME)) ``` 1. Confirmez que vous pouvez interroger la nouvelle table. ``` spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show() ``` # Utilisation de tables Linux Foundation Delta Lake dans Athena pour Spark [Linux Foundation Delta Lake](https://delta.io/) est un format de table que vous pouvez utiliser pour l'analytique du big data. Vous pouvez utiliser Athena pour Spark pour lire directement les tables de Delta Lake stockées dans Amazon S3. Pour utiliser les tables Delta Lake dans Athena pour Spark, configurez les propriétés Spark suivantes. Ces propriétés sont configurées pour vous par défaut dans la console Athena pour Spark lorsque vous choisissez Delta Lake comme format de table. Pour les étapes, consultez [Étape 4 : Modification des détails de la session](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) ou [Étape 7 : Création de votre propre bloc-notes](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook). ``` "spark.sql.catalog.spark_catalog" : "org.apache.spark.sql.delta.catalog.DeltaCatalog", "spark.sql.extensions" : "io.delta.sql.DeltaSparkSessionExtension" ``` La procédure suivante explique comment utiliser une table Delta Lake dans un bloc-notes Athena pour Spark. Exécutez chaque étape dans une nouvelle cellule du bloc-notes. **Pour utiliser une table Delta Lake dans Athena pour Spark** 1. Définissez les constantes à utiliser dans le bloc-notes. ``` DB_NAME = "NEW_DB_NAME" TABLE_NAME = "NEW_TABLE_NAME" TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket" ``` 1. Créez un Apache Spark [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html). ``` columns = ["language","users_count"] data = [("Golang", 3000)] df = spark.createDataFrame(data, columns) ``` 1. Créez une base de données. ``` spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION)) ``` 1. Créez une table Delta Lake vide. ``` spark.sql(""" CREATE TABLE {}.{} ( language string, users_count int ) USING DELTA """.format(DB_NAME, TABLE_NAME)) ``` 1. Insérez une ligne de données dans la table. ``` spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME, TABLE_NAME)) ``` 1. Confirmez que vous pouvez interroger la nouvelle table. ``` spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show() ``` # Utilisation de bibliothèques Python dans Athena pour Spark **Note** Cette page fait référence à l'utilisation des bibliothèques Python dans la version finale du moteur Pyspark version 3. La version 3.5 d'Apache Spark est basée sur [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html) 7.12. Reportez-vous à EMR 7.12 pour les bibliothèques incluses dans cette version. Cette page décrit la terminologie utilisée et la gestion du cycle de vie suivie pour les moteurs d'exécution, les bibliothèques et les packages utilisés dans Amazon Athena pour Apache Spark. ## Définitions + **Amazon Athena pour Apache Spark** est une version personnalisée d'Apache Spark open source. Pour voir la version actuelle, exécutez la commande `print(f'{spark.version}')` dans une cellule du bloc-notes. + Le **moteur d'exécution Athena** est l'environnement dans lequel votre code s'exécute. L'environnement inclut un interpréteur Python et PySpark des bibliothèques. + La **bibliothèque ou le package externe** est un fichier JAR Java ou Scala ou une bibliothèque Python qui ne fait pas partie du moteur d'exécution Athena, mais qui peut être inclus dans les tâches Athena pour Spark. Les packages externes peuvent être créés par Amazon ou par vous. + Le **package pratique** est un ensemble de packages externes sélectionnés par Athena que vous pouvez choisir d'inclure dans vos applications Spark. + L'**offre groupée** combine le moteur d'exécution Athena et un package pratique. + La **bibliothèque utilisateur** est une bibliothèque externe ou un package que vous ajoutez explicitement à votre tâche Athena pour Spark. + La bibliothèque utilisateur est un package externe qui ne fait pas partie d'un package pratique. La bibliothèque utilisateur nécessite un chargement et une installation, comme lorsque vous écrivez des fichiers `.py`, que vous les compressez et que vous ajoutez le fichier `.zip` à votre application. + L'**application Athena pour Spark** est une tâche ou une requête que vous soumettez à Athena pour Spark. ## Gestion du cycle de vie Les sections suivantes décrivent les politiques de gestion des versions et d’obsolescence des packages d’exécution et des packages pratiques utilisés dans Athena pour Spark. ### Gestion des versions et obsolescence du moteur d'exécution Le composant principal du moteur d'exécution Athena est l'interpréteur Python. Python étant un langage évolutif, de nouvelles versions sont publiées régulièrement et la prise en charge des anciennes versions est supprimée. Athena ne vous recommande pas d'exécuter des programmes avec des versions dépréciées de l'interpréteur Python et vous recommande vivement d'utiliser la dernière version du moteur d'exécution Athena chaque fois que cela est possible. Le calendrier d'obsolescence du moteur d'exécution d'Athena est le suivant : 1. Après qu'Athena ait fourni un nouveau moteur d'exécution, Athena continuera à prendre en charge le moteur d'exécution précédent pendant 6 mois. Pendant cette période, Athena appliquera des correctifs de sécurité et des mises à jour au moteur d'exécution précédent. 1. Après 6 mois, Athena mettra fin à la prise en charge de la version précédente. Athena n'appliquera plus les correctifs de sécurité et autres mises à jour du moteur d'exécution précédent. Les applications Spark utilisant l'ancien moteur d'exécution ne pourront plus bénéficier du support technique. 1. Après 12 mois, vous ne pourrez plus mettre à jour ou modifier les applications Spark dans un groupe de travail qui utilise le moteur d'exécution précédent. Nous vous recommandons de mettre à jour vos applications Spark avant la fin de cette période. Après la fin de la période, vous pouvez toujours exécuter les blocs-notes existants, mais tous les blocs-notes qui utilisent encore le moteur d'exécution précédent recevront un avertissement à cet effet. 1. Après 18 mois, vous ne pourrez plus exécuter de tâches dans le groupe de travail en utilisant le moteur d'exécution précédent. ### Gestion des versions et obsolescence des packages pratiques Le contenu des packages pratiques évolue au fil du temps. Athena ajoute, supprime ou améliore occasionnellement ces packages pratiques. Athena applique les directives suivantes pour les packages pratiques : + Les packages pratiques ont un schéma de gestion des versions simple comme 1, 2, 3. + Chaque version de package pratique comprend des versions spécifiques de packages externes. Une fois qu'Athena a créé un package pratique, l'ensemble des packages externes du package pratique et leurs versions correspondantes ne changent pas. + Athena crée une nouvelle version de package pratique lorsqu'elle inclut un nouveau package externe, supprime un package externe ou met à niveau la version d'un ou de plusieurs packages externes. Athena rend obsolète un package pratique lorsqu'elle rend obsolète le moteur d'exécution Athena que le package utilise. Athena peut rendre les paquets obsolètes plus tôt afin de limiter le nombre de packages qu'elle prend en charge. Le calendrier d'obsolescence des packages pratiques suit le calendrier d'obsolescence du moteur d'exécution d'Athena. # Liste des bibliothèques Python préinstallées Les bibliothèques Python préinstallées comprennent les bibliothèques suivantes. ``` boto3==1.24.31 botocore==1.27.31 certifi==2022.6.15 charset-normalizer==2.1.0 cycler==0.11.0 cython==0.29.30 docutils==0.19 fonttools==4.34.4 idna==3.3 jmespath==1.0.1 joblib==1.1.0 kiwisolver==1.4.4 matplotlib==3.5.2 mpmath==1.2.1 numpy==1.23.1 packaging==21.3 pandas==1.4.3 patsy==0.5.2 pillow==9.2.0 plotly==5.9.0 pmdarima==1.8.5 pyathena==2.9.6 pyparsing==3.0.9 python-dateutil==2.8.2 pytz==2022.1 requests==2.28.1 s3transfer==0.6.0 scikit-learn==1.1.1 scipy==1.8.1 seaborn==0.11.2 six==1.16.0 statsmodels==0.13.2 sympy==1.10.1 tenacity==8.0.1 threadpoolctl==3.1.0 urllib3==1.26.10 pyarrow==9.0.0 ``` ## Remarques + MLlib (bibliothèque d'apprentissage automatique Apache Spark) et le `pyspark.ml` package ne sont pas pris en charge. + `pip install` n’est actuellement pas pris en charge dans les sessions Athena pour Spark. Pour plus d’informations sur l’importation de bibliothèques Python dans Amazon Athena pour Apache Spark, consultez [Importation de fichiers et de bibliothèques Python dans Athena pour Spark](notebooks-import-files-libraries.md). # Importation de fichiers et de bibliothèques Python dans Athena pour Spark Ce document fournit des exemples sur la manière d'importer des fichiers et des bibliothèques Python vers Amazon Athena pour Apache Spark. ## Considérations et restrictions + **Version Python** : Athena pour Spark utilise actuellement la version 3.9.16 de Python. Notez que les packages Python sont sensibles aux versions mineures de Python. + **Athena pour l'architecture Spark —** Athena pour Spark utilise Amazon Linux 2 pour l'architecture. ARM64 Notez que certaines bibliothèques Python ne distribuent pas de fichiers binaires pour cette architecture. + **Objets partagés binaires (SOs)** : comme la SparkContext [addPyFile](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.addPyFile.html)méthode ne détecte pas les objets partagés binaires, elle ne peut pas être utilisée dans Athena for Spark pour ajouter des packages Python qui dépendent d'objets partagés. + **Ensembles de données distribués résilients (RDDs)** : ne [RDDs](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.RDD.html)sont pas pris en charge. + **DataFrame.forEach — La méthode .foreach n'**est pas prise en PySpark [DataFramecharge.](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.foreach.html) ## Exemples Les exemples utilisent les conventions suivantes. + Emplacement Amazon S3 réservé `s3://amzn-s3-demo-bucket`. Remplacez-le par l'emplacement de votre propre compartiment S3. + Tous les blocs de code qui s'exécutent à partir d'un shell Unix sont représentés sous *directory\$1name* `$` la forme. Par exemple, la commande `ls` dans le répertoire `/tmp` et sa sortie s'affichent comme suit : ``` /tmp $ ls ``` **Sortie** ``` file1 file2 ``` ## Importation de fichiers texte à utiliser dans les calculs Les exemples de cette rubrique montrent comment importer des fichiers texte pour les utiliser dans les calculs de vos carnets dans Athena pour Spark. ### Ajout d’un fichier à un bloc-notes après son écriture dans le répertoire temporaire local L'exemple suivant montre comment écrire un fichier dans un répertoire temporaire local, l'ajouter à un bloc-notes et le tester. ``` import os from pyspark import SparkFiles tempdir = '/tmp/' path = os.path.join(tempdir, "test.txt") with open(path, "w") as testFile: _ = testFile.write("5") sc.addFile(path) def func(iterator): with open(SparkFiles.get("test.txt")) as testFile: fileVal = int(testFile.readline()) return [x * fileVal for x in iterator] #Test the file from pyspark.sql.functions import udf from pyspark.sql.functions import col udf_with_import = udf(func) df = spark.createDataFrame([(1, "a"), (2, "b")]) df.withColumn("col", udf_with_import(col('_2'))).show() ``` **Sortie** ``` Calculation completed. +---+---+-------+ | _1| _2| col| +---+---+-------+ | 1| a|[aaaaa]| | 2| b|[bbbbb]| +---+---+-------+ ``` ### Importer un fichier à partir d’Amazon S3 L'exemple suivant montre comment importer un fichier à partir d'Amazon S3 dans un bloc-notes et le tester. **Importation d'un fichier à partir d'Amazon S3 dans un bloc-notes** 1. Créez un fichier `test.txt` dont le nom comporte une seule ligne contenant la valeur `5`. 1. Ajoutez le fichier à un compartiment dans Amazon S3. Cet exemple utilise l'emplacement `s3://amzn-s3-demo-bucket`. 1. Utilisez le code suivant pour importer le fichier dans votre bloc-notes et le tester. ``` from pyspark import SparkFiles sc.addFile('s3://amzn-s3-demo-bucket/test.txt') def func(iterator): with open(SparkFiles.get("test.txt")) as testFile: fileVal = int(testFile.readline()) return [x * fileVal for x in iterator] #Test the file from pyspark.sql.functions import udf from pyspark.sql.functions import col udf_with_import = udf(func) df = spark.createDataFrame([(1, "a"), (2, "b")]) df.withColumn("col", udf_with_import(col('_2'))).show() ``` **Sortie** ``` Calculation completed. +---+---+-------+ | _1| _2| col| +---+---+-------+ | 1| a|[aaaaa]| | 2| b|[bbbbb]| +---+---+-------+ ``` ## Ajout de fichiers Python Les exemples de cette rubrique montrent comment ajouter des fichiers et des bibliothèques Python à vos blocs-notes Spark dans Athena. ### Ajout de fichiers Python et enregistrement d’une UDF L'exemple suivant montre comment ajouter des fichiers Python à partir d'Amazon S3 à votre bloc-notes et enregistrer un UDF. **Ajout de fichiers Python à votre bloc-notes et enregistrement d'un UDF** 1. En utilisant votre propre emplacement Amazon S3, créez le fichier `s3://amzn-s3-demo-bucket/file1.py` avec le contenu suivant : ``` def xyz(input): return 'xyz - udf ' + str(input); ``` 1. Dans le même emplacement S3, créez le fichier `s3://amzn-s3-demo-bucket/file2.py` avec le contenu suivant : ``` from file1 import xyz def uvw(input): return 'uvw -> ' + xyz(input); ``` 1. Dans votre bloc-notes Athena pour Spark, exécutez les commandes suivantes. ``` sc.addPyFile('s3://amzn-s3-demo-bucket/file1.py') sc.addPyFile('s3://amzn-s3-demo-bucket/file2.py') def func(iterator): from file2 import uvw return [uvw(x) for x in iterator] from pyspark.sql.functions import udf from pyspark.sql.functions import col udf_with_import = udf(func) df = spark.createDataFrame([(1, "a"), (2, "b")]) df.withColumn("col", udf_with_import(col('_2'))).show(10) ``` **Sortie** ``` Calculation started (calculation_id=1ec09e01-3dec-a096-00ea-57289cdb8ce7) in (session=c8c09e00-6f20-41e5-98bd-4024913d6cee). Checking calculation status... Calculation completed. +---+---+--------------------+ | _1| _2| col| +---+---+--------------------+ | 1 | a|[uvw -> xyz - ud... | | 2 | b|[uvw -> xyz - ud... | +---+---+--------------------+ ``` ### Importation d’un fichier .zip Python Vous pouvez utiliser Python `addPyFile` et ses méthodes `import` pour importer un fichier .zip Python dans votre bloc-notes. **Note** Les fichiers `.zip` que vous importez dans Athena Spark peuvent inclure uniquement des packages Python. Par exemple, l'inclusion de packages contenant des fichiers basés sur le langage C n'est pas prise en charge. **Pour importer un fichier `.zip` Python dans votre bloc-notes** 1. Sur votre ordinateur local, dans un répertoire de bureau tel que `\tmp`, créez un répertoire appelé `moduletest`. 1. Dans le répertoire `moduletest`, créez un fichier nommé `hello.py` avec les contenus suivants : ``` def hi(input): return 'hi ' + str(input); ``` 1. Dans le même répertoire, ajoutez un fichier vide portant le nom `__init__.py`. Si vous listez le contenu du répertoire, il devrait maintenant ressembler à ce qui suit. ``` /tmp $ ls moduletest __init__.py hello.py ``` 1. Utilisez la commande `zip` pour placer les deux fichiers du module dans un fichier appelé `moduletest.zip`. ``` moduletest $ zip -r9 ../moduletest.zip * ``` 1. Chargez les fichiers `.zip` dans votre compartiment Amazon S3. 1. Utilisez le code suivant pour importer le fichier `.zip` Python dans votre bloc-notes. ``` sc.addPyFile('s3://amzn-s3-demo-bucket/moduletest.zip') from moduletest.hello import hi from pyspark.sql.functions import udf from pyspark.sql.functions import col hi_udf = udf(hi) df = spark.createDataFrame([(1, "a"), (2, "b")]) df.withColumn("col", hi_udf(col('_2'))).show() ``` **Sortie** ``` Calculation started (calculation_id=6ec09e8c-6fe0-4547-5f1b-6b01adb2242c) in (session=dcc09e8c-3f80-9cdc-bfc5-7effa1686b76). Checking calculation status... Calculation completed. +---+---+----+ | _1| _2| col| +---+---+----+ | 1| a|hi a| | 2| b|hi b| +---+---+----+ ``` ### Importation de deux versions d’une bibliothèque Python en tant que modules distincts Les exemples de code suivants montrent comment ajouter et importer deux versions différentes d'une bibliothèque Python à partir d'un emplacement dans Amazon S3 en tant que deux modules distincts. Le code ajoute chaque fichier de la bibliothèque à partir de S3, l'importe, puis imprime la version de la bibliothèque pour vérifier l'importation. ``` sc.addPyFile('s3://amzn-s3-demo-bucket/python-third-party-libs-test/simplejson_v3_15.zip') sc.addPyFile('s3://amzn-s3-demo-bucket/python-third-party-libs-test/simplejson_v3_17_6.zip') import simplejson_v3_15 print(simplejson_v3_15.__version__) ``` **Sortie** ``` 3.15.0 ``` ``` import simplejson_v3_17_6 print(simplejson_v3_17_6.__version__) ``` **Sortie** ``` 3.17.6 ``` ### Importation d’un fichier .zip Python depuis PyPI Cet exemple utilise la commande `pip` pour télécharger un fichier .zip Python du projet [bpabel/piglatin](https://github.com/bpabel/piglatin) à partir du référentiel [Python Package Index (PyPI)](https://pypi.org/). **Importer un fichier .zip Python à partir de PyPI** 1. Sur votre bureau local, utilisez les commandes suivantes pour créer un répertoire appelé `testpiglatin` et un environnement virtuel. ``` /tmp $ mkdir testpiglatin /tmp $ cd testpiglatin testpiglatin $ virtualenv . ``` **Sortie** ``` created virtual environment CPython3.9.6.final.0-64 in 410ms creator CPython3Posix(dest=/private/tmp/testpiglatin, clear=False, no_vcs_ignore=False, global=False) seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/Users/user1/Library/Application Support/virtualenv) added seed packages: pip==22.0.4, setuptools==62.1.0, wheel==0.37.1 activators BashActivator,CShellActivator,FishActivator,NushellActivator,PowerShellActivator,PythonActivator ``` 1. Créez un sous-répertoire appelé `unpacked` pour contenir le projet. ``` testpiglatin $ mkdir unpacked ``` 1. Utilisez la commande `pip` pour installer le projet dans le répertoire `unpacked`. ``` testpiglatin $ bin/pip install -t $PWD/unpacked piglatin ``` **Sortie** ``` Collecting piglatin Using cached piglatin-1.0.6-py2.py3-none-any.whl (3.1 kB) Installing collected packages: piglatin Successfully installed piglatin-1.0.6 ``` 1. Vérifiez le contenu du répertoire. ``` testpiglatin $ ls ``` **Sortie** ``` bin lib pyvenv.cfg unpacked ``` 1. Accédez au répertoire `unpacked` et affichez le contenu. ``` testpiglatin $ cd unpacked unpacked $ ls ``` **Sortie** ``` piglatin piglatin-1.0.6.dist-info ``` 1. Utilisez la commande `zip` pour placer le contenu du projet piglatin dans un fichier appelé `library.zip`. ``` unpacked $ zip -r9 ../library.zip * ``` **Sortie** ``` adding: piglatin/ (stored 0%) adding: piglatin/__init__.py (deflated 56%) adding: piglatin/__pycache__/ (stored 0%) adding: piglatin/__pycache__/__init__.cpython-39.pyc (deflated 31%) adding: piglatin-1.0.6.dist-info/ (stored 0%) adding: piglatin-1.0.6.dist-info/RECORD (deflated 39%) adding: piglatin-1.0.6.dist-info/LICENSE (deflated 41%) adding: piglatin-1.0.6.dist-info/WHEEL (deflated 15%) adding: piglatin-1.0.6.dist-info/REQUESTED (stored 0%) adding: piglatin-1.0.6.dist-info/INSTALLER (stored 0%) adding: piglatin-1.0.6.dist-info/METADATA (deflated 48%) ``` 1. (Facultatif) Utilisez les commandes suivantes pour tester l'importation localement. 1. Définissez le chemin Python vers l'emplacement du fichier `library.zip` et démarrez Python. ``` /home $ PYTHONPATH=/tmp/testpiglatin/library.zip /home $ python3 ``` **Sortie** ``` Python 3.9.6 (default, Jun 29 2021, 06:20:32) [Clang 12.0.0 (clang-1200.0.32.29)] on darwin Type "help", "copyright", "credits" or "license" for more information. ``` 1. Importez la bibliothèque et exécutez une commande de test. ``` >>> import piglatin >>> piglatin.translate('hello') ``` **Sortie** ``` 'ello-hay' ``` 1. Utilisez des commandes telles que les suivantes pour ajouter le fichier `.zip` à partir d'Amazon S3, l'importer dans votre bloc-notes dans Athena et le tester. ``` sc.addPyFile('s3://amzn-s3-demo-bucket/library.zip') import piglatin piglatin.translate('hello') from pyspark.sql.functions import udf from pyspark.sql.functions import col hi_udf = udf(piglatin.translate) df = spark.createDataFrame([(1, "hello"), (2, "world")]) df.withColumn("col", hi_udf(col('_2'))).show() ``` **Sortie** ``` Calculation started (calculation_id=e2c0a06e-f45d-d96d-9b8c-ff6a58b2a525) in (session=82c0a06d-d60e-8c66-5d12-23bcd55a6457). Checking calculation status... Calculation completed. +---+-----+--------+ | _1| _2| col| +---+-----+--------+ | 1|hello|ello-hay| | 2|world|orld-way| +---+-----+--------+ ``` ### Importation depuis PyPI d’un fichier .zip Python comportant des dépendances Cet exemple importe le package [md2gemini](https://github.com/makeworld-the-better-one/md2gemini), qui convertit le texte en Markdown au format de texte [Gemini](https://gemini.circumlunar.space/), à partir de PyPI. Le package a les [dépendances](https://libraries.io/pypi/md2gemini) suivantes : ``` cjkwrap mistune wcwidth ``` **Importation d'un fichier .zip Python comportant des dépendances** 1. Sur votre ordinateur local, utilisez les commandes suivantes pour créer un répertoire appelé `testmd2gemini` et un environnement virtuel. ``` /tmp $ mkdir testmd2gemini /tmp $ cd testmd2gemini testmd2gemini$ virtualenv . ``` 1. Créez un sous-répertoire appelé `unpacked` pour contenir le projet. ``` testmd2gemini $ mkdir unpacked ``` 1. Utilisez la commande `pip` pour installer le projet dans le répertoire `unpacked`. ``` /testmd2gemini $ bin/pip install -t $PWD/unpacked md2gemini ``` **Sortie** ``` Collecting md2gemini Downloading md2gemini-1.9.0-py3-none-any.whl (31 kB) Collecting wcwidth Downloading wcwidth-0.2.5-py2.py3-none-any.whl (30 kB) Collecting mistune<3,>=2.0.0 Downloading mistune-2.0.2-py2.py3-none-any.whl (24 kB) Collecting cjkwrap Downloading CJKwrap-2.2-py2.py3-none-any.whl (4.3 kB) Installing collected packages: wcwidth, mistune, cjkwrap, md2gemini Successfully installed cjkwrap-2.2 md2gemini-1.9.0 mistune-2.0.2 wcwidth-0.2.5 ... ``` 1. Accédez au répertoire `unpacked` et vérifiez le contenu. ``` testmd2gemini $ cd unpacked unpacked $ ls -lah ``` **Sortie** ``` total 16 drwxr-xr-x 13 user1 wheel 416B Jun 7 18:43 . drwxr-xr-x 8 user1 wheel 256B Jun 7 18:44 .. drwxr-xr-x 9 user1 staff 288B Jun 7 18:43 CJKwrap-2.2.dist-info drwxr-xr-x 3 user1 staff 96B Jun 7 18:43 __pycache__ drwxr-xr-x 3 user1 staff 96B Jun 7 18:43 bin -rw-r--r-- 1 user1 staff 5.0K Jun 7 18:43 cjkwrap.py drwxr-xr-x 7 user1 staff 224B Jun 7 18:43 md2gemini drwxr-xr-x 10 user1 staff 320B Jun 7 18:43 md2gemini-1.9.0.dist-info drwxr-xr-x 12 user1 staff 384B Jun 7 18:43 mistune drwxr-xr-x 8 user1 staff 256B Jun 7 18:43 mistune-2.0.2.dist-info drwxr-xr-x 16 user1 staff 512B Jun 7 18:43 tests drwxr-xr-x 10 user1 staff 320B Jun 7 18:43 wcwidth drwxr-xr-x 9 user1 staff 288B Jun 7 18:43 wcwidth-0.2.5.dist-info ``` 1. Utilisez la commande `zip` pour placer le contenu du projet md2gemini dans un fichier appelé `md2gemini.zip`. ``` unpacked $ zip -r9 ../md2gemini * ``` **Sortie** ``` adding: CJKwrap-2.2.dist-info/ (stored 0%) adding: CJKwrap-2.2.dist-info/RECORD (deflated 37%) .... adding: wcwidth-0.2.5.dist-info/INSTALLER (stored 0%) adding: wcwidth-0.2.5.dist-info/METADATA (deflated 62%) ``` 1. (Facultatif) Utilisez les commandes suivantes pour vérifier que la bibliothèque fonctionne sur votre ordinateur local. 1. Définissez le chemin Python vers l'emplacement du fichier `md2gemini.zip` et démarrez Python. ``` /home $ PYTHONPATH=/tmp/testmd2gemini/md2gemini.zip /home python3 ``` 1. Importez la bibliothèque et exécutez un test. ``` >>> from md2gemini import md2gemini >>> print(md2gemini('[abc](https://abc.def)')) ``` **Sortie** ``` https://abc.def abc ``` 1. Utilisez les commandes suivantes pour ajouter le fichier `.zip` à partir d'Amazon S3, l'importer dans votre bloc-notes dans Athena et effectuer un test non UDF. ``` # (non udf test) sc.addPyFile('s3://amzn-s3-demo-bucket/md2gemini.zip') from md2gemini import md2gemini print(md2gemini('[abc](https://abc.def)')) ``` **Sortie** ``` Calculation started (calculation_id=0ac0a082-6c3f-5a8f-eb6e-f8e9a5f9bc44) in (session=36c0a082-5338-3755-9f41-0cc954c55b35). Checking calculation status... Calculation completed. => https://abc.def (https://abc.def/) abc ``` 1. Utilisez les commandes suivantes pour effectuer un test UDF. ``` # (udf test) from pyspark.sql.functions import udf from pyspark.sql.functions import col from md2gemini import md2gemini hi_udf = udf(md2gemini) df = spark.createDataFrame([(1, "[first website](https://abc.def)"), (2, "[second website](https://aws.com)")]) df.withColumn("col", hi_udf(col('_2'))).show() ``` **Sortie** ``` Calculation started (calculation_id=60c0a082-f04d-41c1-a10d-d5d365ef5157) in (session=36c0a082-5338-3755-9f41-0cc954c55b35). Checking calculation status... Calculation completed. +---+--------------------+--------------------+ | _1| _2| col| +---+--------------------+--------------------+ | 1|[first website](h...|=> https://abc.de...| | 2|[second website](...|=> https://aws.co...| +---+--------------------+--------------------+ ``` # Utilisation de propriétés Spark pour spécifier une configuration personnalisée Lorsque vous créez ou modifiez une session dans Amazon Athena pour Apache Spark, vous pouvez utiliser les [propriétés Spark](https://spark.apache.org/docs/latest/configuration.html#spark-properties) pour spécifier des fichiers `.jar`, des packages ou une autre configuration personnalisée pour la session. Pour définir vos propriétés Spark, vous pouvez utiliser la console Athena AWS CLI, ou l'API Athena. ## Utilisation de la console Athena pour spécifier des propriétés Spark Dans la console Athena, vous pouvez spécifier vos propriétés Spark lorsque vous [créez un bloc-notes](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) ou [modifiez une session en cours](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details). **Pour ajouter des propriétés dans la boîte de dialogue **Créer un bloc-notes** ou **Modifier les détails de la session**** 1. Développez les **propriétés Spark**. 1. Pour ajouter vos propriétés, utilisez l'option **Modifier dans la table** ou **Modifier dans JSON**. + Pour l'option **Modifier dans la table**, choisissez **Ajouter une propriété** pour ajouter une propriété, ou choisissez **Supprimer** pour supprimer une propriété. Utilisez les champs **Clé** et **Valeur** pour saisir les noms des propriétés et leurs valeurs. + Pour ajouter un fichier `.jar` personnalisé, utilisez la propriété `spark.jars`. + Utilisez la propriété `spark.jars.packages` pour spécifier un fichier de package. + Pour saisir et modifier directement votre configuration, choisissez l'option **Modifier dans JSON**. Dans l'éditeur de texte JSON, vous pouvez effectuer les tâches suivantes : + Choisissez **Copier** pour copier le texte JSON dans le presse-papier. + Choisissez **Effacer** pour supprimer tout le texte de l'éditeur JSON. + Choisissez l'icône des paramètres (engrenage) pour configurer l'encapsulage des lignes ou choisissez un thème de couleur pour l'éditeur JSON. ### Remarques + Vous pouvez définir des propriétés dans Athena pour Spark, ce qui revient à définir les [propriétés de Spark](https://spark.apache.org/docs/latest/configuration.html#spark-properties) directement sur un [SparkConf](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkConf.html)objet. + Commencez toutes les propriétés Spark par le préfixe `spark.`. Les propriétés comportant d'autres préfixes sont ignorées. + Les propriétés Spark ne sont pas toutes disponibles pour une configuration personnalisée sur Athena. Si vous soumettez une demande `StartSession` dont la configuration est restreinte, la session ne démarre pas. + Vous ne pouvez pas utiliser le préfixe `spark.athena.` car il est réservé. ## Utilisez l'API AWS CLI ou Athena pour fournir une configuration personnalisée Pour utiliser l'API AWS CLI ou Athena afin de configurer votre session, utilisez l'action [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)API ou la commande CLI [start-session](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/start-session.html). Dans votre `StartSession` demande, utilisez le `SparkProperties` champ d'[EngineConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EngineConfiguration.html)objet pour transmettre vos informations de configuration au format JSON. Cela démarre une session avec la configuration spécifiée. Pour spécifier des propriétés Spark personnalisées à partir du AWS CLI, utilisez `engine-configuration` la configuration lorsque vous démarrez une session interactive. ``` aws athena start-session \ --region "REGION" --work-group "WORKGROUP" \ --engine-configuration '{ "Classifications": [{ "Name": "spark-defaults", "Properties": { "spark.dynamicAllocation.minExecutors": "1", "spark.dynamicAllocation.initialExecutors": "2", "spark.dynamicAllocation.maxExecutors": "10", "spark.dynamicAllocation.executorIdleTimeout": "300" } }] }' ``` Vous pouvez également spécifier les paramètres de configuration par défaut au niveau du groupe de travail à l'aide de l'action `CreateWorkgroup` API ou de l'action `UpdateWorkgroup` API. Les paramètres de configuration par défaut définis au sein du groupe de travail s'appliquent à toutes les sessions démarrées pour ce groupe de travail. Pour spécifier les propriétés Spark par défaut à partir de celles AWS CLI d'un groupe de travail, utilisez la `engine-configuration` configuration lors de la création d'un nouveau groupe de travail : ``` aws athena create-work-group \ --region "REGION" \ --name "WORKGROUP_NAME" \ --configuration '{ "EngineVersion": { "SelectedEngineVersion": "Apache Spark version 3.5" }, "ExecutionRole": "EXECUTION_ROLE", "EngineConfiguration": { "Classifications": [ { "Name": "spark-defaults", "Properties": { "spark.dynamicAllocation.minExecutors": "1", "spark.dynamicAllocation.initialExecutors": "2", "spark.dynamicAllocation.maxExecutors": "10", "spark.dynamicAllocation.executorIdleTimeout": "300" } } ] } }' ``` Pour modifier les propriétés Spark par défaut d'un groupe de travail, utilisez la AWS CLI `engine-configuration` configuration lors de la mise à jour d'un groupe de travail. Les modifications s'appliquent aux nouvelles sessions interactives à venir. ``` aws athena update-work-group \ --region "REGION" \ --work-group "WORKGROUP_NAME" \ --configuration-updates '{ "EngineVersion": { "SelectedEngineVersion": "Apache Spark version 3.5" }, "ExecutionRole": "EXECUTION_ROLE", "EngineConfiguration": { "Classifications": [ { "Name": "spark-defaults", "Properties": { "spark.dynamicAllocation.minExecutors": "1", "spark.dynamicAllocation.initialExecutors": "2", "spark.dynamicAllocation.maxExecutors": "12", "spark.dynamicAllocation.executorIdleTimeout": "300" } } ] } }' ``` # Formats de données et de stockage pris en charge Le tableau suivant présente les formats pris en charge en mode natif dans Athena pour Apache Spark. **** | **Format de données** | **Lecture** | **Write** (Écrire) | **Compression d'écriture** | | --- | --- | --- | --- | | parquet | oui | oui | aucun, non compressé, snappy, gzip | | orc | oui | oui | aucun, snappy, zlib, lzo | | json | oui | oui | bzip2, gzip, deflate | | csv | oui | oui | bzip2, gzip, deflate | | text | oui | oui | aucun, bzip2, gzip, deflate | | fichier binaire | oui | N/A | N/A | # Surveillez Apache Spark à l'aide de CloudWatch métriques Athena publie des statistiques relatives au calcul sur Amazon CloudWatch lorsque l'**[Publish CloudWatch metrics](notebooks-spark-getting-started.md#notebook-gs-metrics)**option pour votre groupe de travail compatible avec Spark est sélectionnée. Vous pouvez créer des tableaux de bord personnalisés, définir des alarmes et des déclencheurs sur les métriques de la CloudWatch console. Athena publie la métrique suivante sur la CloudWatch console sous l'espace de `AmazonAthenaForApacheSpark` noms : + `DPUCount`— nombre de personnes DPUs consommées pendant la session pour exécuter les calculs. Cette métrique a les dimensions suivantes : + `SessionId` – L'ID de la session dans laquelle les calculs sont soumis. + `WorkGroup` – nom du groupe de travail. **Pour consulter les statistiques des groupes de travail compatibles avec Spark dans la console Amazon CloudWatch** 1. Ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Dans le panneau de navigation, sélectionnez **Métriques**, **Toutes les métriques**. 1. Sélectionnez l'espace de noms **AmazonAthenaForApacheSpark**. **Pour afficher les métriques grâce à la CLI** + Effectuez l’une des actions suivantes : + Pour répertorier les métriques des groupes de travail compatibles avec Athena Spark, ouvrez une invite de commande et utilisez la commande suivante : ``` aws cloudwatch list-metrics --namespace "AmazonAthenaForApacheSpark" ``` + Pour répertorier toutes les métriques disponibles, utilisez la commande suivante : ``` aws cloudwatch list-metrics ``` ## Liste des CloudWatch métriques et des dimensions pour les calculs d'Apache Spark dans Athena Si vous avez activé CloudWatch les métriques dans votre groupe de travail Athena compatible Spark, Athena envoie la métrique suivante à chaque groupe de travail. CloudWatch La métrique utilise l'espace de noms `AmazonAthenaForApacheSpark`. **** | Nom des métriques | Description | | --- | --- | | DPUCount | Nombre DPUs (d'unités de traitement des données) consommées pendant la session pour exécuter les calculs. Un DPU est une mesure relative de la puissance de traitement composée de 4 V de capacité CPUs de calcul et de 16 Go de mémoire. | Cette métrique a les dimensions suivantes. | Dimension | Description | | --- | --- | | SessionId | L'ID de la session dans laquelle les calculs sont soumis. | | WorkGroup | Le nom du groupe de travail. | ## Liste des CloudWatch métriques et des dimensions des sessions interactives Athena Spark Dans la version 3.5 d'Apache Spark, si vous avez activé CloudWatch les métriques dans votre groupe de travail Athena Spark, Athena envoie la métrique suivante à. CloudWatch La métrique utilise l'espace de noms `AmazonAthenaForApacheSpark`. **** | Nom | Description | | --- | --- | | DPUConsumed | Le nombre de requêtes DPUs activement consommées par des requêtes en cours d'exécution à un moment donné dans le groupe de travail. | Cette métrique a les dimensions suivantes. | Dimension | Description | | --- | --- | | Compte | L'identifiant AWS du compte. | | WorkGroup | Le nom du groupe de travail. | # Attribution des coûts au niveau de la session À partir de la version 3.5 d'Apache Spark, Athena permet le suivi des coûts pour chaque session. Vous pouvez définir des balises de répartition des coûts lors du démarrage d'une session et les coûts déclarés pour une session apparaîtront dans Cost Explorer ou dans les rapports de répartition des coûts de AWS facturation. Vous pouvez également appliquer des balises de répartition des coûts au niveau du groupe de travail et celles-ci sont copiées sur toutes les sessions démarrées dans ce groupe de travail. ## Utilisation de l'attribution des coûts au niveau de la session Par défaut, toutes les balises de répartition des coûts spécifiées au niveau du groupe de travail sont copiées vers les sessions interactives démarrées dans ce groupe de travail. Pour désactiver les balises à copier depuis le groupe de travail lors du démarrage d'une session interactive à partir du AWS CLI : ``` aws athena start-session \ --region "REGION" \ --work-group "WORKGROUP" \ --tags '[ { "Key": "tag_key", "Value": "tag_value" } ]' \ --no-copy-work-group-tags ``` Pour permettre la copie des balises depuis le groupe de travail lors du démarrage d'une session interactive à partir du AWS CLI : ``` aws athena start-session \ --region "REGION" \ --work-group "WORKGROUP" \ --copy-work-group-tags ``` ## Considérations et restrictions + Les balises de session remplacent les balises de groupe de travail comportant les mêmes clés. # Journalisation et surveillance des sessions Apache Spark À partir de la version 3.5 d'Apache Spark, vous pouvez spécifier la gestion, Amazon S3 ou la CloudWatch journalisation comme options de journalisation. Dans le cas de la journalisation gérée et de la journalisation S3, le tableau suivant répertorie les emplacements des journaux et la disponibilité de l'interface utilisateur auxquels vous pouvez vous attendre si vous choisissez ces options. **** | Option | Journaux d'événements | Journaux de conteneurs | Interface utilisateur de l'application | | --- | --- | --- | --- | | Journalisation gérée (par défaut) | Stocké dans un compartiment S3 géré | Stocké dans un compartiment S3 géré | Pris en charge | | Journalisation gérée et compartiment S3 | Stocké aux deux endroits | Stocké dans un compartiment S3 | Pris en charge | | Compartiment Amazon S3 | Stocké dans un compartiment S3 | Stocké dans un compartiment S3 | Non pris en charge 1 | 1 Nous vous suggérons de conserver l'option de journalisation gérée sélectionnée. Dans le cas contraire, vous ne pouvez pas utiliser l'application intégrée UIs. ## Journalisation gérée Par défaut, les groupes de travail Athena Spark stockent les journaux des applications en toute sécurité dans des compartiments S3 gérés par des services pendant une durée maximale de 30 jours. Vous pouvez éventuellement fournir une clé KMS (key id, arn, alias ou alias arn) que le service utilisera pour chiffrer les journaux gérés. ``` aws athena start-session \ --work-group "WORKGROUP" \ --monitoring-configuration '{ "ManagedLoggingConfiguration": { "Enabled": true, "KmsKey": "KMS_KEY" }, }' --engine-configuration '' ``` **Note** Si vous désactivez la journalisation gérée, Athena ne pourra pas résoudre les problèmes liés à vos sessions à votre place. Exemple : vous n'accéderez pas à l'interface utilisateur Spark-UI depuis les blocs-notes Amazon SageMaker AI Studio ou en utilisant l'API. `GetResourceDashboard` Pour désactiver cette option depuis le AWS CLI, utilisez la `ManagedLoggingConfiguration` configuration lorsque vous démarrez une session interactive. ``` aws athena start-session \ --work-group "WORKGROUP" \ --monitoring-configuration '{ "ManagedLoggingConfiguration": { "Enabled": false }, }' --engine-configuration '' ``` ### Autorisations requises pour la journalisation gérée Si vous avez fourni une clé KMS, vous aurez besoin des autorisations suivantes dans la politique d'autorisation pour le rôle d'exécution. ``` { "Action": [ "kms:Encrypt", "kms:Decrypt", "kms:ReEncrypt*", "kms:GenerateDataKey*", "kms:DescribeKey" ], "Resource": "*", "Effect": "Allow" } ``` ## Journalisation sur Amazon S3 Vous pouvez configurer la livraison des journaux vers les compartiments Amazon S3. Pour activer la livraison du journal S3 à partir du AWS CLI, utilisez la `S3LoggingConfiguration` configuration lorsque vous démarrez une session interactive. ``` aws athena start-session \ --work-group "WORKGROUP" \ --monitoring-configuration '{ "S3LoggingConfiguration": { "Enabled":true, "LogLocation": "s3://bucket/", }, }' --engine-configuration '' ``` Vous pouvez éventuellement fournir une clé KMS (identifiant de clé, arn, alias ou alias arn) que le service utilisera pour chiffrer les journaux S3. ``` aws athena start-session \ --work-group "WORKGROUP" \ --monitoring-configuration '{ "S3LoggingConfiguration": { "Enabled":true, "LogLocation": "s3://bucket/", "KmsKey": "KMS_KEY" }, }' --engine-configuration '' ``` ### Autorisations requises pour la livraison des journaux à Amazon S3 Avant que vos sessions puissent envoyer des journaux aux compartiments Amazon S3, incluez les autorisations suivantes dans la politique d'autorisation pour le rôle d'exécution. ``` { "Action": "s3:*", "Resource": "*", "Effect": "Allow" } ``` Si vous avez fourni une clé KMS, vous aurez également besoin des autorisations suivantes dans la politique d'autorisation pour le rôle d'exécution. ``` { "Action": [ "kms:Encrypt", "kms:Decrypt", "kms:ReEncrypt*", "kms:GenerateDataKey*", "kms:DescribeKey" ], "Resource": "*", "Effect": "Allow" } ``` Si la clé et le compartiment KMS ne proviennent pas du même compte, KMS doit autoriser le principal de service S3. ``` { "Effect": "Allow", "Principal": { "Service": "s3.amazonaws.com" }, "Action": [ "kms:Encrypt", "kms:Decrypt", "kms:GenerateDataKey*" ], "Resource": "*", "Condition": { "StringEquals": { "aws:SourceAccount": "ACCOUNT_HAVING_KMS_KEY" } } } ``` ## CloudWatch journalisation Vous pouvez configurer la livraison des journaux aux groupes de CloudWatch journaux. Pour activer la livraison du journal S3 à partir du AWS CLI, utilisez la `CloudWatchLoggingConfiguration` configuration lorsque vous démarrez une session interactive. ``` aws athena start-session \ --work-group "WORKGROUP" \ --monitoring-configuration '{ "CloudWatchLoggingConfiguration": { "Enabled": true, "LogGroup": "/aws/athena/sessions/${workgroup}", "LogStreamNamePrefix": "session-" } }' --engine-configuration '' ``` Tous les journaux seront fournis par défaut, mais vous pouvez éventuellement spécifier les types de journaux à inclure. ``` aws athena start-session \ --work-group "WORKGROUP" \ --monitoring-configuration '{ "CloudWatchLoggingConfiguration": { "Enabled": true, "LogGroup": "/aws/athena/sessions/${workgroup}", "LogStreamNamePrefix": "session-", "LogTypes": { "SPARK_DRIVER": [ "STDOUT", "STDERR" ], "SPARK_EXECUTOR": [ "STDOUT", "STDERR" ] } } }' --engine-configuration '' ``` ### Autorisations requises pour la livraison du journal à CloudWatch Avant que vos sessions puissent fournir des CloudWatch journaux à des groupes de journaux, incluez les autorisations suivantes dans la politique d'autorisation pour le rôle d'exécution. ``` { "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "logs:DescribeLogGroups", "logs:DescribeLogStreams" ], "Resource": "*", "Effect": "Allow" } ``` Et conformément à l'autorisation accordée à la politique de ressources clés de KMS. ``` { "Effect": "Allow", "Principal": { "Service": "logs..amazonaws.com" }, "Action": [ "kms:Encrypt", "kms:Decrypt", "kms:ReEncrypt*", "kms:GenerateDataKey*", "kms:DescribeKey" ], "Resource": "*" } ``` ## Configuration des paramètres de journalisation par défaut au sein du groupe de travail Vous pouvez également spécifier les options de journalisation par défaut au niveau du groupe de travail. Pour spécifier les options de journalisation par défaut AWS CLI pour un groupe de travail, utilisez la `monitoring-configuration` configuration lors de la création d'un nouveau groupe de travail : ``` aws athena create-work-group \ --region "REGION" \ --name "WORKGROUP_NAME" \ --monitoring-configuration '{ "CloudWatchLoggingConfiguration": { "Enabled": true, "LogGroup": "/aws/athena/sessions/${workgroup}", "LogStreamNamePrefix": "session-", "LogTypes": { "SPARK_DRIVER": [ "STDOUT", "STDERR" ], "SPARK_EXECUTOR": [ "STDOUT", "STDERR" ] } }, "ManagedLoggingConfiguration": { "Enabled": true, "KmsKey": "KMS_KEY" }, "S3LoggingConfiguration": { "Enabled": true, "KmsKey": "KMS_KEY" "LogLocation": "s3://bucket/", "LogTypes": { "SPARK_DRIVER": [ "STDOUT", "STDERR" ], "SPARK_EXECUTOR": [ "STDOUT", "STDERR" ] } } }' ``` Pour modifier les options de journalisation par défaut AWS CLI pour un groupe de travail, utilisez la `monitoring-configuration` configuration lors de la mise à jour d'un groupe de travail. Les modifications s'appliquent aux nouvelles sessions interactives à venir. ``` aws athena update-work-group \ --region "REGION" \ --work-group "WORKGROUP_NAME" --monitoring-configuration '{ "CloudWatchLoggingConfiguration": { "Enabled": true, "LogGroup": "/aws/athena/sessions/${workgroup}", "LogStreamNamePrefix": "session-", "LogTypes": { "SPARK_DRIVER": [ "STDOUT", "STDERR" ], "SPARK_EXECUTOR": [ "STDOUT", "STDERR" ] } }, "ManagedLoggingConfiguration": { "Enabled": true, "KmsKey": "KMS_KEY" }, "S3LoggingConfiguration": { "Enabled": true, "KmsKey": "KMS_KEY" "LogLocation": "s3://bucket/", "LogTypes": { "SPARK_DRIVER": [ "STDOUT", "STDERR" ], "SPARK_EXECUTOR": [ "STDOUT", "STDERR" ] } } }' ``` # Accès à l'interface utilisateur de Spark Apache Spark UIs présente des interfaces visuelles contenant des informations détaillées sur vos tâches Spark en cours d'exécution et terminées. Vous pouvez surveiller et déboguer des sessions interactives dans Athena Spark à l'aide d'Apache Spark natif, où vous pouvez accéder à des métriques spécifiques à une tâche et à des informations sur les chronologies des événements, les étapes, les tâches et les exécuteurs pour chaque tâche UIs Spark. ## Accès à l'interface utilisateur de Spark Après avoir démarré une session interactive Athena Spark, vous pouvez consulter l'interface utilisateur Spark en temps réel pour exécuter des sessions à partir des blocs-notes Amazon SageMaker AI Unified Studio ou demander une URL sécurisée à l'aide de l'API. `GetResourceDashboard` Pour les sessions terminées, vous pouvez consulter le serveur Spark History à partir des blocs-notes Amazon SageMaker AI Unified Studio, de la console Amazon Athena ou à l'aide de la même API. ``` aws athena get-resource-dashboard \ --region "REGION" \ --session-id "SESSION_ID" ``` ## Autorisations requises pour accéder à l'interface utilisateur de Spark Avant de pouvoir accéder à l'interface utilisateur de Spark, incluez les autorisations suivantes dans la politique d'autorisation de l'utilisateur ou du rôle. ``` { "Action": "athena:GetResourceDashboard", "Resource": "WORKGROUP", "Effect": "Allow" } ``` # Assistance avec Spark Connect Spark Connect est une architecture client-serveur pour Apache Spark qui dissocie le client d'application du processus pilote du cluster Spark, permettant ainsi la connectivité à distance à Spark depuis les clients pris en charge. Spark Connect permet également le débogage interactif pendant le développement, directement à partir de vos /clients préférés IDEs. À partir de la version 3.5 d'Apache Spark, Athena prend en charge Spark Connect en AWS tant que point de terminaison accessible via l'`GetSessionEndpoint`API. ## Exemples d'API/CLI () GetSessionEndpoint Vous pouvez utiliser l'`GetSessionEndpoint`API pour obtenir le point de terminaison Spark Connect pour une session interactive. ``` aws athena get-session-endpoint \ --region "REGION" \ --session-id "SESSION_ID" ``` Cette API renvoie l'URL du point de terminaison Spark Connect pour cette session. ``` { "EndpointUrl": "ENDPOINT_URL", "AuthToken": "AUTH_TOKEN", "AuthTokenExpirationTime": "AUTH_TOKEN_EXPIRY_TIME" } ``` ## Connexion à partir de clients autogérés Vous pouvez vous connecter à une session interactive Athena Spark à partir de clients autogérés. ### Conditions préalables Installez le client pyspark-connect pour Spark 3.5.6 et le SDK AWS pour Python. ``` pip install --user pyspark[connect]==3.5.6 pip install --user boto3 ``` Voici un exemple de script Python permettant d'envoyer des demandes directement au point de terminaison de session : ``` import boto3 import time from pyspark.sql import SparkSession client = boto3.client('athena', region_name='') # start the session response = client.start_session( WorkGroup='', EngineConfiguration={} ) # wait for the session endpoint to be ready time.sleep(5) response = client.get_session_endpoint(SessionId=session_id) # construct the authenticated remote url authtoken=response['AuthToken'] endpoint_url=response['EndpointUrl'] endpoint_url=endpoint_url.replace("https", "sc")+":443/;use_ssl=true;" url_with_headers = ( f"{endpoint_url}" f"x-aws-proxy-auth={authtoken}" ) # start the Spark session start_time = time.time() spark = SparkSession.builder\ .remote(url_with_headers)\ .getOrCreate() spark.version # # Enter your spark code here # # stop the Spark session spark.stop() ``` Voici un exemple de script Python permettant d'accéder à l'interface utilisateur live de Spark ou au serveur Spark History pour une session : ``` Region='' WorkGroupName='' SessionId='' Partition='aws' Account='' SessionARN=f"arn:{Partition}:athena:{Region}:{Account}:workgroup/{WorkGroupName}/session/{SessionId}" # invoke the API to get the live UI/persistence UI for a session response = client.get_resource_dashboard( ResourceARN=SessionARN ) response['Url'] ``` # Activation des compartiments Amazon S3 de type Paiement par le demandeur dans Athena pour Spark Lorsqu'un compartiment Amazon S3 a une configuration de type Paiement par le demandeur, le compte de l'utilisateur exécutant la requête est débité pour les frais d'accès aux données et de transfert de données associés à la requête. Pour plus d'informations, consultez [Utilisation des compartiments de type Paiement par le demandeur pour les transferts et l'utilisation du stockage](https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html) dans le *Guide de l'utilisateur Amazon S3*. Dans Athena pour Spark, les compartiments de type Paiement par le demandeur sont activés par session, et non par groupe de travail. De manière générale, l'activation des compartiments de type Paiement par le demandeur comprend les étapes suivantes : 1. Dans la console Amazon S3, activez le paiement par le demandeur sur les propriétés du compartiment et ajoutez une politique de compartiment pour spécifier l'accès. 1. Dans la console IAM, créez une politique IAM pour autoriser l'accès au compartiment, puis attachez la politique au rôle IAM qui sera utilisé pour accéder au compartiment de type Paiement par le demandeur. 1. Dans Athena pour Spark, ajoutez une propriété de session pour activer la fonction de paiement par le demandeur. ## Étape 1 : Activation du paiement par le demandeur pour un compartiment Amazon S3 et ajout d’une stratégie de compartiment. **Pour activer le paiement par le demandeur sur un compartiment Amazon S3** 1. Ouvrez la console Amazon S3 à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Dans la liste des compartiments, choisissez le lien du compartiment pour lequel vous souhaitez activer le paiement par le demandeur. 1. Sur la page du compartiment, choisissez l'onglet **Propriétés**. 1. Faites défiler jusqu'à la section **Paiement par le demandeur**, puis choisissez **Modifier**. 1. Sur la page **Modifier le paiement par le demandeur**, choisissez **Activer**, puis **Enregistrer les modifications**. 1. Sélectionnez l’onglet **Autorisations**. 1. Dans la section **Bucket policy** (Politique de compartiment), sélectionnez **Edit** (Modifier). 1. Sur la page **Modifier la politique de compartiment**, appliquez la politique de compartiment que vous souhaitez au compartiment source. L'exemple de politique suivant donne accès à tous les AWS principaux (`"AWS": "*"`), mais votre accès peut être plus précis. Par exemple, vous pouvez souhaiter spécifier uniquement un rôle IAM spécifique dans un autre compte. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Statement1", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::111122223333:root" }, "Action": "s3:*", "Resource": [ "arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket", "arn:aws:s3:::555555555555-us-east-1-amzn-s3-demo-bucket/*" ] } ] } ``` ------ ## Étape 2 : Création d’une politique IAM et attachement de cette politique à un rôle IAM Ensuite, vous créez une politique IAM afin d'autoriser l'accès au compartiment. Vous attachez ensuite la politique au rôle qui sera utilisé pour accéder au compartiment de type Paiement par le demandeur. **Pour créer une politique IAM pour le compartiment de type Paiement par le demandeur et l'attacher à un rôle** 1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Dans le panneau de navigation de la console IAM, sélectionnez **Politiques**. 1. Choisissez **Create Policy** (Créer une politique). 1. Choisissez **JSON**. 1. Dans **Éditeur de politiques**, ajoutez une politique comme suit : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Action": [ "s3:*" ], "Effect": "Allow", "Resource": [ "arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket", "arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket/*" ] } ] } ``` ------ 1. Choisissez **Suivant**. 1. Dans la page **Vérifier et créer**, entrez un nom et une Description facultative pour la politique, puis choisissez **Créer une politique**. 1. Dans le panneau de navigation, choisissez **Rôles**. 1. Sur la page **Rôles**, recherchez le rôle que vous souhaitez utiliser, puis cliquez sur le lien du nom du rôle. 1. Dans la section **Politiques d'autorisations**, choisissez **Ajouter des autorisations**, **Attacher des politiques**. 1. Dans la section **Autres politiques d'autorisations**, cochez la case correspondant à la politique que vous avez créée, puis choisissez **Ajouter des autorisations**. ## Étape 3 : Ajout d’une propriété de session Athena pour Spark Après avoir configuré le compartiment Amazon S3 et les autorisations associées pour le paiement par le demandeur, vous pouvez activer cette fonctionnalité dans une session Athena pour Spark. **Pour activer des compartiments de type Paiement par le demandeur dans une session Athena pour Spark** 1. Dans l'éditeur de bloc-notes, dans le menu **Session** en haut à droite, choisissez **Modifier la session**. 1. Développez les **propriétés Spark**. 1. Choisissez **Modifier dans JSON**. 1. Dans l'éditeur de texte JSON, entrez ce qui suit : ``` { "spark.hadoop.fs.s3.useRequesterPaysHeader":"true" } ``` 1. Choisissez **Enregistrer**. # Utilisation de Lake Formation avec les groupes de travail Athena Spark Avec la version finale d'Apache Spark version 3.5, vous pouvez tirer parti du catalogue AWS Lake Formation de AWS Glue données dans lequel le rôle d'exécution de session dispose d'autorisations complètes sur les tables. Cette fonctionnalité vous permet de lire et d'écrire sur des tables protégées par Lake Formation lors de vos sessions interactives Athena Spark. Consultez les sections suivantes pour en savoir plus sur Lake Formation et sur son utilisation avec Athena Spark. ## Étape 1 : Activer l'accès complet à la table dans Lake Formation Pour utiliser le mode Full Table Access (FTA), vous devez autoriser Athena Spark à accéder aux données sans validation du tag de session IAM. AWS Lake Formation Pour l’activer, suivez les étapes de la section [Intégration des applications pour un accès complet aux tables](https://docs.aws.amazon.com//lake-formation/latest/dg/fta-app-integration.html). ### Étape 1.1 : Enregistrer les emplacements des données dans Lake Formation à l'aide d'un rôle défini par l'utilisateur Vous devez utiliser un rôle défini par l'utilisateur pour enregistrer les emplacements de données dans AWS Lake Formation. [Pour plus de détails, consultez la section Exigences relatives aux rôles utilisés pour enregistrer des sites](https://docs.aws.amazon.com//lake-formation/latest/dg/registration-role.html). ## Étape 2 : Configuration des autorisations IAM pour le rôle d'exécution de la session Pour accéder en lecture ou en écriture aux données sous-jacentes, outre les autorisations de Lake Formation, le rôle d'exécution a besoin de l'autorisation `lakeformation:GetDataAccess` IAM. Avec cette autorisation, Lake Formation accède à la demande d'informations d'identification temporaires pour accéder aux données. Voici un exemple de politique expliquant comment fournir des autorisations IAM pour accéder à un script dans Amazon S3, télécharger des journaux vers S3, autoriser AWS Glue l'API et accéder à Lake Formation. ### Étape 2.1 : Configuration des autorisations de Lake Formation + Les tâches Spark qui lisent des données depuis S3 nécessitent l'`SELECT`autorisation de Lake Formation. + Spark Jobs dont write/delete les données dans S3 nécessitent l'`ALL (SUPER)`autorisation de Lake Formation. + Les tâches Spark qui interagissent avec le catalogue de AWS Glue données nécessitent une `DROP` autorisation `DESCRIBE``ALTER`, le cas échéant. ## Étape 3 : Initialisation d'une session Spark pour un accès complet à la table à l'aide de Lake Formation ### Conditions préalables AWS Glue Le catalogue de données doit être configuré en tant que métastore pour accéder aux tables de Lake Formation. Définissez les paramètres suivants pour configurer le AWS Glue catalogue en tant que métastore : ``` { "spark.hadoop.glue.catalogid": "ACCOUNT_ID", "spark.hadoop.hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory", "spark.hadoop.hive.metastore.glue.catalogid": "ACCOUNT_ID", "spark.sql.catalogImplementation": "hive" } ``` Pour accéder aux tables enregistrées auprès de Spark AWS Lake Formation, les configurations suivantes doivent être définies lors de l'initialisation de Spark afin que Spark utilise les AWS Lake Formation informations d'identification. ### Hive ``` { "spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver", "spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": "true", "spark.hadoop.fs.s3.folderObject.autoAction.disabled": "true", "spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": "true", "spark.sql.catalog.createDirectoryAfterTable.enabled": "true", "spark.sql.catalog.dropDirectoryBeforeTable.enabled": "true" } ``` ### Apache Iceberg ``` { "spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension", "spark.sql.catalog.spark_catalog": "org.apache.iceberg.spark.SparkSessionCatalog", "spark.sql.catalog.spark_catalog.warehouse": "s3://your-bucket/warehouse/", "spark.sql.catalog.spark_catalog.client.region": "REGION", "spark.sql.catalog.spark_catalog.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog", "spark.sql.catalog.spark_catalog.glue.account-id": "ACCOUNT_ID", "spark.sql.catalog.spark_catalog.glue.lakeformation-enabled": "true" } ``` ### Tables Amazon S3 ``` { "spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension", "spark.sql.catalog.{catalogName}": "org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.{catalogName}.warehouse": "arn:aws:s3tables:{region}:{accountId}:bucket/{bucketName}", "spark.sql.catalog.{catalogName}.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog", "spark.sql.catalog.{catalogName}.glue.id": "{accountId}:s3tablescatalog/{bucketName}", "spark.sql.catalog.{catalogName}.glue.lakeformation-enabled": "true", "spark.sql.catalog.{catalogName}.client.region": "REGION", "spark.sql.catalog.{catalogName}.glue.account-id": "ACCOUNT_ID" } ``` ### Delta Lake ``` { "spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension", "spark.sql.catalog.spark_catalog": "org.apache.spark.sql.delta.catalog.DeltaCatalog", "spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver", "spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": "true", "spark.hadoop.fs.s3.folderObject.autoAction.disabled": "true", "spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": "true", "spark.sql.catalog.createDirectoryAfterTable.enabled": "true", "spark.sql.catalog.dropDirectoryBeforeTable.enabled": "true" } ``` ## Considérations et restrictions + L'accès complet aux tables est pris en charge pour les tables Hive, Iceberg, Amazon S3 et Delta. Les tables Hudi ne permettent pas un accès complet aux tables. + Pour ajouter de nouveaux catalogues à une session active, utilisez `spark.conf.set` de nouvelles configurations de catalogue. + Les configurations du catalogue sont immuables. Si vous souhaitez mettre à jour une configuration de catalogue, créez un nouveau catalogue en utilisant`spark.conf.set`. + Ajoutez uniquement les catalogues dont vous avez besoin à la session Spark. + Pour modifier le catalogue par défaut : `spark.catalog.setCurrentCatalog("s3tablesbucket")` + Si le nom de votre catalogue contient des caractères spéciaux`-`, évitez-les dans votre requête, comme : ``` SELECT sales_amount as nums FROM `my-s3-tables-bucket`.`s3namespace`.`daily_sales` LIMIT 100 ``` # Activation du chiffrement Apache Spark Vous pouvez activer le chiffrement Apache Spark dans Athena. Cela chiffre les données en transit entre les nœuds Spark et chiffre également les données au repos stockées localement par Spark. Pour renforcer la sécurité de ces données, Athena utilise la configuration de chiffrement suivante : ``` spark.io.encryption.keySizeBits="256" spark.io.encryption.keygen.algorithm="HmacSHA384" ``` Pour activer le chiffrement Spark, vous pouvez utiliser la console Athena AWS CLI, ou l'API Athena. ## Utilisation de la console Athena pour activer le chiffrement Spark dans un nouveau bloc-notes **Pour créer un nouveau bloc-notes sur lequel le chiffrement Spark est activé** 1. Ouvrez la console à l'adresse [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home). 1. Si le panneau de navigation de la console n'est pas visible, choisissez le menu d'extension sur la gauche. 1. Effectuez l’une des actions suivantes : + Dans **Notebook explorer** (Explorateur de blocs-notes), choisissez **Create notebook** (Créer un bloc-notes). + Dans **Notebook editor** (Éditeur de bloc-notes), choisissez **Create notebook** (Créer un bloc-notes) ou cliquez sur l'icône plus (**\$1**) pour ajouter un bloc-notes. 1. Dans **Nom du bloc-notes**, entrez le nom du bloc-notes. 1. Développez l'option **Propriétés Spark**. 1. Sélectionnez **Activer le chiffrement Spark**. 1. Choisissez **Créer**. La session de bloc-notes que vous créez est chiffrée. Utilisez le nouveau bloc-notes comme vous le feriez normalement. Lorsque vous lancerez ultérieurement de nouvelles sessions utilisant le bloc-notes, les nouvelles sessions seront également chiffrées. ## Utilisation de la console Athena pour activer le chiffrement Spark pour un bloc-notes existant Vous pouvez également utiliser la console Athena pour activer le chiffrement Spark sur un bloc-notes existant. **Pour activer le chiffrement sur un bloc-notes existant** 1. [Ouvrez une nouvelle session](notebooks-spark-managing.md#opening-a-previously-created-notebook) pour un bloc-notes créé précédemment. 1. Dans l'éditeur de bloc-notes, dans le menu **Session** en haut à droite, choisissez **Modifier la session**. 1. Dans la boîte de dialogue **Modifier les détails de la session**, développez **Propriétés Spark**. 1. Sélectionnez **Activer le chiffrement Spark**. 1. Choisissez **Enregistrer**. La console lance une nouvelle session dont le chiffrement est activé. Le chiffrement sera également activé pour les sessions ultérieures que vous créerez pour ce bloc-notes. ## Utilisez le AWS CLI pour activer le chiffrement Spark Vous pouvez utiliser le AWS CLI pour activer le chiffrement lorsque vous lancez une session en spécifiant les propriétés Spark appropriées. **Pour utiliser le AWS CLI pour activer le chiffrement Spark** 1. Utilisez une commande comme celle-ci pour créer un objet JSON de configuration du moteur qui spécifie les propriétés de chiffrement Spark. ``` ENGINE_CONFIGURATION_JSON=$( cat < Pour activer le chiffrement Spark avec l'API Athena, utilisez l'[StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)action et ses [EngineConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EngineConfiguration.html)`SparkProperties`paramètres pour spécifier la configuration du chiffrement dans votre `StartSession` demande. # Configurer l' AWS Glue accès entre comptes dans Athena pour Spark Cette rubrique explique comment le compte client *666666666666* et le compte propriétaire *999999999999* peuvent être configurés pour un AWS Glue accès entre comptes. Lorsque les comptes sont configurés, le compte client peut exécuter des requêtes depuis Athena pour Spark sur les AWS Glue bases de données et les tables du propriétaire. ## Étape 1 : Entrez AWS Glue, donnez accès aux rôles des consommateurs Dans AWS Glue, le propriétaire crée une politique qui permet aux rôles du consommateur d'accéder au catalogue de AWS Glue données du propriétaire. **Pour ajouter une AWS Glue politique qui autorise un rôle de consommateur à accéder au catalogue de données du propriétaire** 1. À l'aide du compte du propriétaire du catalogue, connectez-vous à la AWS Management Console. 1. Ouvrez la AWS Glue console à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. Dans le panneau de navigation, développez **Catalogue de données**, puis choisissez **Paramètres du catalogue**. 1. Sur la page des **paramètres du catalogue de données**, dans la section **Autorisations**, ajoutez une politique similaire à la suivante. Cette politique fournit des rôles pour l'*666666666666*accès du compte client au catalogue de données du compte propriétaire*999999999999*. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Cataloguers", "Effect": "Allow", "Principal": { "AWS": [ "arn:aws:iam::666666666666:role/Admin", "arn:aws:iam::666666666666:role/AWSAthenaSparkExecutionRole" ] }, "Action": "glue:*", "Resource": [ "arn:aws:glue:us-west-2:999999999999:catalog", "arn:aws:glue:us-west-2:999999999999:database/*", "arn:aws:glue:us-west-2:999999999999:table/*" ] } ] } ``` ------ ## Étape 2 : Configuration du compte consommateur pour l’accès Dans le compte client, créez une politique pour autoriser l'accès au propriétaire AWS Glue Data Catalog, aux bases de données et aux tables, et associez la politique à un rôle. L'exemple suivant utilise un compte client*666666666666*. **Pour créer une AWS Glue politique d'accès au AWS Glue Data Catalog** 1. À l'aide du compte consommateur, connectez-vous à la AWS Management Console. 1. Ouvrez la console IAM à l’adresse [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). 1. Dans le panneau de navigation, développez **Gestion des accès**, puis choisissez **Politiques**. 1. Choisissez **Create Policy** (Créer une politique). 1. Sur la page **Spécifier les autorisations**, choisissez **JSON**. 1. Dans l'**éditeur de politiques**, entrez une instruction JSON comme la suivante qui autorise AWS Glue des actions sur le catalogue de données du compte propriétaire. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": "glue:*", "Resource": [ "arn:aws:glue:us-east-1:999999999999:catalog", "arn:aws:glue:us-east-1:999999999999:database/*", "arn:aws:glue:us-east-1:999999999999:table/*" ] } ] } ``` ------ 1. Choisissez **Suivant**. 1. Sur la page **Examiner et créer**, dans **Nom de la politique**, saisissez un nom pour la politique. 1. Choisissez **Create Policy** (Créer une politique). Ensuite, vous utilisez la console IAM du compte consommateur pour attacher la politique que vous venez de créer au ou aux rôles IAM que le compte consommateur utilisera pour accéder au catalogue de données du propriétaire. **Pour associer la AWS Glue politique aux rôles du compte client** 1. Dans le panneau de navigation de la console IAM du compte consommateur, sélectionnez **Rôles**. 1. Sur la page **Rôles**, recherchez le rôle auquel vous souhaitez attacher la politique. 1. Choisissez **Ajouter des autorisations**, puis **Attacher des politiques**. 1. Recherchez la politique que vous venez de créer. 1. Cochez la case correspondant à la politique, puis choisissez **Ajouter des autorisations**. 1. Répétez les étapes pour ajouter la politique aux autres rôles que vous souhaitez utiliser. ## Étape 3 : Configuration d’une session et création d’une requête Dans Athena Spark, dans le compte du demandeur, à l'aide du rôle spécifié, créez une session pour tester l'accès en [créant un bloc-notes](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) ou en [modifiant une session en cours](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details). Lorsque vous [configurez les propriétés de session](notebooks-spark-custom-jar-cfg.md#notebooks-spark-custom-jar-cfg-console), spécifiez l'une des options suivantes : + **Le séparateur de AWS Glue catalogue** : avec cette approche, vous incluez l'identifiant du compte du propriétaire dans vos requêtes. Utilisez cette méthode si vous comptez utiliser la session pour interroger des catalogues de données provenant de différents propriétaires. + **L'ID du AWS Glue catalogue** : avec cette approche, vous interrogez directement la base de données. Cette méthode est plus pratique si vous comptez utiliser la session pour interroger uniquement le catalogue de données d'un seul propriétaire. ### Utiliser le séparateur de AWS Glue catalogue Lorsque vous modifiez les propriétés de session, ajoutez les éléments suivants : ``` { "spark.hadoop.aws.glue.catalog.separator": "/" } ``` Lorsque vous exécutez une requête dans une cellule, utilisez une syntaxe similaire à celle décrite dans l'exemple suivant. Notez que dans la clause `FROM`, l'ID du catalogue et le séparateur sont requis devant le nom de la base de données. ``` df = spark.sql('SELECT requestip, uri, method, status FROM `999999999999/mydatabase`.cloudfront_logs LIMIT 5') df.show() ``` ### Utiliser l'ID du AWS Glue catalogue Lorsque vous modifiez les propriétés de session, entrez la propriété suivante. Remplacez *999999999999* par le numéro de compte du propriétaire. ``` { "spark.hadoop.hive.metastore.glue.catalogid": "999999999999" } ``` Lorsque vous exécutez une requête dans une cellule, utilisez une syntaxe similaire à celle ci-dessous. Notez que dans la clause `FROM`, l'ID du catalogue et le séparateur ne sont pas requis devant le nom de la base de données. ``` df = spark.sql('SELECT * FROM mydatabase.cloudfront_logs LIMIT 10') df.show() ``` ## Ressources supplémentaires [Configuration de l'accès entre comptes aux catalogues de AWS Glue données](security-iam-cross-account-glue-catalog-access.md) [Gérer les autorisations entre comptes à l'aide des deux AWS Glue et de Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/hybrid-cross-account.html) dans le *guide du AWS Lake Formation développeur*. [Configurez l'accès entre comptes à un partage à AWS Glue Data Catalog l'aide d'Amazon](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-a-shared-aws-glue-data-catalog-using-amazon-athena.html) Athena *AWS dans Prescriptive* Guidance Patterns. # Présentation des quotas de service dans Athena pour Spark Les *quotas de service*, également appelés *limites*, sont le nombre maximum de ressources de service ou d'opérations que vous Compte AWS pouvez utiliser. Pour plus d'informations sur les quotas de service pour les autres AWS services que vous pouvez utiliser avec Amazon Athena pour Spark, consultez la section sur les [quotas de AWS service](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) dans le. *Référence générale d'Amazon Web Services* **Note** Les valeurs par défaut sont les quotas initiaux définis par AWS, qui sont distincts de la valeur de quota réellement appliquée et du quota de service maximal possible. Les nouveaux Comptes AWS peuvent avoir des quotas initiaux inférieurs qui peuvent augmenter au fil du temps. Amazon Athena pour Apache Spark surveille l'utilisation des comptes au sein de chaque compte Région AWS, puis augmente automatiquement les quotas en fonction de votre utilisation. Si vos exigences dépassent les limites indiquées, contactez le service client. Le tableau suivant répertorie les Service Quotas pour Amazon Athena pour Apache Spark. **** | Nom | Par défaut | Ajustable | Version | Description | | --- | --- | --- | --- | --- | | Simultanéité DPU Apache Spark | 160 | Non | PySpark Version 3 | Le nombre maximum d'unités de traitement de données (DPUs) que vous pouvez utiliser simultanément pour les calculs d'Apache Spark pour un seul compte en cours Région AWS. Un DPU est une mesure relative de la puissance de traitement composée de 4 V de capacité CPUs de calcul et de 16 Go de mémoire. | | Simultanéité DPU de session Apache Spark | 60 | Non | PySpark Version 3 | Le nombre maximum DPUs que vous pouvez consommer simultanément pour un calcul Apache Spark au cours d'une session. | | À la demande DPUs | 4 | Non | Apache Spark version 3.5 | Nombre maximum d'unités de traitement de données (DPUs) que vous pouvez utiliser simultanément pour les sessions interactives Apache Spark en cours Région AWS. | # Utiliser Athena Spark APIs **Note** Les blocs-notes et les calculs Athena APIs sont disponibles dans la version finale du moteur Pyspark version 3. Les blocs-notes et les calculs ne APIs sont pas pris en charge dans la version 3.5 d'Apache Spark. La liste suivante contient des liens de référence vers les actions des API de bloc-notes Athena. Pour les structures de données et les autres actions des API Athena, voir la [https://docs.aws.amazon.com/athena/latest/APIReference/](https://docs.aws.amazon.com/athena/latest/APIReference/). + [CreateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateNotebook.html) + [CreatePresignedNotebookUrl](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreatePresignedNotebookUrl.html) + [DeleteNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_DeleteNotebook.html) + [ExportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ExportNotebook.html) + [GetCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecution.html) + [GetCalculationExecutionCode](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecutionCode.html) + [GetCalculationExecutionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecutionStatus.html) + [GetNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetNotebookMetadata.html) + [GetSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetSession.html) + [GetSessionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetSessionStatus.html) + [ImportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ImportNotebook.html) + [ListApplicationDPUSizes](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListApplicationDPUSizes.html) + [ListCalculationExecutions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListCalculationExecutions.html) + [ListExecutors](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListExecutors.html) + [ListNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListNotebookMetadata.html) + [ListNotebookSessions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListNotebookSessions.html) + [ListSessions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListSessions.html) + [StartCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartCalculationExecution.html) + [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html) + [StopCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StopCalculationExecution.html) + [TerminateSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_TerminateSession.html) + [UpdateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html) + [UpdateNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebookMetadata.html) # Résolution des problèmes liés à Athena pour Spark Utilisez les informations suivantes pour résoudre les problèmes que vous pouvez rencontrer lorsque vous utilisez des blocs-notes et des sessions sur Athena. **Topics** + [Problèmes connus dans Athena pour Spark](notebooks-spark-known-issues.md) + [Résolution des problèmes liés aux groupes de travail compatibles avec Spark](notebooks-spark-troubleshooting-workgroups.md) + [Utilisation de l’instruction Spark EXPLAIN pour résoudre les problèmes liés à Spark SQL](notebooks-spark-troubleshooting-explain.md) + [Journalisation des événements de l’application Spark dans Athena](notebooks-spark-logging.md) + [CloudTrail À utiliser pour résoudre les appels d'API du bloc-notes Athena](notebooks-spark-troubleshooting-cloudtrail.md) + [Dépassement de la limite de taille de 68 000 caractères des blocs de code](notebooks-spark-troubleshooting-code-block-size-limit.md) + [Correction des erreurs de session](notebooks-spark-troubleshooting-sessions.md) + [Correction des erreurs de table](notebooks-spark-troubleshooting-tables.md) + [Accès au support](notebooks-spark-troubleshooting-support.md) # Problèmes connus dans Athena pour Spark Cette page présente certains des problèmes connus d'Athena pour Apache Spark. ## Exception d'argument non valide lors de la création d'une table Bien que Spark n'autorise pas la création de bases de données avec une propriété d'emplacement vide, les bases de données AWS Glue peuvent avoir une `LOCATION` propriété vide si elles sont créées en dehors de Spark. Si vous créez une table et spécifiez une AWS Glue base de données contenant un `LOCATION` champ vide, une exception comme celle-ci peut se produire IllegalArgumentException: Impossible de créer un chemin à partir d'une chaîne vide. Par exemple, la commande suivante génère une exception si la base de données par défaut de AWS Glue contient un champ `LOCATION` vide : ``` spark.sql("create table testTable (firstName STRING)") ``` **Solution suggérée A** — AWS Glue À utiliser pour ajouter un emplacement à la base de données que vous utilisez. **Pour ajouter un emplacement à une AWS Glue base de données** 1. Connectez-vous à la AWS Glue console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/). 1. Dans le panneau de navigation, choisissez **Databases (Bases de données)**. 1. Dans la liste des bases de données, choisissez la base de données à modifier. 1. Sur la page de détails de la base de données, sélectionnez **Edit** (Modifier). 1. Sur la page **Update a database** (Mettre à jour une base de données), dans le champ **Location** (Emplacement), saisissez un emplacement Amazon S3. 1. Choisissez **Update Database** (Mettre à jour la base de données). **Solution suggérée B** – Utilisez une autre base de données AWS Glue qui a un emplacement existant et valide dans Amazon S3. Par exemple, si vous avez une base de données appelée `dbWithLocation`, utilisez la commande `spark.sql("use dbWithLocation")` pour passer à cette base de données. **Solution suggérée C** – Lorsque vous utilisez Spark SQL pour créer la table, spécifiez une valeur pour `location`, comme dans l'exemple suivant. ``` spark.sql("create table testTable (firstName STRING) location 's3://amzn-s3-demo-bucket/'"). ``` **Solution suggérée D** – Si vous avez indiqué un emplacement lors de la création de la table, mais que le problème persiste, assurez-vous que le chemin Amazon S3 que vous indiquez comporte une barre oblique à la fin. Par exemple, la commande suivante génère une exception d'argument non valide : ``` spark.sql("create table testTable (firstName STRING) location 's3://amzn-s3-demo-bucket'") ``` Pour corriger cela, ajoutez une barre oblique finale à l'emplacement (par exemple, `'s3://amzn-s3-demo-bucket/'`). ## Base de données créée dans un emplacement de groupe de travail Si vous utilisez une commande comme `spark.sql('create database db')` pour créer une base de données et que vous ne spécifiez pas d'emplacement pour la base de données, Athena crée un sous-répertoire dans l'emplacement de votre groupe de travail et utilise cet emplacement pour la base de données nouvellement créée. ## Problèmes liés aux tables gérées par Hive dans la base de données AWS Glue par défaut Si la `Location` propriété de votre base de données par défaut AWS Glue n'est pas vide et indique un emplacement valide dans Amazon S3, et que vous utilisez Athena for Spark pour créer une table gérée par Hive dans AWS Glue votre base de données par défaut, les données sont écrites à l'emplacement Amazon S3 spécifié dans votre groupe de travail Athena Spark plutôt qu'à l'emplacement spécifié par la base de données. AWS Glue Ce problème se produit en raison de la façon dont Apache Hive gère sa base de données par défaut. Apache Hive crée des données de table dans l'emplacement racine de l'entrepôt Hive, qui peut être différent de l'emplacement de base de données par défaut réel. Lorsque vous utilisez Athena pour Spark pour créer une table gérée par Hive sous la base de données par défaut dans AWS Glue, les métadonnées de la AWS Glue table peuvent pointer vers deux emplacements différents. Cela peut provoquer un comportement inattendu lorsque vous tentez une opération `INSERT` ou `DROP TABLE`. Les étapes pour reproduire le problème sont les suivantes : 1. Dans Athena pour Spark, vous utilisez l'une des méthodes suivantes pour créer ou enregistrer une table gérée par Hive : + Une instruction SQL telle que `CREATE TABLE $tableName` + Une telle PySpark commande `df.write.mode("overwrite").saveAsTable($tableName)` ne spécifie pas l'`path`option dans l'API Dataframe. À ce stade, la AWS Glue console peut indiquer un emplacement incorrect dans Amazon S3 pour la table. 1. Dans Athena pour Spark, vous utilisez l'instruction `DROP TABLE $table_name` pour supprimer la table que vous avez créée. 1. Après avoir exécuté l'instruction `DROP TABLE`, vous remarquez que les fichiers sous-jacents sont toujours présents dans Amazon S3. Pour résoudre ce problème, procédez de l'une des manières suivantes : **Solution A** — Utilisez une autre AWS Glue base de données lorsque vous créez des tables gérées par Hive. **Solution B** : spécifiez un emplacement vide pour la base de données par défaut dans AWS Glue. Créez ensuite vos tables gérées dans la base de données par défaut. ## Incompatibilité des formats de fichier CSV et JSON entre Athena pour Spark et Athena SQL En raison d'un problème connu lié à Spark open source, lorsque vous créez une table dans Athena pour Spark sur des données CSV ou JSON, la table peut ne pas être lisible à partir d'Athena SQL, et vice versa. Par exemple, vous pouvez créer une table dans Athena pour Spark de l'une des manières suivantes : + Utilisez la syntaxe `USING csv` suivante : ``` spark.sql('''CREATE EXTERNAL TABLE $tableName ( $colName1 $colType1, $colName2 $colType2, $colName3 $colType3) USING csv PARTITIONED BY ($colName1) LOCATION $s3_location''') ``` + Avec la syntaxe [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html)d'API suivante : ``` df.write.format('csv').saveAsTable($table_name) ``` En raison du problème connu avec Spark open source, les requêtes d'Athena SQL sur les tables résultantes risquent d'échouer. **Solution suggérée** : essayez de créer la table dans Athena pour Spark en utilisant la syntaxe Apache Hive. Pour plus d'informations, consultez [CREATE HIVEFORMAT TABLE](https://spark.apache.org/docs/latest/sql-ref-syntax-ddl-create-table-hiveformat.html) dans la documentation Apache Spark. # Résolution des problèmes liés aux groupes de travail compatibles avec Spark Consultez les informations suivantes pour tenter de résoudre les problèmes liés aux groupes de travail compatibles avec Spark dans Athena. ## La session cesse de répondre lors de l'utilisation d'un rôle IAM existant Si vous n'avez pas créé un nouveau `AWSAthenaSparkExecutionRole` pour votre groupe de travail compatible avec Spark et que vous avez plutôt mis à jour ou choisi un rôle IAM existant, il est possible que votre session cesse de répondre. Dans ce cas, vous devrez peut-être ajouter les politiques de confiance et d'autorisations suivantes à votre rôle d'exécution de groupe de travail compatible avec Spark. Ajoutez l'exemple de politique de confiance suivant. La politique comprend un contrôle du député confus pour le rôle d'exécution. Remplacez les valeurs pour `111122223333``aws-region`, et `workgroup-name` par l' Compte AWS ID et Région AWS le groupe de travail que vous utilisez. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "athena.amazonaws.com" }, "Action": "sts:AssumeRole", "Condition": { "StringEquals": { "aws:SourceAccount": "111122223333" }, "ArnLike": { "aws:SourceArn": "arn:aws:athena:us-east-1:111122223333:workgroup/workgroup-name" } } } ] } ``` ------ Ajoutez une politique d'autorisations comme la politique par défaut suivante pour les groupes de travail compatibles avec les blocs-notes. Modifiez les emplacements Amazon S3 réservés Compte AWS IDs pour qu'ils correspondent à ceux que vous utilisez. Remplacez les valeurs de `amzn-s3-demo-bucket`, `aws-region`, `111122223333` et `workgroup-name` par l'ID du compartiment Amazon S3, de la Région AWS, du Compte AWS et le groupe de travail que vous utilisez. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:PutObject", "s3:ListBucket", "s3:DeleteObject", "s3:GetObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/*", "arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Effect": "Allow", "Action": [ "athena:GetWorkGroup", "athena:CreatePresignedNotebookUrl", "athena:TerminateSession", "athena:GetSession", "athena:GetSessionStatus", "athena:ListSessions", "athena:StartCalculationExecution", "athena:GetCalculationExecutionCode", "athena:StopCalculationExecution", "athena:ListCalculationExecutions", "athena:GetCalculationExecution", "athena:GetCalculationExecutionStatus", "athena:ListExecutors", "athena:ExportNotebook", "athena:UpdateNotebook" ], "Resource": "arn:aws:athena:us-east-1:111122223333:workgroup/workgroup-name" }, { "Effect": "Allow", "Action": [ "logs:CreateLogStream", "logs:DescribeLogStreams", "logs:CreateLogGroup", "logs:PutLogEvents" ], "Resource": [ "arn:aws:logs:us-east-1:111122223333:log-group:/aws-athena:*", "arn:aws:logs:us-east-1:111122223333:log-group:/aws-athena*:log-stream:*" ] }, { "Effect": "Allow", "Action": "logs:DescribeLogGroups", "Resource": "arn:aws:logs:us-east-1:111122223333:log-group:*" }, { "Effect": "Allow", "Action": [ "cloudwatch:PutMetricData" ], "Resource": "*", "Condition": { "StringEquals": { "cloudwatch:namespace": "AmazonAthenaForApacheSpark" } } } ] } ``` ------ # Utilisation de l’instruction Spark EXPLAIN pour résoudre les problèmes liés à Spark SQL Vous pouvez utiliser l'instruction Spark `EXPLAIN` avec Spark SQL pour résoudre les problèmes liés à votre code Spark. Les exemples de code et de résultats suivants illustrent cette utilisation. **Example – Instruction Spark SELECT** ``` spark.sql("select * from select_taxi_table").explain(True) ``` **Sortie** ``` Calculation started (calculation_id=20c1ebd0-1ccf-ef14-db35-7c1844876a7e) in (session=24c1ebcb-57a8-861e-1023-736f5ae55386). Checking calculation status... Calculation completed. == Parsed Logical Plan == 'Project [*] +- 'UnresolvedRelation [select_taxi_table], [], false == Analyzed Logical Plan == VendorID: bigint, passenger_count: bigint, count: bigint Project [VendorID#202L, passenger_count#203L, count#204L] +- SubqueryAlias spark_catalog.spark_demo_database.select_taxi_table +- Relation spark_demo_database.select_taxi_table[VendorID#202L, passenger_count#203L,count#204L] csv == Optimized Logical Plan == Relation spark_demo_database.select_taxi_table[VendorID#202L, passenger_count#203L,count#204L] csv == Physical Plan == FileScan csv spark_demo_database.select_taxi_table[VendorID#202L, passenger_count#203L,count#204L] Batched: false, DataFilters: [], Format: CSV, Location: InMemoryFileIndex(1 paths) [s3://amzn-s3-demo-bucket/select_taxi], PartitionFilters: [], PushedFilters: [], ReadSchema: struct ``` **Example – Bloc de données Spark** L'exemple suivant illustre comment utiliser `EXPLAIN` avec un bloc de données  Spark. ``` taxi1_df=taxi_df.groupBy("VendorID", "passenger_count").count() taxi1_df.explain("extended") ``` **Sortie** ``` Calculation started (calculation_id=d2c1ebd1-f9f0-db25-8477-3effc001b309) in (session=24c1ebcb-57a8-861e-1023-736f5ae55386). Checking calculation status... Calculation completed. == Parsed Logical Plan == 'Aggregate ['VendorID, 'passenger_count], ['VendorID, 'passenger_count, count(1) AS count#321L] +- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51, passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55, PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59, extra#60,mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64, total_amount#65,congestion_surcharge#66,airport_fee#67] parquet == Analyzed Logical Plan == VendorID: bigint, passenger_count: bigint, count: bigint Aggregate [VendorID#49L, passenger_count#52L], [VendorID#49L, passenger_count#52L, count(1) AS count#321L] +- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51, passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55, PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59,extra#60, mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64, total_amount#65,congestion_surcharge#66,airport_fee#67] parquet == Optimized Logical Plan == Aggregate [VendorID#49L, passenger_count#52L], [VendorID#49L, passenger_count#52L, count(1) AS count#321L] +- Project [VendorID#49L, passenger_count#52L] +- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51, passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55, PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59,extra#60, mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64, total_amount#65,congestion_surcharge#66,airport_fee#67] parquet == Physical Plan == AdaptiveSparkPlan isFinalPlan=false +- HashAggregate(keys=[VendorID#49L, passenger_count#52L], functions=[count(1)], output=[VendorID#49L, passenger_count#52L, count#321L]) +- Exchange hashpartitioning(VendorID#49L, passenger_count#52L, 1000), ENSURE_REQUIREMENTS, [id=#531] +- HashAggregate(keys=[VendorID#49L, passenger_count#52L], functions=[partial_count(1)], output=[VendorID#49L, passenger_count#52L, count#326L]) +- FileScan parquet [VendorID#49L,passenger_count#52L] Batched: true, DataFilters: [], Format: Parquet, Location: InMemoryFileIndex(1 paths)[s3://amzn-s3-demo-bucket/ notebooks/yellow_tripdata_2016-01.parquet], PartitionFilters: [], PushedFilters: [], ReadSchema: struct ``` # Journalisation des événements de l’application Spark dans Athena L'éditeur de bloc-notes Athena permet la journalisation standard sur Jupyter, Spark et Python. Vous pouvez l'utiliser `df.show()` pour afficher PySpark DataFrame le contenu ou `print("Output")` pour afficher des valeurs dans la sortie de la cellule. Les sorties `stdout`, `stderr` et `results` de vos calculs sont écrites dans votre compartiment de résultats de requête dans Amazon S3. ## Enregistrez les événements de l'application Spark sur Amazon CloudWatch Vos sessions Athena peuvent également écrire des journaux sur [Amazon sur CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) le compte que vous utilisez. ### Présentation des flux de journaux et des groupes de journaux CloudWatch organise l'activité des journaux en flux de journaux et en groupes de journaux. **Flux de journaux** : un flux de CloudWatch journal est une séquence d'événements de journal qui partagent la même source. Chaque source distincte de CloudWatch journaux dans Logs constitue un flux de journaux distinct. **Groupes** de CloudWatch journaux : dans Logs, un groupe de journaux est un groupe de flux de journaux qui partagent les mêmes paramètres de conservation, de surveillance et de contrôle d'accès. Le nombre de flux de journaux pouvant appartenir à un groupe de journaux est illimité. Dans Athena, lorsque vous démarrez une session de bloc-notes pour la première fois, Athena crée un groupe de journaux CloudWatch qui utilise le nom de votre groupe de travail compatible avec Spark, comme dans l'exemple suivant. ``` /aws-athena/workgroup-name ``` Ce groupe de journaux reçoit un flux de journaux pour chaque exécuteur de votre session qui produit au moins un événement du journal. L'exécuteur est la plus petite unité de calcul qu'une session de bloc-notes peut demander à Athena. Dans CloudWatch, le nom du flux de journal commence par l'ID de session et l'ID de l'exécuteur. Pour plus d'informations sur les groupes de CloudWatch journaux et les flux de journaux, consultez la section [Utilisation des groupes de journaux et des flux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) de CloudWatch journaux dans le guide de l'utilisateur Amazon Logs. ### Utilisation d’objets de journalisation standard dans Athena pour Spark Dans une session Athena for Spark, vous pouvez utiliser les deux objets de journalisation standard mondiaux suivants pour écrire des journaux sur Amazon : CloudWatch + **athena\$1user\$1logger — Envoie les journaux uniquement** à. CloudWatch Utilisez cet objet lorsque vous souhaitez enregistrer des informations directement dans lesquelles vos applications Spark sont CloudWatch enregistrées, comme dans l'exemple suivant. ``` athena_user_logger.info("CloudWatch log line.") ``` L'exemple écrit un événement de journal CloudWatch comme suit : ``` AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: CloudWatch log line. ``` + **athena\$1shared\$1logger** — Envoie le même journal à et à des fins d'assistance. CloudWatch AWS Vous pouvez utiliser cet objet pour partager des journaux avec les équipes de AWS service à des fins de résolution des problèmes, comme dans l'exemple suivant. ``` athena_shared_logger.info("Customer debug line.") var = [...some variable holding customer data...] athena_shared_logger.info(var) ``` L'exemple enregistre la `debug` ligne et la valeur de la `var` variable dans CloudWatch Logs et envoie une copie de chaque ligne à Support. **Note** Pour des raisons de confidentialité, votre code de calcul et vos résultats ne sont pas partagés avec AWS. Veillez à ce que vos appels à `athena_shared_logger` n'écrivent que les informations que vous voulez rendre visibles à Support. Les enregistreurs fournis écrivent des événements via [Apache Log4j](https://logging.apache.org/log4j/) et héritent les niveaux de journalisation de cette interface. Les valeurs de niveau de journalisation possibles sont `DEBUG`, `ERROR`, `FATAL`, `INFO`, `WARN` et `WARNING`. Vous pouvez utiliser la fonction nommée correspondante sur l'enregistreur pour produire ces valeurs. **Note** Ne reliez pas les noms `athena_user_logger` ou `athena_shared_logger`. Cela empêche les objets de journalisation d'écrire CloudWatch pendant le reste de la session. ### Exemple : consigner les événements du bloc-notes dans CloudWatch La procédure suivante explique comment enregistrer les événements du bloc-notes Athena dans Amazon CloudWatch Logs. **Pour enregistrer les événements du bloc-notes Athena dans Amazon Logs CloudWatch** 1. Suivez [Prise en main d’Apache Spark dans Amazon Athena](notebooks-spark-getting-started.md) pour créer un groupe de travail compatible avec Spark dans Athena avec un nom unique. Ce tutoriel utilise le nom de groupe de travail `athena-spark-example`. 1. Suivez les étapes de [Étape 7 : Création de votre propre bloc-notes](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) pour créer un bloc-notes et lancer une nouvelle session. 1. Dans l'éditeur de bloc-notes Athena, dans une nouvelle cellule de bloc-notes, saisissez la commande suivante : ``` athena_user_logger.info("Hello world.") ``` 1. Exécuter la cellule. 1. Récupérez l'ID de la session actuelle en effectuant l'une des opérations suivantes : + Affichez la sortie de la cellule (par exemple, `... session=72c24e73-2c24-8b22-14bd-443bdcd72de4`). + Dans une nouvelle cellule, exécutez la commande [magique](notebooks-spark-magics.md) `%session_id`. 1. Enregistrer l'ID de la session. 1. Avec le même Compte AWS que celui que vous utilisez pour exécuter la session du bloc-notes, ouvrez la CloudWatch console à l'adresse [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Dans le volet de navigation de la CloudWatch console, sélectionnez **Log groups**. 1. Dans la liste des groupes de journaux, choisissez le groupe de journaux qui porte le nom de votre groupe de travail Athena compatible avec Spark, comme dans l'exemple suivant. ``` /aws-athena/athena-spark-example ``` La section **Log streams** (Flux de journaux) contient une liste d'un ou plusieurs liens de flux de journaux pour le groupe de travail. Le nom de chaque flux de journaux contient l'ID de la session, l'ID de l'exécuteur et l'UUID unique, séparés par des barres obliques. Par exemple, si l'ID de la session est `5ac22d11-9fd8-ded7-6542-0412133d3177` et l'ID de l'exécuteur est `f8c22d11-9fd8-ab13-8aba-c4100bfba7e2`, le nom du flux de journaux ressemble à l'exemple suivant. ``` 5ac22d11-9fd8-ded7-6542-0412133d3177/f8c22d11-9fd8-ab13-8aba-c4100bfba7e2/f012d7cb-cefd-40b1-90b9-67358f003d0b ``` 1. Choisissez le lien du flux de journaux pour votre session. 1. Sur la page **Log events** (Événements du journal), consultez la colonne **Message**. L'événement du journal pour la cellule que vous avez exécutée ressemble à ce qui suit : ``` AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: Hello world. ``` 1. Retournez à l'éditeur de blocs-notes Athena. 1. Dans une nouvelle cellule, saisissez le code suivant. Le code enregistre une variable pour CloudWatch : ``` x = 6 athena_user_logger.warn(x) ``` 1. Exécuter la cellule. 1. Retournez à la page **des événements du journal** de la CloudWatch console pour le même flux de journal. 1. Le flux de journaux contient maintenant une entrée d'événement du journal avec un message comme le suivant : ``` AthenaForApacheSpark: 2022-01-01 12:00:00,000 WARN builtins: 6 ``` # CloudTrail À utiliser pour résoudre les appels d'API du bloc-notes Athena Pour résoudre les problèmes liés aux appels d'API du bloc-notes, vous pouvez examiner les journaux d' CloudTrail Athena afin d'identifier les anomalies ou de découvrir les actions initiées par les utilisateurs. Pour des informations détaillées sur l'utilisation CloudTrail avec Athena, consultez. [Enregistrez les appels d'API Amazon Athena avec AWS CloudTrail](monitor-with-cloudtrail.md) Les exemples suivants illustrent les entrées du CloudTrail journal pour le bloc-notes Athena. APIs ## StartSession L'exemple suivant montre le CloudTrail journal d'un [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)événement de bloc-notes. ``` { "eventVersion": "1.08", "userIdentity": { "type": "AssumedRole", "principalId": "EXAMPLE_PRINCIPAL_ID:alias", "arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias", "accountId": "123456789012", "accessKeyId": "EXAMPLE_KEY_ID", "sessionContext": { "sessionIssuer": { "type": "Role", "principalId": "EXAMPLE_PRINCIPAL_ID", "arn": "arn:aws:iam::123456789012:role/Admin", "accountId": "123456789012", "userName": "Admin" }, "webIdFederationData": {}, "attributes": { "creationDate": "2022-10-14T16:41:51Z", "mfaAuthenticated": "false" } } }, "eventTime": "2022-10-14T17:05:36Z", "eventSource": "athena.amazonaws.com", "eventName": "StartSession", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.10", "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36", "requestParameters": { "workGroup": "notebook-workgroup", "engineConfiguration": { "coordinatorDpuSize": 1, "maxConcurrentDpus": 20, "defaultExecutorDpuSize": 1, "additionalConfigs": { "NotebookId": "b8f5854b-1042-4b90-9d82-51d3c2fd5c04", "NotebookIframeParentUrl": "https://us-east-1.console.aws.amazon.com" } }, "notebookVersion": "KeplerJupyter-1.x", "sessionIdleTimeoutInMinutes": 20, "clientRequestToken": "d646ff46-32d2-42f0-94d1-d060ec3e5d78" }, "responseElements": { "sessionId": "a2c1ebba-ad01-865f-ed2d-a142b7451f7e", "state": "CREATED" }, "requestID": "d646ff46-32d2-42f0-94d1-d060ec3e5d78", "eventID": "b58ce998-eb89-43e9-8d67-d3d8e30561c9", "readOnly": false, "eventType": "AwsApiCall", "managementEvent": true, "recipientAccountId": "123456789012", "eventCategory": "Management", "tlsDetails": { "tlsVersion": "TLSv1.2", "cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256", "clientProvidedHostHeader": "athena.us-east-1.amazonaws.com" }, "sessionCredentialFromConsole": "true" } ``` ## TerminateSession L'exemple suivant montre le CloudTrail journal d'un [TerminateSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_TerminateSession.html)événement de bloc-notes. ``` { "eventVersion": "1.08", "userIdentity": { "type": "AssumedRole", "principalId": "EXAMPLE_PRINCIPAL_ID:alias", "arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias", "accountId": "123456789012", "accessKeyId": "EXAMPLE_KEY_ID", "sessionContext": { "sessionIssuer": { "type": "Role", "principalId": "EXAMPLE_PRINCIPAL_ID", "arn": "arn:aws:iam::123456789012:role/Admin", "accountId": "123456789012", "userName": "Admin" }, "webIdFederationData": {}, "attributes": { "creationDate": "2022-10-14T16:41:51Z", "mfaAuthenticated": "false" } } }, "eventTime": "2022-10-14T17:21:03Z", "eventSource": "athena.amazonaws.com", "eventName": "TerminateSession", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.11", "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36", "requestParameters": { "sessionId": "a2c1ebba-ad01-865f-ed2d-a142b7451f7e" }, "responseElements": { "state": "TERMINATING" }, "requestID": "438ea37e-b704-4cb3-9a76-391997cf42ee", "eventID": "49026c5a-bf58-4cdb-86ca-978e711ad238", "readOnly": false, "eventType": "AwsApiCall", "managementEvent": true, "recipientAccountId": "123456789012", "eventCategory": "Management", "tlsDetails": { "tlsVersion": "TLSv1.2", "cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256", "clientProvidedHostHeader": "athena.us-east-1.amazonaws.com" }, "sessionCredentialFromConsole": "true" } ``` ## ImportNotebook L'exemple suivant montre le CloudTrail journal d'un [ImportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ImportNotebook.html)événement de bloc-notes. Pour des raisons de sécurité, certains contenus sont cachés. ``` { "eventVersion": "1.08", "userIdentity": { "type": "AssumedRole", "principalId": "EXAMPLE_PRINCIPAL_ID:alias", "arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias", "accountId": "123456789012", "accessKeyId": "EXAMPLE_KEY_ID", "sessionContext": { "sessionIssuer": { "type": "Role", "principalId": "EXAMPLE_PRINCIPAL_ID", "arn": "arn:aws:iam::123456789012:role/Admin", "accountId": "123456789012", "userName": "Admin" }, "webIdFederationData": {}, "attributes": { "creationDate": "2022-10-14T16:41:51Z", "mfaAuthenticated": "false" } } }, "eventTime": "2022-10-14T17:08:54Z", "eventSource": "athena.amazonaws.com", "eventName": "ImportNotebook", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.12", "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36", "requestParameters": { "workGroup": "notebook-workgroup", "name": "example-notebook-name", "payload": "HIDDEN_FOR_SECURITY_REASONS", "type": "IPYNB", "contentMD5": "HIDDEN_FOR_SECURITY_REASONS" }, "responseElements": { "notebookId": "05f6225d-bdcc-4935-bc25-a8e19434652d" }, "requestID": "813e777f-6dac-41f4-82a7-e99b7b33f319", "eventID": "4abec837-143b-4458-9c1f-fa9fb88ab69b", "readOnly": false, "eventType": "AwsApiCall", "managementEvent": true, "recipientAccountId": "123456789012", "eventCategory": "Management", "tlsDetails": { "tlsVersion": "TLSv1.2", "cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256", "clientProvidedHostHeader": "athena.us-east-1.amazonaws.com" }, "sessionCredentialFromConsole": "true" } ``` ## UpdateNotebook L'exemple suivant montre le CloudTrail journal d'un [UpdateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html)événement de bloc-notes. Pour des raisons de sécurité, certains contenus sont cachés. ``` { "eventVersion": "1.08", "userIdentity": { "type": "AssumedRole", "principalId": "EXAMPLE_PRINCIPAL_ID:AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f", "arn": "arn:aws:sts::123456789012:assumed-role/AWSAthenaSparkExecutionRole-om0yj71w5l/AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f", "accountId": "123456789012", "accessKeyId": "EXAMPLE_KEY_ID", "sessionContext": { "sessionIssuer": { "type": "Role", "principalId": "EXAMPLE_PRINCIPAL_ID", "arn": "arn:aws:iam::123456789012:role/service-role/AWSAthenaSparkExecutionRole-om0yj71w5l", "accountId": "123456789012", "userName": "AWSAthenaSparkExecutionRole-om0yj71w5l" }, "webIdFederationData": {}, "attributes": { "creationDate": "2022-10-14T16:48:06Z", "mfaAuthenticated": "false" } } }, "eventTime": "2022-10-14T16:52:22Z", "eventSource": "athena.amazonaws.com", "eventName": "UpdateNotebook", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.13", "userAgent": "Boto3/1.24.84 Python/3.8.14 Linux/4.14.225-175.364.amzn2.aarch64 Botocore/1.27.84", "requestParameters": { "notebookId": "c87553ff-e740-44b5-884f-a70e575e08b9", "payload": "HIDDEN_FOR_SECURITY_REASONS", "type": "IPYNB", "contentMD5": "HIDDEN_FOR_SECURITY_REASONS", "sessionId": "9cc1ebb2-aac5-b1ca-8247-5d827bd8232f" }, "responseElements": null, "requestID": "baaba1d2-f73d-4df1-a82b-71501e7374f1", "eventID": "745cdd6f-645d-4250-8831-d0ffd2fe3847", "readOnly": false, "eventType": "AwsApiCall", "managementEvent": true, "recipientAccountId": "123456789012", "eventCategory": "Management", "tlsDetails": { "tlsVersion": "TLSv1.2", "cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256", "clientProvidedHostHeader": "athena.us-east-1.amazonaws.com" } } ``` ## StartCalculationExecution L'exemple suivant montre le CloudTrail journal d'un [StartCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartCalculationExecution.html)événement de bloc-notes. Pour des raisons de sécurité, certains contenus sont cachés. ``` { "eventVersion": "1.08", "userIdentity": { "type": "AssumedRole", "principalId": "EXAMPLE_PRINCIPAL_ID:AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f", "arn": "arn:aws:sts::123456789012:assumed-role/AWSAthenaSparkExecutionRole-om0yj71w5l/AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f", "accountId": "123456789012", "accessKeyId": "EXAMPLE_KEY_ID", "sessionContext": { "sessionIssuer": { "type": "Role", "principalId": "EXAMPLE_PRINCIPAL_ID", "arn": "arn:aws:iam::123456789012:role/service-role/AWSAthenaSparkExecutionRole-om0yj71w5l", "accountId": "123456789012", "userName": "AWSAthenaSparkExecutionRole-om0yj71w5l" }, "webIdFederationData": {}, "attributes": { "creationDate": "2022-10-14T16:48:06Z", "mfaAuthenticated": "false" } } }, "eventTime": "2022-10-14T16:52:37Z", "eventSource": "athena.amazonaws.com", "eventName": "StartCalculationExecution", "awsRegion": "us-east-1", "sourceIPAddress": "203.0.113.14", "userAgent": "Boto3/1.24.84 Python/3.8.14 Linux/4.14.225-175.364.amzn2.aarch64 Botocore/1.27.84", "requestParameters": { "sessionId": "9cc1ebb2-aac5-b1ca-8247-5d827bd8232f", "description": "Calculation started via Jupyter notebook", "codeBlock": "HIDDEN_FOR_SECURITY_REASONS", "clientRequestToken": "0111cd63-4fd0-4ad8-a738-fd350115fc21" }, "responseElements": { "calculationExecutionId": "82c1ebb4-bd08-e4c3-5631-a662fb2ff2c5", "state": "CREATING" }, "requestID": "1a107461-3f1b-481e-b8a2-7fbd524e2373", "eventID": "b74dbd00-e839-4bd1-a1da-b75fbc70ab9a", "readOnly": false, "eventType": "AwsApiCall", "managementEvent": true, "recipientAccountId": "123456789012", "eventCategory": "Management", "tlsDetails": { "tlsVersion": "TLSv1.2", "cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256", "clientProvidedHostHeader": "athena.us-east-1.amazonaws.com" } } ``` # Dépassement de la limite de taille de 68 000 caractères des blocs de code Athena pour Spark a une limite de taille des blocs de code de calcul connue de 68 000 caractères. Lorsque vous exécutez un calcul avec un bloc de code dépassant cette limite, le message d'erreur suivant peut s'afficher : «... » à « CodeBlock » ne satisfait pas à la contrainte : le membre doit avoir une longueur inférieure ou égale à 68000 L'image suivante montre cette erreur dans l'éditeur de bloc-notes de la console Athena. ![\[Message d'erreur concernant la taille des blocs de code dans l'éditeur de bloc-notes Athena\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-troubleshooting-code-block-size-limit-1.png) La même erreur peut se produire lorsque vous utilisez le AWS CLI pour exécuter un calcul comportant un bloc de code volumineux, comme dans l'exemple suivant. ``` aws athena start-calculation-execution \ --session-id "{SESSION_ID}" \ --description "{SESSION_DESCRIPTION}" \ --code-block "{LARGE_CODE_BLOCK}" ``` La commande affiche le message d'erreur suivant : *\$1LARGE\$1CODE\$1BLOCK\$1*à 'CodeBlock', la contrainte n'a pas été respectée : le membre doit avoir une longueur inférieure ou égale à 68000 ## Solution Pour contourner ce problème, chargez le fichier contenant votre code de requête ou de calcul sur Amazon S3. Utilisez ensuite boto3 pour lire le fichier et exécuter votre SQL ou votre code. Les exemples suivants supposent que vous avez déjà chargé le fichier contenant votre requête SQL ou votre code Python sur Amazon S3. ### Exemple SQL L'exemple de code suivant lit le fichier `large_sql_query.sql` à partir d'un compartiment Amazon S3, puis exécute la requête volumineuse que le fichier contient. ``` s3 = boto3.resource('s3') def read_s3_content(bucket_name, key): response = s3.Object(bucket_name, key).get() return response['Body'].read() # SQL sql = read_s3_content('bucket_name', 'large_sql_query.sql') df = spark.sql(sql) ``` ### PySpark exemple L'exemple de code suivant lit le fichier `large_py_spark.py` à partir d'Amazon S3, puis exécute le bloc de code volumineux que le fichier contient. ``` s3 = boto3.resource('s3') def read_s3_content(bucket_name, key): response = s3.Object(bucket_name, key).get() return response['Body'].read() # PySpark py_spark_code = read_s3_content('bucket_name', 'large_py_spark.py') exec(py_spark_code) ``` # Correction des erreurs de session Les informations fournies dans cette section vous aideront à résoudre les problèmes liés aux sessions. Lorsqu'une erreur de configuration personnalisée se produit lors du démarrage d'une session, la console Athena pour Spark affiche une bannière de message d'erreur. Pour résoudre les erreurs de démarrage de session, vous pouvez vérifier le changement d'état de la session ou les informations de journalisation. ## Affichage des informations de changement d’état de la session Vous pouvez obtenir des informations sur un changement d'état de session à partir de l'éditeur de bloc-notes Athena ou de l'API Athena. **Pour afficher les informations sur l'état de session dans la console Athena** 1. Dans l'éditeur de bloc-notes Athena, dans le menu **Session** en haut à droite, choisissez **Afficher les détails**. 1. Consultez l'onglet **Session en cours**. La section **Informations de session** affiche des informations telles que l'ID de session, le groupe de travail, le statut et le motif du changement d'état. L'exemple de capture d'écran suivant montre les informations contenues dans la section **Motif du changement d'état** de la boîte de dialogue **Informations de session** pour une erreur de session Spark dans Athena. ![\[Affichage des informations de changement d'état de la session dans la console Athena pour Spark.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/notebooks-spark-custom-jar-cfg-1.jpeg) **Pour afficher les informations sur l'état de la session à l'aide de l'API Athena** + Dans l'API Athena, vous pouvez trouver des informations sur le changement d'état de session dans le `StateChangeReason` champ de [SessionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_SessionStatus.html)l'objet. **Note** Après avoir arrêté manuellement une session, ou si la session s'arrête après un délai d'inactivité (la valeur par défaut est de 20 minutes), la valeur des **StateChangeReason**modifications apportées à la session a été interrompue par demande. ## Utilisation de la journalisation pour corriger les erreurs de démarrage de session Les erreurs de configuration personnalisées qui se produisent lors du démarrage d'une session sont enregistrées par [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html). Dans vos CloudWatch journaux, recherchez les messages d'erreur provenant de pour résoudre les problèmes liés `AthenaSparkSessionErrorLogger` à l'échec du démarrage d'une session. Pour plus d’informations sur la journalisation Spark, consultez [Journalisation des événements de l’application Spark dans Athena](notebooks-spark-logging.md). Pour plus d'informations sur la résolution des problèmes des sessions dans Athena pour Spark, consultez [Correction des erreurs de session](#notebooks-spark-troubleshooting-sessions). ## Problèmes spécifiques liés aux sessions Les informations fournies dans cette section vous aideront à résoudre des problèmes spécifiques liés aux sessions. ### Session en mauvais état Si vous recevez le message d'erreur Session in unhealthy state (Session en mauvais état). Veuillez créer une nouvelle session, mettre fin à votre session existante et en créer une nouvelle. ### Impossible d'établir une connexion au serveur du bloc-notes Lorsque vous ouvrez un bloc-notes, il est possible que le message d'erreur suivant s'affiche : ``` A connection to the notebook server could not be established. The notebook will continue trying to reconnect. Check your network connection or notebook server configuration. ``` #### Cause Lorsqu'Athena ouvre un bloc-notes, Athena crée une session et se connecte au bloc-notes à l'aide d'une URL de bloc-notes pré-signée. La connexion à l'ordinateur portable utilise le protocole WSS ([WebSocketSecure](https://en.wikipedia.org/wiki/WebSocket)). L'erreur peut se produire pour les raisons suivantes : + Un pare-feu local (par exemple, un pare-feu à l'échelle de l'entreprise) bloque le trafic WSS. + Un proxy ou un logiciel anti-virus sur votre ordinateur local bloque la connexion WSS. #### Solution Supposons que vous ayez une connexion WSS dans la région `us-east-1` comme suit : ``` wss://94c2bcdf-66f9-4d17-9da6-7e7338060183.analytics-gateway.us-east-1.amazonaws.com/ api/kernels/33c78c82-b8d2-4631-bd22-1565dc6ec152/channels?session_id= 7f96a3a048ab4917b6376895ea8d7535 ``` Pour résoudre cette erreur, utilisez l'une des stratégies suivantes. + Utilisez la syntaxe du modèle générique pour autoriser le trafic WSS de liste sur le port `443` à travers Régions AWS et Comptes AWS. ``` wss://*amazonaws.com ``` + Utilisez la syntaxe du modèle générique pour autoriser le trafic WSS répertorié sur le port `443` dans un port Région AWS et entre les ports Comptes AWS dans le port Région AWS que vous spécifiez. L’exemple suivant utilise `us-east-1`. ``` wss://*analytics-gateway.us-east-1.amazonaws.com ``` # Correction des erreurs de table Les informations fournies dans cette section vous aideront à corriger les erreurs de table dans Athena for Spark. ## Impossible de créer une erreur de chemin lors de la création d'une table **Message d'erreur IllegalArgumentException** : Impossible de créer un chemin à partir d'une chaîne vide. **Cause** : Cette erreur peut se produire lorsque vous utilisez Apache Spark dans Athena pour créer une table dans une AWS Glue base de données et que la propriété de la base de données est vide`LOCATION`. **Solution suggérée** : pour plus d'informations et de solutions, voir [Exception d'argument non valide lors de la création d'une table](notebooks-spark-known-issues.md#notebooks-spark-known-issues-illegal-argument-exception). ## AccessDeniedException lors de l'interrogation de tables AWS Glue **Message d'erreur** : pyspark.sql.utils. AnalysisException: Impossible de vérifier l'existence de la base de données par défaut : com.amazonaws.services.glue.model. AccessDeniedException: L'utilisateur : arn:aws:sts : ::assumed-role/ *aws-account-id* - AWSAthenaSparkExecutionRole/*unique-identifier*- *unique-identifier* n'AthenaExecutorest pas autorisé à exécuter : glue : on GetDatabase resource : arn:aws:glue : :catalog *aws-region* car *aws-account-id* aucune politique basée sur l'identité n'autorise l'action glue : (GetDatabase Service : ; Code d'état : 400 ; Code d'erreur : ; ID de demande : ; Proxy : null) AWSGlue AccessDeniedException *request-id* **Cause** : le rôle d'exécution de votre groupe de travail activé par Spark ne dispose pas des autorisations nécessaires pour accéder aux ressources. AWS Glue **Solution suggérée** : pour résoudre ce problème, accordez à votre rôle d'exécution l'accès aux AWS Glue ressources, puis modifiez votre politique de compartiment Amazon S3 pour accorder l'accès à votre rôle d'exécution. La procédure suivante décrit de manière plus détaillée ces étapes. **Pour accorder à votre rôle d'exécution l'accès aux AWS Glue ressources** 1. Ouvrez la console à l'adresse [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home). 1. Si le panneau de navigation de la console n'est pas visible, choisissez le menu d'extension sur la gauche. ![\[Choisissez le menu d'expansion.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/nav-pane-expansion.png) 1. Dans le panneau de navigation de la console Athena, choisissez **Workgroups** (Groupes de travail). 1. Sur la page **Workgroups** (Groupes de travail), choisissez le lien du groupe de travail à consulter. 1. Sur la page **Overview Details** (Présentation détaillée) du groupe de travail, cliquez sur le lien **Role ARN** (ARN de rôle). Le lien ouvre le rôle d'exécution Spark dans la console IAM. 1. Dans la section **Permissions policies** (Politiques d'autorisations), choisissez le nom de la politique de rôle liée. 1. Choisissez **Edit policy** (Modifier une politique), puis choisissez **JSON**. 1. Ajoutez AWS Glue l'accès au rôle. En général, vous ajoutez des autorisations pour les actions `glue:GetDatabase` et `glue:GetTable`. Pour plus d'informations sur la configuration des rôles IAM, voir [Ajout et suppression d'autorisations basées sur l'identité IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) dans le Guide de l'utilisateur IAM. 1. Choisissez **Review policy (Examiner une stratégie)**, puis **Save changes (Enregistrer les modifications)**. 1. Modifiez la politique de votre compartiment Amazon S3 pour accorder l'accès au rôle d'exécution. Notez que vous devez accorder au rôle l'accès à la fois au compartiment et aux objets qu'il contient. Pour les étapes, voir [Ajout d'une politique de compartiment à l'aide de la console Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-bucket-policy.html) dans le Guide de l'utilisateur Amazon Simple Storage Service. # Accès au support Pour obtenir de l'aide auprès de AWS, choisissez **Support****, Support Center** dans le AWS Management Console. Pour faciliter votre expérience, veuillez avoir les informations suivantes à portée de main : + ID de la requête Athena + ID de session + ID du calcul