Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzare Apache Spark in Amazon Athena
Amazon Athena facilita l'esecuzione di analisi e l'esplorazione dei dati in modo interattivo mediante Apache Spark senza la necessità di pianificare, configurare o gestire le risorse. Eseguire le applicazioni Apache Spark su Athena significa inviare il codice Spark per l'elaborazione e ricevere direttamente i risultati senza la necessità di configurazioni aggiuntive. Apache Spark su Amazon Athena è serverless e offre il dimensionamento automatico e on demand per l'elaborazione istantanea, in modo da far fronte ai cambiamenti dei volumi di dati e dei requisiti di elaborazione.
Nella versione di rilascio[PySpark versione del motore 3](notebooks-spark-release-versions.md#notebooks-spark-release-versions-pyspark-3), puoi utilizzare l'esperienza notebook semplificata nella console Amazon Athena per sviluppare applicazioni Apache Spark utilizzando Python o notebook Athena. APIs
Nella versione release[Apache Spark versione 3.5](notebooks-spark-release-versions.md#notebooks-spark-release-versions-spark-35), puoi eseguire il codice Spark dai notebook Amazon SageMaker Unified Studio o dai tuoi client preferiti compatibili con Spark Connect.
Amazon Athena offre le seguenti funzionalità:
+ **Utilizzo della console**: invia le tue applicazioni Spark dalla console Amazon Athena (solo Pyspark enginer versione 3).
+ **Scripting**: crea ed esegui il debug di applicazioni Apache Spark in Python in modo rapido e interattivo.
+ **Dimensionamento dinamico**: Amazon Athena determina automaticamente le risorse di elaborazione e memoria necessarie per eseguire un processo e dimensiona continuamente tali risorse di conseguenza fino ai massimi specificati. Questo dimensionamento dinamico riduce i costi senza influire sulla velocità.
+ **Esperienza notebook**: usa i notebook Amazon SageMaker AI Unified Studio per creare, modificare ed eseguire calcoli utilizzando un'interfaccia familiare. Nella versione 3 del motore Pyspark, puoi utilizzare notebook in-console Athena compatibili con i notebook Jupyter e contenenti un elenco di celle che vengono eseguite in ordine come calcoli. Il contenuto delle celle può includere codice, testo, Markdown, matematica, grafici e rich media.
Per ulteriori informazioni, consultare [Eseguire Spark SQL su Amazon Athena Spark](https://aws.amazon.com/blogs/big-data/run-spark-sql-on-amazon-athena-spark/) ed [Esplora il tuo data lake usando Amazon Athena per Apache Spark](https://aws.amazon.com/blogs/big-data/explore-your-data-lake-using-amazon-athena-for-apache-spark/) nel *Blog sui Big Data di AWS *.
**Topics**
+ [Versioni di rilascio](notebooks-spark-release-versions.md)
+ [Considerazioni e limitazioni](notebooks-spark-considerations-and-limitations.md)
+ [Nozioni di base](notebooks-spark-getting-started.md)
+ [Gestire i file del notebook](notebooks-spark-managing.md)
+ [Editor per notebook](notebooks-spark-editor.md)
+ [Utilizzare formati di tabella non Hive](notebooks-spark-table-formats.md)
+ [Supporto delle librerie Python](notebooks-spark-python-library-support.md)
+ [Specificare una configurazione personalizzata](notebooks-spark-custom-jar-cfg.md)
+ [Formati di dati e archiviazione supportati](notebooks-spark-data-and-storage-formats.md)
+ [Monitora Apache Spark](notebooks-spark-metrics.md)
+ [Attribuzione dei costi](notebooks-spark-cost-attribution.md)
+ [Registrazione di log e monitoraggio](notebooks-spark-logging-monitoring.md)
+ [Accesso all'interfaccia utente Spark](notebooks-spark-ui-access.md)
+ [Spark Connect](notebooks-spark-connect.md)
+ [Abilitare i bucket con pagamento del richiedente](notebooks-spark-requester-pays.md)
+ [Integrazione con Lake Formation](notebooks-spark-lakeformation.md)
+ [Abilitare la crittografia Spark](notebooks-spark-encryption.md)
+ [Accesso al catalogo multi-account](spark-notebooks-cross-account-glue.md)
+ [Service Quotas](notebooks-spark-quotas.md)
+ [Athena Spark APIs](notebooks-spark-api-list.md)
+ [Risoluzione dei problemi](notebooks-spark-troubleshooting.md)
# Versioni di rilascio
Amazon Athena per Apache Spark offre le seguenti versioni di rilascio:
## PySpark versione del motore 3
PySpark la versione 3 include la versione 3.2.1 di Apache Spark. Con questa versione, puoi eseguire il codice Spark nei notebook in-console Athena.
## Apache Spark versione 3.5
La versione 3.5 di Apache Spark è basata su Amazon EMR 7.12 e include la versione 3.5.6 di Apache Spark. Con questa versione, puoi eseguire il codice Spark dal notebook Amazon SageMaker AI Unified Studio o dai tuoi client Spark compatibili preferiti. Questa versione aggiunge funzionalità chiave per offrire un'esperienza migliorata per i carichi di lavoro interattivi:
+ **Secure Spark Connect**: aggiunge Spark Connect come endpoint autenticato e autorizzato. AWS
+ **Attribuzione dei costi a livello di sessione**: gli utenti possono tenere traccia dei costi per sessione interattiva nei report AWS Cost Explorer o Cost and Usage. Per ulteriori informazioni, consulta [Attribuzione dei costi a livello di sessione](notebooks-spark-cost-attribution.md).
+ Funzionalità di **debug avanzate**: aggiunge il supporto live di Spark UI e Spark History Server per il debug dei carichi di lavoro provenienti sia dai notebook che dai notebook. APIs Per ulteriori informazioni, consulta [Accesso all'interfaccia utente di Spark](notebooks-spark-ui-access.md#notebooks-spark-ui-access-methods).
+ supporto per l'accesso **non filtrato: accedi alle tabelle del catalogo di dati protette in** cui disponi delle autorizzazioni complete per le tabelle. AWS Glue Per ulteriori informazioni, consulta [Utilizzo di Lake Formation con i gruppi di lavoro Athena Spark](notebooks-spark-lakeformation.md).
### Proprietà predefinite di Spark
La tabella seguente elenca le proprietà Spark e i relativi valori predefiniti applicati alle sessioni di SparkConnect Athena.
| Chiave | Valore predefinito | Description |
| --- | --- | --- |
| `spark.app.id` | `` | Questo non è modificabile. |
| `spark.app.name` | `default` | |
| `spark.driver.cores` | `4` | Il numero di core utilizzati dal driver. Questo valore non è modificabile durante il lancio iniziale. |
| `spark.driver.memory` | `10g` | Quantità di memoria utilizzata da ogni driver. Non è modificabile durante l'avvio iniziale. |
| `spark.driver.memoryOverhead` | `6g` | Quantità di sovraccarico di memoria assegnata per i carichi di lavoro Python e altri processi in esecuzione sul driver. Questo valore non è modificabile durante il lancio iniziale. |
| `spark.cortex.driver.disk` | `64g` | Il disco del driver Spark. Questo non è modificabile durante il lancio iniziale. |
| `spark.executor.cores` | `4` | Il numero di core utilizzati da ciascun executor. Questo valore non è modificabile durante il lancio iniziale. |
| `spark.executor.memory` | `10g` | Quantità di memoria utilizzata da ogni driver. |
| `spark.executor.memoryOverhead` | `6g` | Quantità di sovraccarico di memoria assegnata per i carichi di lavoro Python e altri processi in esecuzione sull'executor. Questo valore non è modificabile durante il lancio iniziale. |
| `spark.cortex.executor.disk` | `64g` | Il disco Spark Executor. Questo non è modificabile durante il lancio iniziale. |
| `spark.cortex.executor.architecture` | `AARCH_64` | Architettura dell'esecutore. |
| `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` | Opzioni Java aggiuntive per il driver Spark. Questo non è modificabile durante il lancio iniziale. |
| `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` | Opzioni Java aggiuntive per l'esecutore Spark. Questo non è modificabile durante il lancio iniziale. |
| `spark.executor.instances` | `1` | Il numero di contenitori Spark Executor da allocare. |
| `spark.dynamicAllocation.enabled` | `TRUE` | Opzione che attiva l'allocazione dinamica delle risorse. Questa opzione aumenta o riduce il numero di esecutori registrati con l'applicazione, in base al carico di lavoro. |
| `spark.dynamicAllocation.minExecutors` | `0` | Il limite inferiore per il numero di esecutori se si attiva l'allocazione dinamica. |
| `spark.dynamicAllocation.maxExecutors` | `59` | Il limite superiore per il numero di esecutori se si attiva l'allocazione dinamica. |
| `spark.dynamicAllocation.initialExecutors` | `1` | Il numero iniziale di executor da eseguire se si attiva l'allocazione dinamica. |
| `spark.dynamicAllocation.executorIdleTimeout` | `60s` | Il periodo di tempo in cui un executor può rimanere inattivo prima che Spark lo rimuova. Questo vale solo se attivi l'allocazione dinamica. |
| `spark.dynamicAllocation.shuffleTracking.enabled` | `TRUE` | L'abilitazione del DRA richiede l'attivazione del tracciamento casuale. |
| `spark.dynamicAllocation.sustainedSchedulerBacklogTimeout` | `1s` | Il timeout definisce per quanto tempo lo scheduler Spark deve osservare un lungo arretrato di attività in sospeso prima di attivare una richiesta al gestore del cluster di avviare nuovi esecutori. |
| `spark.sql.catalogImplementation` | `hive` | |
| `spark.hadoop.hive.metastore.client.factory.class` | `com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory` | AWS Glue La classe di implementazione del metastore. |
| `spark.hadoop.hive.metastore.glue.catalogid` | `` | AWS Glue catalogo AccountId. |
| `spark.sql.hive.metastore.sharedPrefixes` | `software.amazon.awssdk.services.dynamodb` | La proprietà specifica un elenco separato da virgole di prefissi di pacchetto per le classi che devono essere caricate dall'applicazione ClassLoader anziché il codice isolato ClassLoader creato per il codice Hive Metastore Client. |
| `spark.hadoop.fs.s3.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Definisce l'implementazione per il client S3 per utilizzare S3A. |
| `spark.hadoop.fs.s3a.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Definisce l'implementazione per il client S3A (S3A). |
| `spark.hadoop.fs.s3n.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Definisce l'implementazione per il client S3 nativo (S3N) per utilizzare 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` | Questa proprietà abilita un protocollo di commit ottimizzato per i job Spark durante la scrittura di dati su Amazon S3. Se impostata su true, aiuta Spark a evitare costose operazioni di ridenominazione dei file, con conseguenti scritture atomiche più veloci e affidabili rispetto al committer Hadoop predefinito. |
| `spark.hadoop.fs.s3a.endpoint.region` | `` | Questa configurazione imposta in modo esplicito la AWS regione per il bucket Amazon S3 a cui si accede tramite il client S3A. |
| `spark.hadoop.fs.s3.getObject.initialSocketTimeoutMilliseconds` | `2000` | Questo specifica il timeout della connessione al socket in millisecondi. |
| `spark.hadoop.fs.s3a.committer.magic.enabled` | `TRUE` | Ciò abilita S3A «Magic» Committer, un protocollo di commit altamente performante ma specifico che si basa sul supporto del gestore del cluster sottostante per percorsi speciali. |
| `spark.hadoop.fs.s3a.committer.magic.track.commits.in.memory.enabled` | `TRUE` | Rilevante solo quando il Magic Committer è abilitato, specifica se l'elenco dei file salvati da un'attività deve essere registrato in memoria anziché essere scritto su file temporanei del disco. |
| `spark.hadoop.fs.s3a.committer.name` | `magicv2` | Questa impostazione seleziona esplicitamente lo specifico algoritmo S3A Output Committer da utilizzare (ad esempio, directory, partizionato o magico). Specificando il nome, scegli la strategia che gestisce i dati temporanei, gestisce gli errori delle attività ed esegue il commit atomico finale sul percorso Amazon S3 di destinazione. |
| `spark.hadoop.fs.s3.s3AccessGrants.enabled` | `FALSE` | Property abilita il supporto per Amazon S3 Access Grants quando si accede ai dati Amazon S3 tramite il client di file system S3A/EMRFS. |
| `spark.hadoop.fs.s3.s3AccessGrants.fallbackToIAM` | `FALSE` | Quando Amazon S3 Access Grants è abilitato, questa proprietà controlla se il client Amazon S3 deve ricorrere alle credenziali IAM tradizionali se la ricerca di Access Grants fallisce o non fornisce autorizzazioni sufficienti. |
| `spark.pyspark.driver.python` | `/usr/bin/python3.11` | Percorso Python per il driver. |
| `spark.pyspark.python` | `/usr/bin/python3.11` | Percorso Python per executor. |
| `spark.python.use.daemon` | `TRUE` | Questa configurazione controlla se Spark utilizza un processo daemon di lavoro Python su ogni executor. Se abilitato (true, l'impostazione predefinita), l'executor mantiene attivo il worker Python tra un'attività e l'altra per evitare il sovraccarico dovuto al lancio e all'inizializzazione ripetuti di un nuovo interprete Python per ogni attività, migliorando significativamente le prestazioni delle applicazioni. PySpark |
| `spark.sql.execution.arrow.pyspark.enabled` | `TRUE` | Consente l'uso di Apache Arrow per ottimizzare il trasferimento di dati tra i processi JVM e Python in. PySpark |
| `spark.sql.execution.arrow.pyspark.fallback.enabled` | `TRUE` | Proprietà di configurazione che controlla il comportamento di Spark quando si verifica un errore durante il trasferimento dei dati tra JVM e Python utilizzando l'ottimizzazione Apache Arrow. |
| `spark.sql.parquet.fs.optimized.committer.optimization-enabled` | `TRUE` | Proprietà di configurazione che controlla se Spark utilizza un file committer ottimizzato per scrivere file Parquet su determinati file system, in particolare sistemi di archiviazione cloud come Amazon S3. |
| `spark.sql.parquet.output.committer.class` | `com.amazon.emr.committer.EmrOptimizedSparkSqlParquetOutputCommitter` | Proprietà di configurazione Spark che specifica il nome completo della classe Hadoop da utilizzare durante la scrittura OutputCommitter di file Parquet. |
| `spark.resourceManager.cleanupExpiredHost` | `TRUE` | Questa proprietà controlla se il Driver pulisce attivamente le risorse dell'applicazione Spark associate agli executor in esecuzione su nodi che sono stati eliminati o scaduti. |
| `spark.blacklist.decommissioning.enabled` | `TRUE` | La proprietà consente alla logica di Spark di inserire automaticamente nella lista nera gli esecutori attualmente in fase di disattivazione (chiusura graduale) da parte del gestore del cluster. Ciò impedisce allo scheduler di inviare nuove attività agli esecutori che stanno per uscire, migliorando la stabilità del lavoro durante la riduzione delle risorse. |
| `spark.blacklist.decommissioning.timeout` | `1h` | Tempo massimo di attesa che Spark permetta a Spark di migrare correttamente un'attività da un executor in fase di disattivazione prima di inserire l'host nella lista nera. |
| `spark.stage.attempt.ignoreOnDecommissionFetchFailure` | `TRUE` | Indica a Spark di essere indulgente e di non fallire un intero tentativo se si verifica un errore di recupero durante la lettura dei dati shuffle da un executor in fase di disattivazione. L'errore di recupero è considerato recuperabile e Spark recupererà nuovamente i dati da una posizione diversa (richiedendo potenzialmente un nuovo calcolo), dando priorità al completamento del lavoro rispetto alla rigorosa gestione degli errori durante arresti regolari. |
| `spark.decommissioning.timeout.threshold` | `20` | Questa proprietà viene in genere utilizzata internamente o in specifiche configurazioni di cluster manager per definire la durata totale massima prevista da Spark per il processo di disattivazione di un host. Se il tempo effettivo di disattivazione supera questa soglia, Spark può adottare misure aggressive, come inserire l'host nella lista nera o richiedere la chiusura forzata, per liberare la risorsa. |
| `spark.files.fetchFailure.unRegisterOutputOnHost` | `TRUE` | Quando un'attività non riesce a recuperare dati shuffle o RDD da un host specifico, l'impostazione su true indica a Spark di annullare la registrazione di tutti i blocchi di output associati all'applicazione in errore su quell'host. Ciò impedisce alle attività future di tentare di recuperare dati dall'host inaffidabile, costringendo Spark a ricalcolare i blocchi necessari altrove e aumentando la robustezza del lavoro contro problemi di rete intermittenti. |
# Considerazioni e limitazioni
## Apache Spark versione 3.5
Di seguito sono riportate le considerazioni e le limitazioni per la versione di rilascio di Apache Spark versione 3.5:
+ Questa versione di rilascio è disponibile nelle seguenti versioni: Regioni AWS
+ Asia Pacifico (Mumbai)
+ Asia Pacifico (Seoul)
+ Asia Pacifico (Singapore)
+ Asia Pacifico (Sydney)
+ Asia Pacifico (Tokyo)
+ Canada (Centrale)
+ Europa (Francoforte)
+ Europa (Irlanda)
+ Europa (Londra)
+ Europe (Paris)
+ Europa (Stoccolma)
+ Sud America (San Paolo)
+ Stati Uniti orientali (Virginia settentrionale)
+ Stati Uniti orientali (Ohio)
+ Stati Uniti occidentali (Oregon)
+ Questa versione del motore non supporta i notebook o notebook Athena integrati nella console. APIs Questa versione è invece integrata con i notebook Amazon SageMaker AI Unified Studio. Puoi anche usare client Spark Connect compatibili.
+ Il calcolo APIs -`StartCalculationExecution`, `ListCalculationExecutions` e`GetCalculationExecution`, non sono supportati in questa versione.
+ Non è possibile aggiornare un gruppo di lavoro dalla versione 3 PySpark del motore alla versione 3.5 di Apache Spark.
## Motore Pyspark versione 3
Di seguito sono riportate le considerazioni e le limitazioni per la versione di rilascio del motore Pyspark versione 3:
+ Questa versione di rilascio è disponibile nelle seguenti versioni: Regioni AWS
+ Asia Pacifico (Mumbai)
+ Asia Pacifico (Singapore)
+ Asia Pacifico (Sydney)
+ Asia Pacifico (Tokyo)
+ Europa (Francoforte)
+ Europa (Irlanda)
+ Stati Uniti orientali (Virginia settentrionale)
+ Stati Uniti orientali (Ohio)
+ Stati Uniti occidentali (Oregon)
+ AWS Lake Formation non è supportata.
+ Le tabelle che utilizzano la proiezione delle partizioni non sono supportate.
+ I gruppi di lavoro compatibili con Apache Spark possono utilizzare l'editor di notebook Athena, ma non l'editor di query Athena. Solo i gruppi di lavoro Athena SQL possono utilizzare l'editor di query Athena.
+ Le query di visualizzazione su più motori non sono supportate. Athena per Spark non può eseguire query suulle viste create da Athena SQL. Poiché le viste per i due motori sono implementate in modo diverso, non sono compatibili per l'uso tra motori diversi.
+ MLlib (libreria di machine learning Apache Spark) e il `pyspark.ml` pacchetto non sono supportati. Per un elenco delle librerie Python supportate, consulta la pagina [Elenco delle librerie Python preinstallate](notebooks-spark-preinstalled-python-libraries.md).
+ Al momento, non `pip install` è supportato nelle sessioni di Athena for Spark.
+ È consentita una sola sessione attiva per notebook.
+ Quando più utenti utilizzano la console per aprire una sessione esistente in un gruppo di lavoro, accedono allo stesso notebook. Per evitare confusione, apri solo le sessioni create da te.
+ I domini di hosting per le applicazioni Apache Spark che potresti utilizzare con Amazon Athena (ad esempio, `analytics-gateway.us-east-1.amazonaws.com`) sono registrati nella [Public Suffix List (PSL)](https://publicsuffix.org/list/public_suffix_list.dat) di Internet. Se hai bisogno di impostare cookie sensibili nei tuoi domini, ti consigliamo di utilizzare i cookie con un prefisso `__Host-` per proteggere il tuo dominio dai tentativi di falsificazione delle richieste tra siti (CSRF). Per ulteriori informazioni, consulta la pagina [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) nella documentazione per gli sviluppatori di Mozilla.org.
+ Per informazioni sulla risoluzione dei problemi relativi a notebook, sessioni e gruppi di lavoro Spark in Athena, consulta la pagina [Risolvere problemi in Athena per Spark](notebooks-spark-troubleshooting.md).
# Inizia a usare Apache Spark su Amazon Athena
**Nota**
[Per la versione di rilascio di Apache Spark versione 3.5, segui la guida introduttiva in SageMaker Notebooks.](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html) Usa questa guida per la versione di rilascio del motore Pyspark versione 3.
Per iniziare a utilizzare Apache Spark su Amazon Athena, devi prima di tutto creare un gruppo di lavoro abilitato a Spark. Dopo il passaggio al gruppo di lavoro, è possibile creare un notebook o aprirne uno esistente. Quando apri un notebook in Athena, viene avviata automaticamente una nuova sessione ed è possibile utilizzare il notebook direttamente nell'editor notebook Athena.
**Nota**
Assicurati di creare un gruppo di lavoro abilitato a Spark prima di tentare di creare un notebook.
## Passaggio 1: creare un gruppo di lavoro abilitato a Spark in Athena
Puoi utilizzare i [gruppi di lavoro](workgroups-manage-queries-control-costs.md) in Athena per raggruppare utenti, team, applicazioni o carichi di lavoro e per tenere traccia dei costi. Per utilizzare Apache Spark in Amazon Athena, crei un gruppo di lavoro Amazon Athena che utilizza un motore Spark.
**Nota**
I gruppi di lavoro compatibili con Apache Spark possono utilizzare l'editor di notebook Athena, ma non l'editor di query Athena. Solo i gruppi di lavoro Athena SQL possono utilizzare l'editor di query Athena.
**Creazione di un gruppo di lavoro abilitato a Spark in Athena**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home)
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Nel pannello di navigazione, seleziona **Workgroups** (Gruppi di lavoro).
1. Nella pagina **Gruppi di lavoro** scegli **Crea gruppo di lavoro**.
1. In **Workgroup name** (Nome del gruppo di lavoro), inserisci un nome per il tuo gruppo di lavoro Apache Spark.
1. (Facoltativo) Per **Description** (Descrizione), inserisci una descrizione per il livello.
1. In **Analytics engine** (Motore di analisi), scegli **Apache Spark**.
**Nota**
Dopo avere creato un gruppo di lavoro, il tipo di motore di analisi del gruppo di lavoro non può essere modificato. Ad esempio, un gruppo di lavoro del motore Athena versione 3 non può essere modificato in un gruppo di lavoro PySpark del motore versione 3.
1. Ai fini di questo tutorial, seleziona **Turn on example notebook** (Attiva il notebook di esempio). Questa funzionalità opzionale aggiunge un notebook di esempio con lo stesso nome `example-notebook-random_string` al gruppo di lavoro e aggiunge le autorizzazioni AWS Glue relative che il notebook utilizza per creare, mostrare ed eliminare database e tabelle specifici nel tuo account e le autorizzazioni di lettura in Amazon S3 per il set di dati di esempio. Per visualizzare le autorizzazioni aggiunte, scegli **View additional permissions details** (Visualizza dettagli aggiuntivi sulle autorizzazioni).
**Nota**
L'esecuzione del notebook di esempio potrebbe comportare dei costi aggiuntivi.
1. Perle **impostazioni dei risultati di calcolo**, scegliere una delle seguenti opzioni:
+ **Create a new S3 bucket** (Crea un nuovo bucket S3): questa opzione crea un bucket Amazon S3 nel tuo account per i risultati dei calcoli. Il nome del bucket ha il formato `account_id-region-athena-results-bucket-alphanumeric_id` e utilizza le impostazioni ACLs disabilitate, l'accesso pubblico bloccato, il controllo delle versioni disabilitato e il proprietario del bucket applicato.
+ **Choose an existing S3 location** (Scegli una posizione S3 esistente): per questa opzione, procedi come segue:
+ Inserisci il percorso S3 di una posizione esistente nella casella di ricerca o scegli **Browse S3** (Sfoglia S3) per selezionare un bucket da un elenco.
**Nota**
Quando selezioni una posizione esistente in Amazon S3, non aggiungere una barra (`/`) alla posizione. In questo modo, il collegamento alla posizione dei risultati del calcolo nella [pagina dei dettagli del calcolo](#notebooks-spark-getting-started-viewing-session-and-calculation-details) punta alla directory errata. In tal caso, modifica la posizione dei risultati del gruppo di lavoro rimuovendo la barra finale.
+ (Facoltativo) Scegli **View** (Visualizza) per aprire la pagina **Buckets** (Bucket) della console Amazon S3, dove puoi trovare ulteriori informazioni sul bucket esistente che hai scelto.
+ (Facoltativo) Per **Proprietario previsto del bucket**, inserisci l'ID dell' AWS account che prevedi sia il proprietario del bucket di posizione di output dei risultati della query. Ti consigliamo di scegliere questa opzione come ulteriore misura di sicurezza. Se l'ID account del proprietario del bucket non corrisponde all'ID specificato, i tentativi di output nel bucket avranno esito negativo. Per informazioni dettagliate, consulta [Verifica della proprietà del bucket con condizione del proprietario del bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html) nella *Guida per l'utente di Amazon S3*.
+ (Facoltativo) Seleziona **Assign bucket owner full control over query results** (Assegna al proprietario del bucket il controllo completo dei risultati delle query) se la posizione dei risultati dei calcoli è di proprietà di un altro account e desideri concedere a tale altro account il controllo completo dei risultati delle tue query.
1. (Facoltativo) Scegliere **Encrypt query results** se si desidera crittografare i risultati delle query.
+ In **Encryption type**, scegliere una delle seguenti opzioni:
+ **SSE\$1S3**: questa opzione utilizza la crittografia lato server (SSE) con chiavi crittografia gestite da Amazon S3.
+ **SSE\$1KMS** — Questa opzione utilizza la crittografia lato server (SSE) con chiavi gestite. AWS KMS
Per **Scegli una AWS KMS chiave, scegli una** delle seguenti opzioni.
+ **Usa chiave AWS proprietaria**: la AWS KMS chiave è di proprietà e gestita da AWS. Non ti viene addebitato alcun costo aggiuntivo per l'utilizzo di questa chiave.
+ **Scegli una AWS KMS chiave diversa (avanzata)**: per questa opzione, esegui una delle seguenti operazioni:
+ Per utilizzare una chiave esistente, usa la casella di ricerca per scegliere AWS KMS o immettere una chiave ARN.
+ Per creare una chiave nella AWS KMS console, scegli **Crea una AWS KMS chiave**. Il ruolo di esecuzione deve disporre dell'autorizzazione a utilizzare la chiave che crei. Dopo aver completato la creazione della chiave nella console KMS, torna alla pagina **Crea gruppo di lavoro** nella console Athena, quindi utilizza la casella di ricerca **Scegli una AWS KMS chiave o inserisci un ARN** per scegliere la chiave appena creata.
**Importante**
Quando modifichi la [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) per un gruppo di lavoro, i notebook gestiti prima dell'aggiornamento continuano a fare riferimento alla vecchia chiave KMS. I notebook gestiti dopo l'aggiornamento utilizzano la nuova chiave KMS. Per aggiornare i vecchi notebook in modo che facciano riferimento alla nuova chiave KMS, esporta e quindi importa ciascuno dei vecchi notebook. Se elimini la vecchia chiave KMS prima di aggiornare i riferimenti dei vecchi notebook alla nuova chiave KMS, i vecchi notebook non saranno più decifrabili e non potranno essere recuperati.
Questo comportamento si applica anche agli aggiornamenti degli [alias](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html), che sono nomi semplici per le chiavi KMS. Quando si aggiorna un alias di chiave KMS in modo che punti a una nuova chiave KMS, i notebook gestiti prima dell'aggiornamento dell'alias fanno ancora riferimento alla vecchia chiave KMS, mentre i notebook gestiti dopo l'aggiornamento dell'alias utilizzano la nuova chiave KMS. Tieni a mente questi aspetti prima di aggiornare le chiavi o gli alias KMS.
1. Per **Additional configurations**, scegliere **Use defaults**. Questa opzione aiuta a iniziare a utilizzare il proprio gruppo di lavoro abilitato per Spark. Quando si utilizzano i predefiniti, Athena crea per tuo conto un ruolo IAM e una posizione dei risultati di calcolo in Amazon S3. Il nome del ruolo IAM e la posizione del bucket S3 da creare sono visualizzati nella casella sotto l'intestazione **Additional configurations** (Configurazioni aggiuntive).
Se non si vogliono utilizzare i valori predefiniti, continuare con i passaggi nella sezione [(Facoltativo) Definire configurazioni personalizzate per il gruppo di lavoro](#notebooks-spark-getting-started-workgroup-configuration) per configurare manualmente il gruppo di lavoro.
1. (Facoltativo) **Tags** (Tag): utilizza questa opzione per aggiungere tag al gruppo di lavoro. Per ulteriori informazioni, consulta [Assegnare tag alle risorse di Athena](tags.md).
1. Selezionare **Create workgroup (Crea gruppo di lavoro)**. Un messaggio informa che il gruppo di lavoro è stato creato correttamente e il gruppo di lavoro viene visualizzato nell'elenco dei gruppi di lavoro.
### (Facoltativo) Definire configurazioni personalizzate per il gruppo di lavoro
Se desideri specificare un ruolo IAM e una posizione dei risultati del calcolo personalizzati per il notebook, segui i passaggi illustrati in questa sezione. Se hai scelto **Use defaults** (Utilizza valori predefiniti) per l'opzione **Additional configurations** (Configurazioni aggiuntive), salta questa sezione e vai direttamente alla sezione [Passaggio 2: aprire Notebook explorer e cambio del gruppo di lavoro](#notebooks-spark-getting-started-switching-workgroups-and-opening-notebook-explorer).
La procedura seguente presuppone che siano stati completati i passaggi da 1 a 9 della procedura **Creazione di un gruppo di lavoro abilitato a Spark in Athena** della sezione precedente.
**Definizione di configurazioni personalizzate per il gruppo di lavoro**
1. Se desideri creare o utilizzare un ruolo IAM personalizzato o configurare la crittografia dei notebook, espandi **IAM role configuration** (Configurazione del ruolo IAM).
+ Per **Service Role to authorize Athena** scegliere una delle seguenti opzioni:
+ **Create and use a new service role**: scegliere questa opzione affinché Athena crei un ruolo di servizio per tuo conto. Per visualizzare le autorizzazioni concesse dal ruolo, scegli **View permission details** (Visualizza i dettagli delle autorizzazioni).
+ **Choose an existing service role**: dall’elenco a discesa, scegliere un ruolo esistente. Il ruolo scelto deve includere le autorizzazioni nella prima opzione. Per ulteriori informazioni sulle autorizzazioni per i gruppi di lavoro abilitati per i notebook, consulta la pagina [Risolvere problemi relativi ai gruppi di lavoro abilitati per Spark](notebooks-spark-troubleshooting-workgroups.md).
+ In **Notebook and calculation code encryption key management** (Gestione delle chiavi di crittografia del codice di calcolo), scegli una delle opzioni seguenti:
+ **Crittografa utilizzando una chiave AWS proprietaria (impostazione predefinita)**: la AWS KMS chiave è di proprietà e gestita da. AWS Non ti viene addebitato alcun costo aggiuntivo per l'utilizzo di questa chiave.
+ **Encrypt using your own AWS KMS key**: per questa opzione, eseguire una delle seguenti operazioni:
+ Per utilizzare una chiave esistente, usa la casella di ricerca per scegliere AWS KMS o immettere una chiave ARN.
+ Per creare una chiave nella AWS KMS console, scegli **Crea una AWS KMS chiave**. Il ruolo di esecuzione deve disporre dell'autorizzazione a utilizzare la chiave che crei. Dopo aver completato la creazione della chiave nella console KMS, torna alla pagina **Crea gruppo di lavoro** nella console Athena, quindi utilizza la casella di ricerca **Scegli una AWS KMS chiave o inserisci un ARN** per scegliere la chiave appena creata.
**Importante**
Quando modifichi la [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) per un gruppo di lavoro, i notebook gestiti prima dell'aggiornamento continuano a fare riferimento alla vecchia chiave KMS. I notebook gestiti dopo l'aggiornamento utilizzano la nuova chiave KMS. Per aggiornare i vecchi notebook in modo che facciano riferimento alla nuova chiave KMS, esporta e quindi importa ciascuno dei vecchi notebook. Se elimini la vecchia chiave KMS prima di aggiornare i riferimenti dei vecchi notebook alla nuova chiave KMS, i vecchi notebook non saranno più decifrabili e non potranno essere recuperati.
Questo comportamento si applica anche agli aggiornamenti degli [alias](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html), che sono nomi semplici per le chiavi KMS. Quando si aggiorna un alias di chiave KMS in modo che punti a una nuova chiave KMS, i notebook gestiti prima dell'aggiornamento dell'alias fanno ancora riferimento alla vecchia chiave KMS, mentre i notebook gestiti dopo l'aggiornamento dell'alias utilizzano la nuova chiave KMS. Tieni a mente questi aspetti prima di aggiornare le chiavi o gli alias KMS.
1. (Facoltativo) **Altre impostazioni**: espandi questa opzione per abilitare o disabilitare l'opzione **Pubblica CloudWatch metriche per il gruppo** di lavoro. Questo campo è selezionato per impostazione predefinita. Per ulteriori informazioni, consulta [Monitora Apache Spark con metriche CloudWatch](notebooks-spark-metrics.md).
1. (Facoltativo) **Tags** (Tag): utilizza questa opzione per aggiungere tag al gruppo di lavoro. Per ulteriori informazioni, consulta [Assegnare tag alle risorse di Athena](tags.md).
1. Selezionare **Create workgroup (Crea gruppo di lavoro)**. Un messaggio informa che il gruppo di lavoro è stato creato correttamente e il gruppo di lavoro viene visualizzato nell'elenco dei gruppi di lavoro.
## Passaggio 2: aprire Notebook explorer e cambio del gruppo di lavoro
Prima di poter utilizzare il gruppo di lavoro abilitato a Spark che hai appena creato, devi passare a tale gruppo di lavoro. Per passare da un gruppo di lavoro abilitato a Spark a un altro, puoi utilizzare l'opzione **Workgroup** (Gruppo di lavoro) in Notebook explorer o Notebook editor (Editor notebook).
**Nota**
Prima di iniziare, verifica che il tuo browser non blocchi i cookie di terzi. Qualsiasi browser che blocca i cookie di terze parti per impostazione predefinita o abilitata dall'utente impedirà l'avvio di notebook. Per ulteriori informazioni sulla gestione dei cookie, consulta:
[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)
**Apertura di Notebook explorer e cambio del gruppo di lavoro**
1. Nel pannello di navigazione, scegli **Notebook explorer**.
1. Usa l'opzione **Workgroup** (Gruppo di lavoro) nell'angolo in alto a destra della console per scegliere il gruppo di lavoro abilitato a Spark che hai creato. Il notebook di esempio è mostrato nell'elenco dei notebook.
Puoi utilizzare Notebook explorer nei modi seguenti:
+ Scegli il nome con collegamento di un notebook per aprirlo in una nuova sessione.
+ Per rinominare, eliminare o esportare il tuo notebook, utilizza il menu **Actions** (Operazioni).
+ Per importare un file del notebook, scegli **Import file** (Importa file).
+ Per creare un notebook, scegli **Create notebook** (Crea notebook).
## Passaggio 3: eseguire il notebook di esempio
Il notebook di esempio richiama i dati da un set di dati di viaggi in taxi a New York City disponibile al pubblico. Il taccuino contiene esempi che mostrano come lavorare con Spark DataFrames, Spark SQL e. AWS Glue Data Catalog
**Esecuzione del notebook di esempio**
1. In Notebook explorer, scegli il nome collegato del notebook di esempio.
Questo avvia una sessione del notebook con i parametri predefiniti e apre il notebook nell'editor notebook. Un messaggio informa che è stata avviata una nuova sessione di Apache Spark utilizzando i parametri predefiniti (massimo 20). DPUs
1. Per eseguire le celle in ordine e visualizzare i risultati, premi il pulsante **Run** (Esegui) una volta per ogni cella del notebook.
+ Scorri verso il basso per vedere i risultati e visualizzare nuove celle.
+ Per le celle che contengono un calcolo, una barra di avanzamento mostra la percentuale di completamento, il tempo trascorso e il tempo rimanente.
+ Il notebook di esempio crea un database e una tabella nell'account. La cella finale li rimuove come fase di pulizia.
**Nota**
Se modifichi i nomi di cartelle, tabelle o database nel notebook di esempio, assicurati che tali modifiche si riflettano nei ruoli IAM che utilizzi. In caso contrario, il notebook potrebbe non funzionare a causa di autorizzazioni insufficienti.
## Passaggio 4: modificare i dettagli della sessione
Dopo aver avviato una sessione di notebook, è possibile modificare i dettagli della sessione come il formato della tabella, la crittografia, il timeout di inattività della sessione e il numero massimo simultaneo di unità di elaborazione dati (DPUs) che si desidera utilizzare. Una DPU è una misura relativa della potenza di elaborazione costituita da 4 V di capacità CPUs di elaborazione e 16 GB di memoria.
**Modifica dei dettagli della sessione**
1. Nell'editor notebook, nel menu **Session** (Sessione) in alto a destra, scegli **Edit session** (Modifica sessione).
1. Nella finestra di dialogo **Modifica dettagli sessione**, nella sezione **Proprietà Spark**, scegli o inserisci i valori per le seguenti opzioni:
+ **Formato di tabella aggiuntivo**: seleziona **Linux Foundation Delta Lake**, **Apache Hudi**, **Apache Iceberg** oppure **Personalizzato**.
+ Per le opzioni di tabella **Delta**, **Hudi** o **Iceberg**, le proprietà di tabella richieste per il formato di tabella corrispondente vengono fornite automaticamente nelle opzioni **Edit in table** e **Edit in JSON**. Per ulteriori informazioni sull'utilizzo di queste tabelle, consulta [Utilizzare formati di tabella non Hive in Athena per Spark](notebooks-spark-table-formats.md).
+ Per aggiungere o rimuovere proprietà di tabella per i tipi di tabella **Personalizzata** o di altro tipo, utilizzate le opzioni **Modifica nella tabella** e **Modifica in JSON**.
+ Per l'opzione **Modifica nella tabella**, seleziona **Aggiungi proprietà** per aggiungere una proprietà o **Rimuovi** per rimuovere una proprietà. Per immettere i nomi delle proprietà e i relativi valori, utilizzate le caselle **Chiave** e **Valore**.
+ Per l'opzione **Modifica in JSON**, utilizzate l'editor di testo JSON per modificare direttamente la configurazione.
+ Per copiare il testo JSON negli appunti, seleziona **Copia**.
+ Per rimuovere tutto il testo dall'editor JSON, scegli **Cancella**.
+ Per configurare la disposizione delle linee o scegliere un tema di colore per l'editor JSON, scegli l'icona delle impostazioni (a forma di ingranaggio).
+ **Attiva la crittografia Spark -**: seleziona questa opzione per crittografare i dati scritti su disco e inviati tramite i nodi di rete Spark. Per ulteriori informazioni, consulta [Abilitare la crittografia Apache Spark](notebooks-spark-encryption.md).
1. Nella sezione **Parametri sessione** scegli o inserisci i valori per le seguenti opzioni:
+ **Session idle timeout** (Timeout di inattività della sessione): scegli o inserisci un valore compreso tra 1 e 480 minuti. Il valore di default è 20.
+ **Coordinator size** (Dimensione del coordinatore): un *coordinatore* è un esecutore speciale che orchestra il lavoro di elaborazione e gestisce altri esecutori in una sessione di notebook. Attualmente, 1 DPU è il valore predefinito nonché l'unico possibile.
+ **Executor size** (Dimensioni dell'esecutore): un *esecutore* è l'unità di calcolo più piccola che una sessione di notebook può richiedere ad Athena. Attualmente, 1 DPU è il valore predefinito nonché l'unico possibile.
+ **Valore simultaneo massimo**: il numero massimo di elementi DPUs che possono essere eseguiti contemporaneamente. Il valore predefinito 20, il valore minimo è 3 e il valore massimo è 60. L'aumento di questo valore non alloca automaticamente risorse aggiuntive, ma Athena tenterà di allocare fino al massimo specificato quando il carico di elaborazione lo richiede e quando le risorse sono disponibili.
1. Scegli **Save** (Salva).
1. Alla richiesta **Confirm edit** (Conferma modifica), scegli **Confirm** (Conferma).
Athena salva il notebook e avvia una nuova sessione con i parametri specificati. Un banner nell'editor notebook informa che è iniziata una nuova sessione con i parametri modificati.
**Nota**
Athena ricorda le impostazioni della sessione per il notebook. Se modifichi i parametri di una sessione e poi la termini, Athena utilizza i parametri di sessione che hai configurato la volta successiva che avvii una sessione del notebook.
## Passaggio 5: visualizzare i dettagli della sessione e del calcolo
Dopo avere eseguito il notebook, è possibile visualizzare i dettagli della sessione e del calcolo.
**Visualizzazione dei dettagli della sessione e del calcolo**
1. Dal menu **Session** (Sessione) in alto a destra, scegli **View details (Visualizza dettagli**).
+ La scheda **Current session** (Sessione corrente) mostra informazioni sulla sessione corrente, tra cui l'ID della sessione, l'ora di creazione, lo stato e il gruppo di lavoro.
+ La scheda **Cronologia** elenca la sessione delle sessioni IDs precedenti. Per visualizzare i dettagli di una sessione precedente, scegli la scheda **History** (Cronologia), quindi scegli un ID di sessione nell'elenco.
+ La sezione **Calculations** (Calcoli) mostra un elenco dei calcoli eseguiti durante la sessione.
1. Per visualizzare i dettagli di un calcolo, scegli l'ID del calcolo.
1. Nella pagina **Calculation details** (Dettagli del calcolo), è possibile eseguire le seguenti operazioni:
+ Per visualizzare il codice per il calcolo, consulta la sezione **Code** (Codice).
+ Per visualizzare i risultati del calcolo, scegli la scheda **Results** (Risultati).
+ Per scaricare i risultati visualizzati in formato di testo, scegli **Download results** (Scarica risultati).
+ Per visualizzare informazioni sui risultati del calcolo in Amazon S3, scegli **View in S3** (Visualizza in S3).
## Passaggio 6: terminare la sessione
**Per terminare una sessione del notebook**
1. Nell'editor notebook, nel menu **Session** (Sessione) in alto a destra, scegli **Terminate** (Termina).
1. Alla richiesta **Confirm session termination** (Conferma chiusura della sessione), scegli **Confirm** (Conferma). Il notebook viene salvato e si torna all'editor notebook.
**Nota**
La chiusura di una scheda del notebook nell'editor notebook non interrompe la sessione di un notebook attivo. Se vuoi assicurarti che la sessione venga terminata, utilizza l'opzione **Session** (Sessione), **Terminate** (Termina).
## Passaggio 7: creare il proprio notebook
Dopo avere creato un gruppo di lavoro Athena, puoi creare il tuo notebook.
**Creazione di un notebook**
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
1. Nel pannello di navigazione della console Athena, scegli **Notebook explorer** o **Notebook editor** (Editor notebook).
1. Esegui una delle seguenti operazioni:
+ In **Notebook explorer**, scegli **Create notebook** (Crea notebook).
+ In **Notebook editor** (Editor notebook), scegli **Create notebook** (Crea notebook) oppure seleziona l'icona con il segno più (**\$1**) per aggiungere un notebook.
1. Nella finestra di dialogo **Create notebook** (Crea notebook), per **Notebook name** (Nome del notebook) inserisci un nome.
1. (Facoltativo) Espandi **Proprietà Spark**, quindi scegli o inserisci i valori per le seguenti opzioni:
+ **Formato di tabella aggiuntivo**: seleziona **Linux Foundation Delta Lake**, **Apache Hudi**, **Apache Iceberg**, oppure **Personalizzato**.
+ Per le opzioni di tabella **Delta**, **Hudi** o **Iceberg**, le proprietà di tabella richieste per il formato di tabella corrispondente vengono fornite automaticamente nelle opzioni **Edit in table** e **Edit in JSON**. Per ulteriori informazioni sull'utilizzo di queste tabelle, consulta [Utilizzare formati di tabella non Hive in Athena per Spark](notebooks-spark-table-formats.md).
+ Per aggiungere o rimuovere proprietà di tabella per i tipi di tabella **Personalizzata** o di altro tipo, utilizzate le opzioni **Modifica nella tabella** e **Modifica in JSON**.
+ Per l'opzione **Modifica nella tabella**, seleziona **Aggiungi proprietà** per aggiungere una proprietà o **Rimuovi** per rimuovere una proprietà. Per immettere i nomi delle proprietà e i relativi valori, utilizzate le caselle **Chiave** e **Valore**.
+ Per l'opzione **Modifica in JSON**, utilizzate l'editor di testo JSON per modificare direttamente la configurazione.
+ Per copiare il testo JSON negli appunti, seleziona **Copia**.
+ Per rimuovere tutto il testo dall'editor JSON, scegli **Cancella**.
+ Per configurare la disposizione delle linee o scegliere un tema di colore per l'editor JSON, scegli l'icona delle impostazioni (a forma di ingranaggio).
+ **Attiva la crittografia Spark -**: seleziona questa opzione per crittografare i dati scritti su disco e inviati tramite i nodi di rete Spark. Per ulteriori informazioni, consulta [Abilitare la crittografia Apache Spark](notebooks-spark-encryption.md).
1. (Facoltativo) Espandi **Session parameters** (Parametri della sessione), quindi scegli o inserisci i valori per le seguenti opzioni:
+ **Session idle timeout** (Timeout di inattività della sessione): scegli o inserisci un valore compreso tra 1 e 480 minuti. Il valore di default è 20.
+ **Coordinator size** (Dimensione del coordinatore): un *coordinatore* è un esecutore speciale che orchestra il lavoro di elaborazione e gestisce altri esecutori in una sessione di notebook. Attualmente, 1 DPU è il valore predefinito nonché l'unico possibile. Una DPU (unità di elaborazione dati) è una misura relativa della potenza di elaborazione costituita da 4 V CPUs di capacità di elaborazione e 16 GB di memoria.
+ **Executor size** (Dimensioni dell'esecutore): un *esecutore* è l'unità di calcolo più piccola che una sessione di notebook può richiedere ad Athena. Attualmente, 1 DPU è il valore predefinito nonché l'unico possibile.
+ **Valore simultaneo massimo**: il numero massimo di elementi DPUs che possono essere eseguiti contemporaneamente. Il valore predefinito è 20 e il valore massimo è 60. L'aumento di questo valore non alloca automaticamente risorse aggiuntive, ma Athena tenterà di allocare fino al massimo specificato quando il carico di elaborazione lo richiede e quando le risorse sono disponibili.
1. Scegli **Create** (Crea). Il notebook si apre in una nuova sessione nell'editor di notebook.
Per informazioni sulla gestione dei file di notebook, consulta la pagina [Gestire i file del notebook](notebooks-spark-managing.md).
# Gestire i file del notebook
**Nota**
L'editor di notebook Athena è supportato nella versione 3 del motore Pyspark. [Per usare notebook con Apache Spark versione 3.5, vedi Notebooks. SageMaker ](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html)
Oltre che per [creare](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) notebook, puoi utilizzare Notebook explorer anche per aprire, rinominare, eliminare, esportare o importare notebook o visualizzare la cronologia delle sessioni di un notebook.
**Per aprire un taccuino creato in precedenza**
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
1. Nel pannello di navigazione della console Athena, scegli **Notebook editor** (Editor notebook) o **Notebook explorer**.
1. Esegui una delle seguenti operazioni:
+ In **Notebook editor** (Editor notebook), scegli un notebook nell'elenco **Recent notebooks** (Notebook recenti) o **Saved notebooks** (Notebook salvati). Il notebook si apre in una nuova sessione.
+ In **Notebook explorer**, scegli il nome di un notebook dall'elenco. Il notebook si apre in una nuova sessione.
**Ridenominazione di un notebook**
1. [Termina](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) tutte le sessioni attive per il notebook che desideri rinominare. Le sessioni attive del notebook devono essere terminate prima di poter rinominare il notebook.
1. Apri **Notebook explorer**.
1. Nell'elenco **Notebooks** (Notebook), seleziona il pulsante di opzione per il notebook che desideri rinominare.
1. Nel menu **Actions** (Operazioni), scegli **Rename** (Rinomina).
1. Alla richiesta **Rename notebook** (Rinomina notebook), inserisci il nuovo nome, quindi scegli **Save** (Salva). Il nuovo nome del notebook viene visualizzato nell'elenco dei notebook.
**Eliminazione di un notebook**
1. [Termina](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) tutte le sessioni attive per il notebook che desideri eliminare. Le sessioni attive del notebook devono essere terminate prima di poter eliminare il notebook.
1. Apri **Notebook explorer**.
1. Nell'elenco **Notebooks** (Notebook), seleziona il pulsante di opzione per il notebook che desideri eliminare.
1. Nel menu **Actions (Operazioni)** selezionare **Delete (Elimina)**.
1. Alla richiesta **Delete notebook?** (Eliminare notebook?), inserisci il nome del notebook, quindi scegli il pulsante **Delete** (Elimina) per confermare l'eliminazione. Il nome del notebook viene rimosso dall'elenco dei notebook.
**Esportazione di un notebook**
1. Apri **Notebook explorer**.
1. Nell'elenco **Notebooks** (Notebook), seleziona il pulsante di opzione per il notebook che desideri esportare.
1. Nel menu **Actions** (Operazioni), scegli **Export file** (Esporta file).
**Importazione di un notebook**
1. Apri **Notebook explorer**.
1. Scegli **Import file** (Importa file).
1. Individua la posizione sul computer locale del file che desideri importare, quindi scegli **Open** (Apri). Il notebook importato viene visualizzato nell'elenco dei notebook.
**Visualizzazione della cronologia delle sessioni di un notebook**
1. Apri **Notebook explorer**.
1. Nell'elenco **Notebooks** (Notebook), seleziona il pulsante di opzione per il notebook del quale desideri visualizzare la cronologia di sessione.
1. Nel menu **Actions** (Operazioni), scegli **Session history** (Cronologia della sessione).
1. Nella scheda **History** (Cronologia), scegli un **Session ID** (ID di sessione) per visualizzare le informazioni sulla sessione e i relativi calcoli.
# Utilizzare l’editor per notebook Athena
**Nota**
L'editor di notebook Athena è supportato nella versione 3 del motore Pyspark. [Per usare notebook con Apache Spark versione 3.5, vedi Notebooks. SageMaker ](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html)
Puoi gestire i notebook in Notebook explorer di Athena e modificarli ed eseguirli in sessioni utilizzando l'editor notebook di Athena. Puoi configurare l'utilizzo della DPU per le sessioni dei notebook in base alle tue esigenze.
Quando arresti un notebook, termini anche la sessione associata. Tutti i file vengono salvati, ma le modifiche in corso nelle variabili, nelle funzioni e nelle classi dichiarate vanno perse. Quando riavvii il notebook, Athena ricarica i file del notebook e puoi eseguire nuovamente il codice.
L'editor notebook Athena è un ambiente interattivo per la scrittura e l'esecuzione di codice. Le seguenti sezioni descrivono le funzionalità dell'ambiente.
## Comprendere le sessioni e i calcoli del notebook
Ogni notebook è associato a un singolo kernel Python ed esegue codice Python. Un notebook può avere una o più celle che contengono comandi. Per eseguire le celle in un notebook, innanzitutto è necessario creare una sessione del notebook. Le sessioni tengono traccia delle variabili e dello stato dei notebook.
Eseguire una cella in un notebook significa eseguire un calcolo nella sessione corrente. I calcoli fanno progredire lo stato del notebook e possono eseguire attività come la lettura da Amazon S3 o la scrittura su altri archivi dati. Finché una sessione è in esecuzione, i calcoli utilizzano e modificano lo stato mantenuto per il notebook.
Quando lo stato non ti è più utile, puoi terminare una sessione. Quando termini una sessione, il notebook persiste, ma le variabili e le altre informazioni sullo stato vengono eliminate. Se devi lavorare su più progetti contemporaneamente, puoi creare una sessione per ogni progetto: le sessioni sono indipendenti l'una dall'altra.
Le sessioni hanno una capacità di elaborazione dedicata, misurata in DPU. Quando si crea una sessione, è possibile assegnare alla sessione un numero di. DPUs Sessioni diverse possono avere capacità diverse a seconda dei requisiti dell'attività.
## Passare dalla modalità di comando alla modalità di modifica
L'editor notebook ha un'interfaccia utente modale: una modalità di modifica per inserire il testo in una cella e una modalità di comando per impartire all'editor stesso comandi come copia, incolla o esegui.
Per utilizzare la modalità di modifica e la modalità di comando, è possibile eseguire le seguenti operazioni:
+ Per accedere alla modalità di modifica, premi **ENTER** o scegli una cella. Quando è in modalità di modifica, la cella ha il margine sinistro verde.
+ Per accedere alla modalità di comando, premi **ESC** o fai clic all'esterno di una cella. Tieni presente che i comandi in genere si applicano solo alla cella attualmente selezionata, non a tutte le celle. Quando l'editor è in modalità di comando, la cella ha il margine sinistro blu.
+ In modalità comando, puoi utilizzare le scorciatoie da tastiera e il menu sopra l'editor, ma non puoi inserire il testo nelle singole celle.
+ Per selezionare una cella, scegli la cella.
+ Per selezionare tutte le celle, premi **Ctrl\$1A** (Windows) o **Cmd\$1A** (Mac).
## Utilizzare le azioni nel menu dell’editor del notebook
Le icone nel menu nella parte superiore dell'editor notebook offrono le seguenti opzioni:
+ **Save** (Salva): salva lo stato corrente del notebook.
+ **Insert cell below** (Inserisci cella sotto): aggiunge una nuova cella (vuota) sotto quella attualmente selezionata.
+ **Cut selected cells** (Taglia celle selezionate): rimuove la cella selezionata dalla posizione corrente e la copia in memoria.
+ **Copy selected cells** (Copia celle selezionate): copia la cella selezionata in memoria.
+ **Paste cells below** (Incolla celle sotto): incolla la cella copiata sotto la cella corrente.
+ **Move selected cells up** (Sposta le celle selezionate in alto): sposta la cella corrente sopra la cella soprastante.
+ **Move selected cells down** (Sposta le celle selezionate in basso): sposta la cella corrente sotto la cella sottostante.
+ **Run** (Esegui): esegue la cella corrente (selezionata). L'output viene visualizzato immediatamente sotto la cella corrente.
+ **Run all** (Esegui tutto): esegue tutte le celle del notebook. L'output per ogni cella viene visualizzato immediatamente sotto la cella.
+ **Stop (Interrupt the kernel)** (Arresta [interrompi il kernel]): arresta il notebook corrente interrompendo il kernel.
+ **Format option** (Opzione di formato): seleziona il formato della cella, che può essere uno dei seguenti:
+ **Code** (Codice): utilizzato per il codice Python (impostazione predefinita).
+ **Markdown**: da utilizzare per inserire testo in formato markdown in [GitHubstile](https://docs.github.com/en/get-started/writing-on-github). Per renderizzare il markdown, esegui la cella.
+ **Raw NBConvert**: da utilizzare per inserire testo in forma non modificata. Le celle contrassegnate come **Raw NBConvert** possono essere convertite in un formato diverso come HTML dallo strumento da riga di comando Jupyter [nbconvert](https://nbconvert.readthedocs.io/en/latest/usage.html).
+ **Heading** (Intestazione): utilizzato per modificare il livello dell'intestazione della cella.
+ **Command palette** (Palette dei comandi): contiene i comandi del notebook Jupyter e le relative scorciatoie da tastiera. Per ulteriori informazioni sulle scorciatoie da tastiera, consulta le sezioni più avanti in questo documento.
+ **Session** (Sessione): utilizza le opzioni di questo menu per [visualizzare](notebooks-spark-getting-started.md#notebooks-spark-getting-started-viewing-session-and-calculation-details) i dettagli di una sessione, [modificare i parametri della sessione](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) o [terminare](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) la sessione.
## Utilizzare le scorciatoie da tastiera nella modalità di comando per aumentare la produttività
Di seguito sono elencate alcune tra le scorciatoie da tastiera più utilizzate nella modalità di comando dell'editor notebook. Queste scorciatoie sono disponibili dopo avere premuto **ESC** per accedere alla modalità di comando. Per visualizzare l'elenco completo dei comandi disponibili nell'editor, premi **ESC \$1 H**.
****
| Chiave | Azione |
| --- | --- |
| 1 - 6 | Cambia il tipo di cella in markdown e imposta il livello dell'intestazione sul numero digitato |
| a | Crea una cella sopra la cella corrente |
| b | Crea una cella sotto la cella corrente |
| c | Copia la cella corrente in memoria |
| d d | Elimina la cella corrente |
| h | Visualizza la schermata di aiuto delle scorciatoie da tastiera |
| j | Scendi di una cella |
| k | Sali di una cella |
| m | Cambia il formato della cella corrente in markdown |
| r | Cambia il formato della cella corrente in raw (non elaborato) |
| s | Salva il notebook |
| v | Incolla il contenuto della memoria sotto la cella corrente |
| x | Taglia la cella o le celle selezionate |
| y | Cambia il formato della cella in codice |
| z | Annulla operazione |
| Ctrl\$1Enter | Esegui la cella corrente e accedi alla modalità di comando |
| Shift\$1Enter o Alt\$1Enter | Esegui la cella corrente e crea una nuova cella sotto l'output e inserisci la nuova cella in modalità di modifica |
| Space | Pagina giù |
| Shift\$1Space | Pagina su |
| Shift \$1 L | Attiva la visibilità dei numeri di riga nelle celle |
## Personalizzazione delle scorciatoie nella modalità di comando
L'editor notebook offre la possibilità di personalizzare le scorciatoie da tastiera in modalità di comando.
**Modifica delle scorciatoie in modalità di comando**
1. Dal menu dell'editor notebook, scegli **Command palette** (Palette comandi).
1. Dalla palette dei comandi, scegli la voce **Edit command mode keyboard shortcuts** (Modifica scorciatoie da tastiera in modalità di comando).
1. Utilizza l'interfaccia **Edit command mode shortcuts** (Modifica scorciatoie in modalità di comando) per mappare o rimappare i comandi che desideri sulla tastiera.
Per visualizzare le istruzioni per modificare le scorciatoie in modalità di comando, scorri fino alla fine della schermata **Edit command mode shortcuts** (Modifica scorciatoie in modalità di comando).
Per informazioni sull'uso dei comandi magic in Athena per Apache Spark, consulta [Utilizzare i comandi magic](notebooks-spark-magics.md).
**Topics**
+ [Comprendere le sessioni e i calcoli del notebook](#notebooks-spark-sessions-and-calculations)
+ [Passare dalla modalità di comando alla modalità di modifica](#notebooks-spark-command-mode-vs-edit-mode)
+ [Utilizzare le azioni nel menu dell’editor del notebook](#notebooks-spark-notebook-editor-menu)
+ [Utilizzare le scorciatoie da tastiera nella modalità di comando per aumentare la produttività](#notebooks-spark-command-mode-keyboard-shortcuts)
+ [Personalizzazione delle scorciatoie nella modalità di comando](#notebooks-spark-editing-command-mode-shortcuts)
+ [Utilizzare i comandi magic](notebooks-spark-magics.md)
# Utilizzare i comandi magic
I comandi magici, o magie, sono comandi speciali che è possibile eseguire in una cella del notebook. Ad esempio, `%env` mostra le variabili di ambiente in una sessione del notebook. Athena supporta le funzioni magiche della versione 6.0.3. IPython
Questa sezione mostra alcuni comandi magic chiave in Athena per Apache Spark.
+ Per visualizzare un elenco dei comandi magici in Athena, esegui il comando **%lsmagic** in una cella del notebook.
+ Per informazioni sull'uso di magic per creare grafici nei notebook Athena, consulta [Utilizzare magie per creare grafici di dati](notebooks-spark-magics-graphs.md).
+ Per informazioni sui comandi magici aggiuntivi, consulta [Comandi magici incorporati](https://ipython.readthedocs.io/en/stable/interactive/magics.html) nella IPython documentazione.
**Nota**
Attualmente, il comando `%pip` fallisce quando viene eseguito. Si tratta di un problema noto.
**Topics**
+ [Magic nelle celle](notebooks-spark-magics-cell-magics.md)
+ [Magic di riga](notebooks-spark-magics-line-magics.md)
+ [Magie grafiche](notebooks-spark-magics-graphs.md)
# Utilizzare magic nelle celle
Le magie scritte su più righe sono precedute da un doppio segno percentuale (`%%`) e sono chiamate funzioni magiche di cella o magie di cella.
## %%sql
Questo magic nelle celle consente di eseguire istruzioni SQL direttamente senza doverle decorare con l'istruzione SQL Spark. Il comando visualizza anche l'output richiamando implicitamente `.show()` nel dataframe restituito.
![\[Utilizzo dell'%%sql.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-1.png)
Il comando `%%sql` tronca automaticamente gli output delle colonne fino a una larghezza di 20 caratteri. Attualmente questa impostazione non è configurabile. Per ovviare a questa limitazione, utilizza la seguente sintassi completa e modifica di conseguenza i parametri del metodo `show`.
```
spark.sql("""YOUR_SQL""").show(n=number, truncate=number, vertical=bool)
```
+ **n** `int`, facoltativo. Il numero di righe da mostrare.
+ **truncate**: `bool` o `int`, facoltativo: se `true`, tronca le stringhe più lunghe di 20 caratteri. Se impostato su un numero maggiore di 1, tronca le stringhe lunghe fino alla lunghezza specificata e allinea a destra le celle.
+ **verticale** `bool`, facoltativo. Se `true`, stampa le righe di output in verticale (valore di una riga per colonna).
# Utilizzare magic di riga
Le magie che si trovano su una singola riga sono precedute da un segno percentuale (`%`) e sono chiamate funzioni magiche di riga o magie di riga.
## %help
Visualizza le descrizioni dei comandi magic disponibili.
![\[Utilizzo dell'%help.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-2.png)
## %list\$1sessions
Elenca le sessioni associate al notebook. Le informazioni per ogni sessione includono l'ID della sessione, lo stato della sessione e la data e l'ora di inizio e fine della sessione.
![\[Utilizzo dell'%list_sessions.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-3.png)
## %session\$1id
Recupera l'ID della sessione corrente.
![\[Utilizzo dell'session_id.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-4.png)
## %set\$1log\$1level
Imposta o reimposta il logger per utilizzare il livello di log specificato. I valori possibili sono `DEBUG`, `ERROR`, `FATAL`, `INFO` e `WARN` o `WARNING`. I valori devono essere maiuscoli e non devono essere racchiusi tra virgolette singole o doppie.
![\[Utilizzo dell'%set_log_level.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-5.png)
## %status
Descrive la sessione corrente. L'output include l'ID della sessione, lo stato della sessione, il nome del gruppo di lavoro, la versione PySpark del motore e l'ora di inizio della sessione. Questo comando magic richiede una sessione attiva per recuperare i dettagli della sessione.
Di seguito sono riportati i valori possibili per lo stato:
**CREATING**: la sessione viene avviata, inclusa l'acquisizione di risorse.
**CREATED**: la sessione è stata avviata.
**IDLE**: la sessione è in grado di accettare un calcolo.
**BUSY**: la sessione sta elaborando un'altra operazione e non è in grado di accettare un calcolo.
**TERMINATING**: la sessione è in fase di arresto.
**TERMINATED**: la sessione e le relative risorse non sono più in esecuzione.
**DEGRADED**: la sessione non ha coordinatori sani.
**FAILED**: a causa di un errore, la sessione e le relative risorse non sono più in esecuzione.
![\[Utilizzo dell'%status.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-6.png)
# Utilizzare magie per creare grafici di dati
I line magics di questa sezione sono specializzati nel rendering di dati per particolari tipi di dati o in combinazione con librerie grafiche.
## %table
È possibile utilizzare il comando magico `%table` per visualizzare i dati del dataframe in formato tabella.
L'esempio seguente crea un dataframe con due colonne e tre righe di dati, quindi visualizza i dati in formato tabella.
![\[Utilizzo del comando magic %table.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-graphs-1.png)
## %matplot
[Matplotlib](https://matplotlib.org/) è una libreria completa per la creazione di visualizzazioni statiche, animate e interattive in Python. È possibile utilizzare il comando magic `%matplot` per creare un grafico dopo aver importato la libreria matplotlib in una cella del notebook.
L'esempio seguente importa la libreria matplotlib, crea un insieme di coordinate x e y, quindi utilizza il comando "use the `%matplot` magic" per creare un grafico dei punti.
```
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
```
![\[Utilizzo del comando magic %matplot.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-graphs-2.png)
### Utilizzare insieme le librerie matplotlib e seaborn
[Seaborn](https://seaborn.pydata.org/tutorial/introduction) è una libreria per creare grafici statistici in Python. Si basa su matplotlib e si integra strettamente con le strutture di dati [panda](https://pandas.pydata.org/)(Python data analysis, "analisi dei dati Python"). Puoi anche usare il comando magic `%matplot` per eseguire il rendering dei dati marittimi.
L'esempio seguente utilizza entrambe le librerie matplotlib e seaborn per creare un semplice grafico a barre.
```
import matplotlib.pyplot as plt
import seaborn as sns
x = ['A', 'B', 'C']
y = [1, 5, 3]
sns.barplot(x, y)
%matplot plt
```
![\[Utilizzo di %matplot per il rendering dei dati seaborn.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-graphs-3.png)
## %plotly
[Plotly](https://plotly.com/python/) è una libreria grafica open source per Python che puoi usare per creare grafici interattivi. Utilizza il comando magic `%ploty` per eseguire il rendering dei dati grafici.
L'esempio seguente utilizza le librerie [StringIO](https://docs.python.org/3.13/library/io.html#io.StringIO), plotly e pandas sui dati dei prezzi delle azioni per creare un grafico dell'attività azionaria tra febbraio e marzo 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
```
![\[Utilizzando il comando magic %ploty.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-magics-graphs-4.png)
# Utilizzare formati di tabella non Hive in Athena per Spark
**Nota**
Questa pagina si riferisce all'utilizzo delle librerie Python nella versione di rilascio Pyspark engine versione 3. Fai riferimento ad [Amazon EMR 7.12](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html) per le versioni supportate in formato tabella aperta.
Quando lavori con sessioni e notebook in Athena for Spark, puoi usare le tabelle Delta Lake, Apache Hudi e Apache Iceberg di Linux Foundation, oltre alle tabelle Apache Hive.
## Considerazioni e limitazioni
Quando si utilizzano formati di tabella diversi da Apache Hive con Athena per Spark, considerare i seguenti punti:
+ Oltre ad Apache Hive, è supportato un solo formato di tabella per notebook. Per utilizzare più formati di tabella in Athena for Spark, crea un notebook separato per ogni formato di tabella. Per informazioni sulla creazione di taccuini in Athena per Spark, consulta [Passaggio 7: creare il proprio notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
+ I formati di tabella Delta Lake, Hudi e Iceberg sono stati testati su Athena for Spark utilizzandoli come metastore. AWS Glue Potresti essere in grado di utilizzare altri metastore, ma tale utilizzo non è attualmente supportato.
+ Per utilizzare i formati di tabella aggiuntivi, sostituisci la proprietà predefinita `spark_catalog`, come indicato nella console Athena e in questa documentazione. Questi cataloghi non Hive possono leggere le tabelle Hive, oltre ai propri formati di tabella.
## Versioni di tabella
La seguente tabella mostra le versioni di tabella non Hive supportate in Amazon Athena per Apache Spark.
****
| Formato della tabella | Versione supportata |
| --- | --- |
| Apache Iceberg | 1.2.1 |
| Apache Hudi | 0,13 |
| Linux Foundation Delta Lake | 2.0.2 |
In Athena for Spark, questi file `.jar` in formato tabella e le relative dipendenze vengono caricati nel classpath per i driver e gli executor Spark.
Per un post *sul AWS blog Big Data* che mostra come lavorare con i formati di tabella Iceberg, Hudi e Delta Lake utilizzando Spark SQL nei notebook Amazon Athena, consulta [Usa Amazon Athena con Spark SQL per i tuoi formati di tabelle transazionali open](https://aws.amazon.com/blogs/big-data/use-amazon-athena-with-spark-sql-for-your-open-source-transactional-table-formats/) source.
**Topics**
+ [Considerazioni e limitazioni](#notebooks-spark-table-formats-considerations-and-limitations)
+ [Versioni di tabella](#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)
# Utilizzare una tabella Apache Iceberg in Athena per Spark
[Apache Iceberg](https://iceberg.apache.org/) è un formato di tabella aperta per set di dati di grandi dimensioni in Amazon Simple Storage Service (Amazon S3). Ti fornisce prestazioni di query rapide su tabelle di grandi dimensioni, commit atomici, scritture simultanee ed evoluzione delle tabelle compatibili con SQL.
Per utilizzare le tabelle Apache Iceberg in Athena for Spark, configura le seguenti proprietà Spark. Queste proprietà sono configurate automaticamente nella console Athena for Spark quando scegli Apache Iceberg come formato di tabella. Per la procedura, consulta [Passaggio 4: modificare i dettagli della sessione](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) o [Passaggio 7: creare il proprio notebook](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 seguente procedura mostra come utilizzare una tabella Apache Iceberg in un notebook Athena per Spark. Esegui ogni passaggio in una nuova cella del notebook.
**Per usare una tabella Apache Iceberg in Athena per Spark**
1. Definisci le costanti da usare nel notebook.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Crea 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. Crea un database.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Crea una tabella Apache Iceberg vuota.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING ICEBERG
""".format(DB_NAME, TABLE_NAME))
```
1. Inserisci una riga di dati nella tabella.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME, TABLE_NAME))
```
1. Conferma di poter eseguire query sulla nuova tabella.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
Per ulteriori informazioni ed esempi su come lavorare con le tabelle Spark DataFrames e Iceberg, consulta [Spark Queries](https://iceberg.apache.org/docs/latest/spark-queries/) nella documentazione di Apache Iceberg.
# Utilizzare una tabella Apache Hudi in Athena per Spark
[https://hudi.apache.org/](https://hudi.apache.org/)Apache Hudi è un framework open source per la gestione dei dati che semplifica l’elaborazione incrementale dei dati. Le azioni di inserimento, aggiornamento, annullamento ed eliminazione a livello di record vengono elaborate con maggiore precisione, il che riduce il sovraccarico.
Per utilizzare le tabelle Apache Hudi in Athena per Spark, configura le seguenti proprietà Spark. Queste proprietà sono configurate automaticamente nella console Athena for Spark quando scegli Apache Hudi come formato di tabella. Per la procedura, consulta [Passaggio 4: modificare i dettagli della sessione](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) o [Passaggio 7: creare il proprio notebook](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 seguente procedura mostra come utilizzare una tabella Apache Hudi in un notebook Athena per Spark. Esegui ogni passaggio in una nuova cella del notebook.
**Per usare una tabella Apache Hudi in Athena per Spark**
1. Definisci le costanti da usare nel notebook.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Crea [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html)un Apache Spark.
```
columns = ["language","users_count"]
data = [("Golang", 3000)]
df = spark.createDataFrame(data, columns)
```
1. Crea un database.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Crea una tabella Apache Hudi vuota.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING HUDI
TBLPROPERTIES (
primaryKey = 'language',
type = 'mor'
);
""".format(DB_NAME, TABLE_NAME))
```
1. Inserisci una riga di dati nella tabella.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME,TABLE_NAME))
```
1. Conferma di poter eseguire query sulla nuova tabella.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
# Utilizzare le tabelle Delta Lake di Linux Foundation in Athena per Spark.
[Linux Foundation Delta Lake](https://delta.io/) è un formato di tabella che puoi utilizzare per la Big data/analisi. Puoi usare Athena per Spark per leggere direttamente le tabelle Delta Lake archiviate in Amazon S3.
Per utilizzare le tabelle Delta Lake in Athena per Spark, configura le seguenti proprietà Spark. Queste proprietà sono configurate automaticamente nella console Athena for Spark quando scegli Delta Lake come formato di tabella. Per la procedura, consulta [Passaggio 4: modificare i dettagli della sessione](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) o [Passaggio 7: creare il proprio notebook](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 seguente procedura mostra come utilizzare una tabella Delta Lake in un notebook Athena per Spark. Esegui ogni passaggio in una nuova cella del notebook.
**Per usare una tabella Delta Lake in Athena per Spark**
1. Definisci le costanti da usare nel notebook.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Crea 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. Crea un database.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Crea una tabella Delta Lake vuota.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING DELTA
""".format(DB_NAME, TABLE_NAME))
```
1. Inserisci una riga di dati nella tabella.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME, TABLE_NAME))
```
1. Conferma di poter eseguire query sulla nuova tabella.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
# Utilizzare le librerie Python in Athena per Spark
**Nota**
Questa pagina si riferisce all'utilizzo delle librerie Python nella versione di rilascio Pyspark engine versione 3. La versione di rilascio di Apache Spark versione 3.5 è basata su Amazon [EMR 7.12.](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html) Fare riferimento a EMR 7.12 per le librerie incluse in questa versione.
Questa pagina descrive la terminologia utilizzata e la gestione del ciclo di vita seguita per i runtime, le librerie e i pacchetti utilizzati in Amazon Athena per Apache Spark.
## Definizioni
+ **Amazon Athena per Apache Spark** è una versione personalizzata di Apache Spark open source. Per visualizzare la versione corrente, esegui il comando `print(f'{spark.version}')` in una cella del notebook.
+ Il **runtime Athena** è l'ambiente in cui viene eseguito il codice. L'ambiente include un interprete Python e librerie. PySpark
+ Una **libreria o un pacchetto esterno** è una libreria JAR o Python di Java o Scala che non fa parte del runtime di Athena ma può essere inclusa nei processi di Athena for Spark. I pacchetti esterni possono essere creati da Amazon o da te.
+ Un **pacchetto di convenienza** è una raccolta di pacchetti esterni selezionati da Athena che puoi scegliere di includere nelle tue applicazioni Spark.
+ Un **bundle** combina il runtime Athena e un pacchetto di convenienza.
+ Una **libreria utente** è una libreria o un pacchetto esterno che aggiungi esplicitamente al tuo processo Athena per Spark.
+ Una libreria utente è un pacchetto esterno che non fa parte di un pacchetto di convenienza. Una libreria utente richiede il caricamento e l'installazione, come quando si scrivono alcuni file `.py`, li si comprime e quindi si aggiunge il file `.zip` all'applicazione.
+ Un'**applicazione Athena per Spark** è un processo o una query che invii ad Athena per Spark.
## Gestione del ciclo di vita
Le sezioni seguenti descrivono i criteri di controllo delle versioni e di deprecazione relative ai pacchetti di runtime e convenienza utilizzati in Athena per Spark.
### Controllo delle versioni e impostazione del runtime come obsoleto
Il componente principale del runtime di Athena è l'interprete Python. Poiché Python è un linguaggio in evoluzione, vengono rilasciate regolarmente nuove versioni e il supporto per le versioni precedenti viene rimosso. Athena sconsiglia di eseguire programmi con versioni di interpreti Python obsolete e consiglia vivamente di utilizzare il runtime Athena più recente, quando possibile.
La pianificazione dell'impostazione del runtime di Athena come obsoleto è la seguente:
1. Dopo che avrà fornito un nuovo runtime, Athena continuerà a supportare il runtime precedente per 6 mesi. Durante questo periodo, Athena applicherà patch di sicurezza e aggiornamenti al runtime precedente.
1. Dopo 6 mesi, Athena terminerà il supporto per il runtime precedente. Athena non applicherà più patch di sicurezza e altri aggiornamenti al runtime precedente. Le applicazioni Spark che utilizzano il runtime precedente non saranno più idonee al supporto tecnico.
1. Dopo 12 mesi, non sarà più possibile aggiornare o modificare le applicazioni Spark in un gruppo di lavoro che utilizza il runtime precedente. Ti consigliamo di aggiornare le applicazioni Spark prima del termine di questo periodo. Al termine del periodo, sarà ancora possibile eseguire i notebook esistenti, ma tutti i notebook che utilizzano ancora il runtime precedente registreranno un avviso in tal senso.
1. Dopo 18 mesi, non sarà più possibile eseguire i processi nel gruppo di lavoro utilizzando il runtime precedente.
### Controllo delle versioni e impostazione dei pacchetti di convenienza come obsoleti
Il contenuto dei pacchetti di convenienza cambia nel tempo. Athena aggiunge, rimuove o aggiorna occasionalmente questi pacchetti di convenienza.
Athena utilizza le seguenti linee guida per i pacchetti di convenienza:
+ I pacchetti di convenienza hanno uno schema di controllo delle versioni semplice, come 1, 2, 3.
+ Ogni versione del pacchetto di convenienza include versioni specifiche di pacchetti esterni. Dopo che Athena ha creato un pacchetto di convenienza, il set di pacchetti esterni del pacchetto di convenienza e le versioni corrispondenti non cambiano.
+ Athena crea una nuova versione del pacchetto di convenienza quando include un nuovo pacchetto esterno, rimuove un pacchetto esterno o aggiorna la versione di uno o più pacchetti esterni.
Athena imposta un pacchetto di convenienza come obsoleto quando imposta come obsoleto il runtime Athena utilizzato dal pacchetto. Athena può impostare i pacchetti come obsoleti prima del tempo per limitare il numero di pacchetti supportati.
La pianificazione dell'impostazione dei pacchetti di convenienza come obsoleti segue la pianificazione di impostazione come obsoleto del runtime di Athena.
# Elenco delle librerie Python preinstallate
Le librerie Python preinstallate includono quanto segue.
```
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
```
## Note
+ MLlib (libreria di machine learning Apache Spark) e il `pyspark.ml` pacchetto non sono supportati.
+ Al momento, `pip install` non è supportato nelle sessioni di Athena for Spark.
Per informazioni sull’importazione di librerie Python in Amazon Athena per Apache Spark, consultare [Importare file e librerie Python in Amazon Athena per Apache Spark](notebooks-import-files-libraries.md).
# Importare file e librerie Python in Amazon Athena per Apache Spark
Questo documento fornisce esempi di come importare file e librerie Python in Amazon Athena per Apache Spark.
## Considerazioni e limitazioni
+ **Versione Python**: attualmente, Athena for Spark utilizza la versione Python 3.9.16. Nota che i pacchetti Python sono sensibili alle versioni minori di Python.
+ **Architettura Athena per Spark:** Athena per Spark utilizza Amazon Linux 2 sull'architettura. ARM64 Nota che alcune librerie Python non distribuiscono file binari per questa architettura.
+ **Oggetti binari condivisi (SOs)** — Poiché il SparkContext [addPyFile](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.addPyFile.html)metodo non rileva oggetti binari condivisi, non può essere usato in Athena per Spark per aggiungere pacchetti Python che dipendono da oggetti condivisi.
+ **Resilient Distributed Dataset (RDDs)**: non sono supportati. [RDDs](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.RDD.html)
+ **DataFrame.foreach — Il metodo .foreach non** [è supportato. PySpark DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.foreach.html)
## Esempi
Gli esempi utilizzano le seguenti convenzioni.
+ Il segnaposto della posizione di Amazon S3 `s3://amzn-s3-demo-bucket`. Sostituisci questo valore con la posizione del tuo bucket S3.
+ Tutti i blocchi di codice eseguiti da una shell Unix sono mostrati come. *directory\$1name* `$` Ad esempio, il comando `ls` nella directory `/tmp` e il relativo output vengono visualizzati come segue:
```
/tmp $ ls
```
**Output**
```
file1 file2
```
## Importare file di testo da utilizzare nei calcoli
Gli esempi di questa sezione mostrano come importare file di testo da utilizzare nei calcoli nei notebook in Athena per Spark.
### Aggiungere un file a un notebook dopo averlo scritto nella directory temporanea locale
L'esempio seguente mostra come scrivere un file in una directory temporanea locale, aggiungerlo a un notebook e testarlo.
```
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()
```
**Output**
```
Calculation completed.
+---+---+-------+
| _1| _2| col|
+---+---+-------+
| 1| a|[aaaaa]|
| 2| b|[bbbbb]|
+---+---+-------+
```
### Importazione di un file da Amazon S3
Il seguente esempio mostra come importare un file da Amazon S3 in un notebook e testarlo.
**Importazione di un file da Amazon S3 in un notebook**
1. Crea un file denominato `test.txt` con una singola riga contenente il valore `5`.
1. Aggiungi il file a un bucket in Amazon S3. Questo esempio utilizza la posizione `s3://amzn-s3-demo-bucket`.
1. Utilizza il codice seguente per importare il file sul tuo notebook e testarlo.
```
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()
```
**Output**
```
Calculation completed.
+---+---+-------+
| _1| _2| col|
+---+---+-------+
| 1| a|[aaaaa]|
| 2| b|[bbbbb]|
+---+---+-------+
```
## Aggiungere file Python
Gli esempi in questa sezione mostrano come aggiungere file e librerie Python ai notebook Spark in Athena.
### Aggiungere file Python e registrare un'UDF
La procedura seguente mostra come aggiungere file Python da Amazon S3 al notebook e come registrare un'UDF.
**Aggiunta di file Python al notebook e registrazione di un'UDF**
1. Utilizzando la tua posizione Amazon S3, crea il file `s3://amzn-s3-demo-bucket/file1.py` con i seguenti contenuti:
```
def xyz(input):
return 'xyz - udf ' + str(input);
```
1. Nella stessa posizione S3, crea il file `s3://amzn-s3-demo-bucket/file2.py` con i seguenti contenuti:
```
from file1 import xyz
def uvw(input):
return 'uvw -> ' + xyz(input);
```
1. Nel tuo notebook Athena per Spark, esegui i seguenti comandi.
```
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)
```
**Output**
```
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... |
+---+---+--------------------+
```
### Importare un file .zip Python
Puoi utilizzare i metodi `addPyFile` e `import` di Python per importare un file .zip Python nel tuo notebook.
**Nota**
I file `.zip` importati in Athena Spark possono includere solo pacchetti Python. Ad esempio, l'inclusione di pacchetti con file basati su C non è supportata.
**Importazione di un file `.zip` Python in un notebook**
1. Sul tuo computer locale, in una directory del desktop come ad esempio `\tmp`, crea una directory chiamata `moduletest`.
1. Nella directory `moduletest`, creare un file denominato `hello.py` con il seguente contenuto:
```
def hi(input):
return 'hi ' + str(input);
```
1. Nella stessa directory, aggiungi un file vuoto denominato `__init__.py`.
Se elenchi i contenuti della directory, ora dovrebbero apparire come segue.
```
/tmp $ ls moduletest
__init__.py hello.py
```
1. Utilizza il comando `zip` per inserire i due file del modulo in un file chiamato `moduletest.zip`.
```
moduletest $ zip -r9 ../moduletest.zip *
```
1. Carica il file `.zip` nel tuo bucket in Amazon S3.
1. Utilizza il codice seguente per importare il file `.zip` Python nel notebook.
```
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()
```
**Output**
```
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|
+---+---+----+
```
### Importare due versioni di una libreria Python come moduli separati
I seguenti esempi di codice mostrano come aggiungere e importare due versioni distinte di una libreria Python da una posizione in Amazon S3 come due moduli separati. Il codice aggiunge ogni file della libreria da S3, lo importa e quindi stampa la versione della libreria per verificare l'importazione.
```
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__)
```
**Output**
```
3.15.0
```
```
import simplejson_v3_17_6
print(simplejson_v3_17_6.__version__)
```
**Output**
```
3.17.6
```
### Importare un file .zip Python da PyPI
Questo esempio utilizza il comando `pip` per scaricare un file .zip in Python del progetto [bpabel/piglatin](https://github.com/bpabel/piglatin) dal [Python Package Index (PyPI)](https://pypi.org/).
**Importazione di un file .zip Python da PyPI**
1. Sul desktop locale, utilizza i seguenti comandi per creare una directory chiamata `testpiglatin` e creare un ambiente virtuale.
```
/tmp $ mkdir testpiglatin
/tmp $ cd testpiglatin
testpiglatin $ virtualenv .
```
**Output**
```
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. Crea una sottodirectory denominata `unpacked` per ospitare il progetto.
```
testpiglatin $ mkdir unpacked
```
1. Utilizza il comando `pip` per installare il progetto nella directory `unpacked`.
```
testpiglatin $ bin/pip install -t $PWD/unpacked piglatin
```
**Output**
```
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. Verifica il contenuto della directory.
```
testpiglatin $ ls
```
**Output**
```
bin lib pyvenv.cfg unpacked
```
1. Passa alla directory `unpacked` e visualizza il contenuto.
```
testpiglatin $ cd unpacked
unpacked $ ls
```
**Output**
```
piglatin piglatin-1.0.6.dist-info
```
1. Utilizza il comando `zip` per inserire il contenuto del progetto piglatin in un file denominato `library.zip`.
```
unpacked $ zip -r9 ../library.zip *
```
**Output**
```
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. (Facoltativo) Utilizza i seguenti comandi per testare l'importazione localmente.
1. Imposta il percorso Python nella posizione del file `library.zip` e avvia Python.
```
/home $ PYTHONPATH=/tmp/testpiglatin/library.zip
/home $ python3
```
**Output**
```
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. Importa la libreria ed esegui un comando di test.
```
>>> import piglatin
>>> piglatin.translate('hello')
```
**Output**
```
'ello-hay'
```
1. Utilizza i comandi seguenti per aggiungere il file `.zip` da Amazon S3, importarlo nel tuo notebook in Athena e testarlo.
```
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()
```
**Output**
```
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|
+---+-----+--------+
```
### Importare un file .zip Python da PyPI con dipendenze
Questo esempio importa da PyPI il pacchetto [md2gemini](https://github.com/makeworld-the-better-one/md2gemini), che converte il testo in formato Markdown nel formato di testo [Gemini](https://gemini.circumlunar.space/). Il pacchetto include le seguenti [dipendenze](https://libraries.io/pypi/md2gemini):
```
cjkwrap
mistune
wcwidth
```
**Importazione da PyPI di un file .zip Python con dipendenze**
1. Sul computer locale, utilizza i seguenti comandi per creare una directory chiamata `testmd2gemini` e creare un ambiente virtuale.
```
/tmp $ mkdir testmd2gemini
/tmp $ cd testmd2gemini
testmd2gemini$ virtualenv .
```
1. Crea una sottodirectory denominata `unpacked` per ospitare il progetto.
```
testmd2gemini $ mkdir unpacked
```
1. Utilizza il comando `pip` per installare il progetto nella directory `unpacked`.
```
/testmd2gemini $ bin/pip install -t $PWD/unpacked md2gemini
```
**Output**
```
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. Passa alla directory `unpacked` e controlla il contenuto.
```
testmd2gemini $ cd unpacked
unpacked $ ls -lah
```
**Output**
```
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. Utilizza il comando `zip` per inserire il contenuto del progetto md2gemini in un file denominato `md2gemini.zip`.
```
unpacked $ zip -r9 ../md2gemini *
```
**Output**
```
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. (Facoltativo) Utilizza i seguenti comandi per verificare che la libreria funzioni sul computer locale.
1. Imposta il percorso Python nella posizione del file `md2gemini.zip` e avvia Python.
```
/home $ PYTHONPATH=/tmp/testmd2gemini/md2gemini.zip
/home python3
```
1. Importa la libreria ed esegui un test.
```
>>> from md2gemini import md2gemini
>>> print(md2gemini('[abc](https://abc.def)'))
```
**Output**
```
https://abc.def abc
```
1. Utilizza i comandi seguenti per aggiungere il file `.zip` da Amazon S3, importarlo nel tuo notebook in Athena ed eseguire 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)'))
```
**Output**
```
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. Utilizza i comandi seguenti per eseguire 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()
```
**Output**
```
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...|
+---+--------------------+--------------------+
```
# Utilizzare le proprietà Spark per specificare una configurazione personalizzata
Quando crei o modifichi una sessione in Amazon Athena per Apache Spark, puoi utilizzare le [proprietà Spark](https://spark.apache.org/docs/latest/configuration.html#spark-properties) per specificare file `.jar`, pacchetti o un'altra configurazione personalizzata per la sessione. Per specificare le proprietà di Spark, puoi utilizzare la console Athena, o AWS CLI l'API Athena.
## Utilizzare la console Athena per specificare le proprietà Spark
Nella console Athena, puoi specificare le proprietà di Spark quando [crei un notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) o [modifichi una sessione corrente](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details).
**Come aggiungere proprietà nella finestra di dialogo **Crea notebook** o **Modifica dettagli della sessione****
1. Espandi le **proprietà Spark**.
1. Per aggiungere le tue proprietà, utilizza l'opzione **Modifica nella tabella** o **Modifica in JSON**.
+ Per l'opzione **Modifica nella tabella**, seleziona **Aggiungi proprietà** per aggiungere una proprietà o seleziona **Rimuovi** per rimuovere una proprietà. Utilizza le caselle **Chiave** e **Valore** per inserire i nomi delle proprietà e i relativi valori.
+ Per aggiungere un file `.jar` personalizzato, utilizza la proprietà `spark.jars`.
+ Per specificare un file pacchetto, utilizza la proprietà `spark.jars.packages`.
+ Per inserire e modificare direttamente la configurazione, seleziona l'opzione **Modifica in JSON**. Nell'editor di testo JSON, puoi eseguire le seguenti attività:
+ Seleziona **Copia** per copiare il testo JSON negli appunti.
+ Seleziona **Cancella** per rimuovere tutto il testo dall'editor JSON.
+ Scegli l'icona delle impostazioni (ingranaggio) per configurare la disposizione delle linee o scegli un tema di colore per l'editor JSON.
### Note
+ Puoi impostare le proprietà in Athena per Spark, il che equivale a impostare le [proprietà Spark](https://spark.apache.org/docs/latest/configuration.html#spark-properties) direttamente su un oggetto. [SparkConf](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkConf.html)
+ Avvia tutte le proprietà Spark con il prefisso `spark.`. Le proprietà con altri prefissi vengono ignorate.
+ Non tutte le proprietà Spark sono disponibili per la configurazione personalizzata su Athena. Se invii una richiesta `StartSession` con una configurazione limitata, la sessione non viene avviata.
+ Non è possibile utilizzare il prefisso `spark.athena.` perché è riservato.
## Usa l'API AWS CLI o Athena per fornire una configurazione personalizzata
Per utilizzare l'API AWS CLI o Athena per fornire la configurazione della sessione, utilizza l'azione [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)API o il comando CLI [start-session](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/start-session.html). Nella tua `StartSession` richiesta, utilizza il `SparkProperties` campo dell'[EngineConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EngineConfiguration.html)oggetto per passare le informazioni di configurazione in formato JSON. Questo avvia una sessione con la configurazione specificata.
Per specificare proprietà Spark personalizzate da AWS CLI, usa la `engine-configuration` configurazione quando avvii una sessione interattiva.
```
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"
}
}]
}'
```
È inoltre possibile specificare i valori predefiniti di configurazione a livello di gruppo di lavoro utilizzando l'azione API o l'azione `CreateWorkgroup` API. `UpdateWorkgroup` I valori di configurazione predefiniti nel gruppo di lavoro si applicano a tutte le sessioni avviate per quel gruppo di lavoro.
Per specificare le proprietà Spark predefinite AWS CLI per un gruppo di lavoro, usa la `engine-configuration` configurazione quando crei un nuovo gruppo di lavoro:
```
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"
}
}
]
}
}'
```
Per modificare le proprietà Spark predefinite di un gruppo di lavoro, usa AWS CLI la configurazione quando aggiorni un gruppo di lavoro. `engine-configuration` Le modifiche si applicano alle nuove sessioni interattive in futuro.
```
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"
}
}
]
}
}'
```
# Formati di dati e archiviazione supportati
La tabella seguente mostra i formati supportati in modo nativo in Athena per Apache Spark..
****
| **Formato dei dati** | **Lettura** | **Scrittura** | **Compressione di scrittura** |
| --- | --- | --- | --- |
| parquet | sì | sì | nessuno, non compresso, snappy, gzip |
| orc | sì | sì | nessuno, snappy, zlib, lzo |
| json | sì | sì | bzip2, gzip, deflate |
| csv | sì | sì | bzip2, gzip, deflate |
| testo | sì | sì | nessuno, bzip2, gzip, deflate |
| file binario | sì | N/D | N/D |
# Monitora Apache Spark con metriche CloudWatch
Athena pubblica metriche relative al calcolo su CloudWatch Amazon quando viene selezionata l'opzione per il tuo gruppo di lavoro abilitato a **[Publish CloudWatch metrics](notebooks-spark-getting-started.md#notebook-gs-metrics)**Spark. Puoi creare dashboard personalizzate, impostare allarmi e trigger sulle metriche nella console. CloudWatch
Athena pubblica la seguente metrica sulla CloudWatch console nel namespace: `AmazonAthenaForApacheSpark`
+ `DPUCount`— numero di dati DPUs consumati durante la sessione per eseguire i calcoli.
Questo parametro possiede le seguenti dimensioni:
+ `SessionId`: l'ID della sessione in cui vengono inviati i calcoli.
+ `WorkGroup`: il nome del gruppo di lavoro.
**Per visualizzare le metriche per i gruppi di lavoro compatibili con Spark nella console Amazon CloudWatch**
1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione, seleziona **Metrics** (Parametri), **All metrics** (Tutti i parametri).
1. Selezionare lo spazio dei nomi **AmazonAthenaForApacheSpark**.
**Per visualizzare i parametri con CLI**
+ Esegui una delle seguenti operazioni:
+ Per elencare i parametri per i gruppi di lavoro Athena abilitati per Spark, apri un prompt dei comandi e utilizza il comando seguente:
```
aws cloudwatch list-metrics --namespace "AmazonAthenaForApacheSpark"
```
+ Per visualizzare un elenco di tutti i parametri disponibili, usare il comando seguente:
```
aws cloudwatch list-metrics
```
## Elenco di CloudWatch metriche e dimensioni per i calcoli di Apache Spark in Athena
Se hai abilitato le CloudWatch metriche nel tuo gruppo di lavoro Athena abilitato per Spark, Athena invia la seguente metrica a ciascun gruppo di lavoro. CloudWatch Il parametro utilizza lo spazio dei nomi `AmazonAthenaForApacheSpark`.
****
| Nome parametro | Description |
| --- | --- |
| DPUCount | Numero di DPUs (unità di elaborazione dati) consumate durante la sessione per eseguire i calcoli. Una DPU è una misura relativa della potenza di elaborazione costituita da 4 V CPUs di capacità di elaborazione e 16 GB di memoria. |
Questo parametro ha le seguenti dimensioni.
| Dimensione | Description |
| --- | --- |
| SessionId | L'ID della sessione in cui vengono inviati i calcoli. |
| WorkGroup | Il nome del gruppo di lavoro. |
## Elenco di CloudWatch metriche e dimensioni per le sessioni interattive di Athena Spark
Nella versione di rilascio Apache Spark versione 3.5, se hai abilitato le CloudWatch metriche nel tuo gruppo di lavoro Athena Spark, Athena invia la seguente metrica a. CloudWatch Il parametro utilizza lo spazio dei nomi `AmazonAthenaForApacheSpark`.
****
| Nome | Description |
| --- | --- |
| DPUConsumed | Il numero di utenti utilizzati DPUs attivamente dalle query in uno stato RUNNING in un determinato momento nel gruppo di lavoro. |
Questo parametro ha le seguenti dimensioni.
| Dimensione | Description |
| --- | --- |
| Account | L'ID dell' AWS account. |
| WorkGroup | Il nome del gruppo di lavoro. |
# Attribuzione dei costi a livello di sessione
A partire dalla versione 3.5 di Apache Spark, Athena consente di tenere traccia dei costi per ogni sessione. È possibile definire i tag di allocazione dei costi all'avvio di una sessione e i costi riportati per una sessione verranno visualizzati in Cost Explorer o nei report di AWS allocazione dei costi di fatturazione. Puoi anche applicare tag di allocazione dei costi a livello di gruppo di lavoro e copiarli in tutte le sessioni avviate in quel gruppo di lavoro.
## Utilizzo dell'attribuzione dei costi a livello di sessione
Per impostazione predefinita, tutti i tag di allocazione dei costi specificati a livello di gruppo di lavoro vengono copiati nelle sessioni interattive avviate in quel gruppo di lavoro.
Per disabilitare la copia dei tag dal gruppo di lavoro quando si avvia una sessione interattiva da: AWS CLI
```
aws athena start-session \
--region "REGION" \
--work-group "WORKGROUP" \
--tags '[
{
"Key": "tag_key",
"Value": "tag_value"
}
]' \
--no-copy-work-group-tags
```
Per consentire la copia dei tag dal gruppo di lavoro quando si avvia una sessione interattiva da: AWS CLI
```
aws athena start-session \
--region "REGION" \
--work-group "WORKGROUP" \
--copy-work-group-tags
```
## Considerazioni e limitazioni
+ I tag di sessione sostituiscono i tag del gruppo di lavoro con le stesse chiavi.
# Registrazione e monitoraggio per le sessioni di Apache Spark
A partire dalla versione 3.5 di Apache Spark, puoi specificare la registrazione gestita, Amazon S3 o la registrazione come opzioni di CloudWatch registrazione.
Per quanto riguarda la registrazione gestita e la registrazione S3, la tabella seguente elenca le posizioni dei log e la disponibilità dell'interfaccia utente che puoi aspettarti se scegli queste opzioni.
****
| Opzione | Registri degli eventi | Registri di container | Interfaccia utente dell'applicazione |
| --- | --- | --- | --- |
| Registrazione gestita (impostazione predefinita) | Memorizzato in un bucket S3 gestito | Memorizzato in un bucket S3 gestito | Supportata |
| Registrazione gestita e bucket S3 | Archiviati in entrambi i posti | Memorizzato in un bucket S3 | Supportata |
| Bucket Amazon S3 | Memorizzato nel bucket S3 | Memorizzato nel bucket S3 | Non supportato 1 |
1 Ti consigliamo di mantenere selezionata l'opzione Registrazione gestita. In caso contrario, non è possibile utilizzare l'applicazione UIs integrata.
## Registrazione gestita
Per impostazione predefinita, i gruppi di lavoro Athena Spark archiviano i log delle applicazioni in modo sicuro in bucket S3 gestiti dal servizio per un massimo di 30 giorni.
Facoltativamente, puoi fornire una chiave KMS (key id, arn, alias o alias arn) che il servizio utilizzerà per crittografare i log gestiti.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"ManagedLoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
},
}'
--engine-configuration ''
```
**Nota**
Se disattivi la registrazione gestita, Athena non può risolvere i problemi delle sessioni per tuo conto. Esempio: non potrai accedere alla Spark-UI dai notebook Amazon SageMaker AI Studio o utilizzare l'API. `GetResourceDashboard`
Per disattivare questa opzione da AWS CLI, usa la `ManagedLoggingConfiguration` configurazione quando avvii una sessione interattiva.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"ManagedLoggingConfiguration": {
"Enabled": false
},
}'
--engine-configuration ''
```
### Autorizzazioni richieste per la registrazione gestita
Se hai fornito una chiave KMS, avrai bisogno delle seguenti autorizzazioni nella politica delle autorizzazioni per il ruolo di esecuzione.
```
{
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*",
"Effect": "Allow"
}
```
## Registrazione di Amazon S3
Puoi configurare la consegna dei log ai bucket Amazon S3.
Per abilitare la consegna dei log S3 da AWS CLI, usa la `S3LoggingConfiguration` configurazione quando avvii una sessione interattiva.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"S3LoggingConfiguration": {
"Enabled":true,
"LogLocation": "s3://bucket/",
},
}'
--engine-configuration ''
```
Facoltativamente, puoi fornire una chiave KMS (key id, arn, alias o alias arn) che il servizio utilizzerà per crittografare i log S3.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"S3LoggingConfiguration": {
"Enabled":true,
"LogLocation": "s3://bucket/",
"KmsKey": "KMS_KEY"
},
}'
--engine-configuration ''
```
### Autorizzazioni richieste per la consegna dei log ad Amazon S3
Prima che le sessioni possano inviare i log ai bucket Amazon S3, includi le seguenti autorizzazioni nella politica delle autorizzazioni per il ruolo di esecuzione.
```
{
"Action": "s3:*",
"Resource": "*",
"Effect": "Allow"
}
```
Se hai fornito una chiave KMS, avrai bisogno anche delle seguenti autorizzazioni nella politica delle autorizzazioni per il ruolo di esecuzione.
```
{
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*",
"Effect": "Allow"
}
```
Se la chiave kms e il bucket non provengono dallo stesso account, KMS deve consentire il service principal di 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 registrazione
È possibile configurare la consegna dei log in gruppi di CloudWatch log.
Per abilitare la consegna dei log S3 da AWS CLI, usa la `CloudWatchLoggingConfiguration` configurazione quando avvii una sessione interattiva.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-"
}
}'
--engine-configuration ''
```
Tutti i log verranno consegnati per impostazione predefinita, ma puoi facoltativamente specificare quali tipi di log includere.
```
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 ''
```
### Autorizzazioni richieste per la consegna dei log a CloudWatch
Prima che le sessioni possano inviare i log ai gruppi di CloudWatch log, includi le seguenti autorizzazioni nella politica delle autorizzazioni per il ruolo di esecuzione.
```
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams"
],
"Resource": "*",
"Effect": "Allow"
}
```
E previa autorizzazione alla politica delle risorse chiave di KMS.
```
{
"Effect": "Allow",
"Principal": {
"Service": "logs..amazonaws.com"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
}
```
## Configurazione delle impostazioni predefinite di registrazione nel gruppo di lavoro
È inoltre possibile specificare le opzioni di registrazione predefinite a livello di gruppo di lavoro.
Per specificare le opzioni di registrazione predefinite da AWS CLI per un gruppo di lavoro, usa la `monitoring-configuration` configurazione quando crei un nuovo gruppo di lavoro:
```
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"
]
}
}
}'
```
Per modificare le opzioni di registrazione predefinite AWS CLI per un gruppo di lavoro, utilizzate la configurazione durante l'aggiornamento di un gruppo di lavoro. `monitoring-configuration` Le modifiche si applicano alle nuove sessioni interattive in futuro.
```
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"
]
}
}
}'
```
# Accesso all'interfaccia utente di Spark
Apache Spark UIs presenta interfacce visive con informazioni dettagliate sui job Spark in esecuzione e completati. Puoi monitorare ed eseguire il debug delle sessioni interattive in Athena Spark utilizzando Apache UIs Spark nativo, dove puoi approfondire le metriche e le informazioni specifiche del lavoro su tempistiche, fasi, attività ed esecutori degli eventi per ogni job Spark.
## Accesso all'interfaccia utente di Spark
Dopo aver avviato una sessione interattiva di Athena Spark, puoi visualizzare l'interfaccia utente Spark in tempo reale per le sessioni in esecuzione dai notebook Amazon SageMaker AI Unified Studio o richiedere un URL sicuro utilizzando l'API. `GetResourceDashboard` Per le sessioni completate, puoi visualizzare lo Spark History Server dai notebook Amazon SageMaker AI Unified Studio, dalla console Amazon Athena o utilizzando la stessa API.
```
aws athena get-resource-dashboard \
--region "REGION" \
--session-id "SESSION_ID"
```
## Autorizzazioni richieste per accedere all'interfaccia utente di Spark
Prima di poter accedere all'interfaccia utente di Spark, includi le seguenti autorizzazioni nella politica delle autorizzazioni per l'utente o il ruolo.
```
{
"Action": "athena:GetResourceDashboard",
"Resource": "WORKGROUP",
"Effect": "Allow"
}
```
# Supporto Spark Connect
Spark Connect è un'architettura client-server per Apache Spark che separa il client dell'applicazione dal processo driver del cluster Spark, permettendo la connettività remota a Spark dai client supportati. Spark Connect consente anche il debug interattivo durante lo sviluppo direttamente dai tuoi /clients. IDEs
A partire dalla versione 3.5 di Apache Spark, Athena supporta Spark Connect come AWS endpoint accessibile tramite l'API. `GetSessionEndpoint`
## Esempi di API/CLI () GetSessionEndpoint
Puoi utilizzare l'`GetSessionEndpoint`API per ottenere l'endpoint Spark Connect per una sessione interattiva.
```
aws athena get-session-endpoint \
--region "REGION" \
--session-id "SESSION_ID"
```
Questa API restituisce l'URL dell'endpoint Spark Connect per quella sessione.
```
{
"EndpointUrl": "ENDPOINT_URL",
"AuthToken": "AUTH_TOKEN",
"AuthTokenExpirationTime": "AUTH_TOKEN_EXPIRY_TIME"
}
```
## Connessione da client autogestiti
Puoi connetterti a una sessione interattiva di Athena Spark da client autogestiti.
### Prerequisiti
Installa il client pyspark-connect per Spark 3.5.6 e l'SDK per Python. AWS
```
pip install --user pyspark[connect]==3.5.6
pip install --user boto3
```
Di seguito è riportato un esempio di script Python per inviare richieste direttamente all'endpoint della sessione:
```
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()
```
Di seguito è riportato un esempio di script Python per accedere all'interfaccia utente live di Spark o allo Spark History Server per una sessione:
```
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']
```
# Abilitare il pagamento del richiedente per i bucket Amazon S3 in Athena per Spark
Quando un bucket Amazon S3 è configurato per il pagamento a carico del richiedente, all'account dell'utente che esegue la query vengono addebitati i costi di accesso e trasferimento dei dati associati alla richiesta. Per ulteriori informazioni, consulta la sezione [Utilizzo dei bucket con pagamento a carico del richiedente per i trasferimenti e l'utilizzo dello storage](https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html) nella *Guida per l'utente di Amazon S3*.
In Athena for Spark, i bucket di pagamento del richiedente sono abilitati per sessione, non per gruppo di lavoro. Ad alto livello, l'abilitazione dei bucket requester pay include i seguenti passaggi:
1. Nella console Amazon S3, abilita i pagamenti del richiedente sulle proprietà del bucket e aggiungi una policy del bucket per specificare l'accesso.
1. Nella console IAM, crea una policy IAM per consentire l'accesso al bucket, quindi collega la policy al ruolo IAM che verrà utilizzato per accedere al bucket a pagamento a carico del richiedente.
1. In Athena for Spark, aggiungi una proprietà di sessione per abilitare la funzionalità di pagamento del richiedente.
## Passaggio 1: abilitare il pagamento a carico del richiedente su un bucket Amazon S3 e aggiungi una policy di bucket
**Come abilitare il pagamento a carico del richiedente su un bucket Amazon S3**
1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nell'elenco dei bucket scegli il il link per il bucket per il quale vuoi abilitare il pagamento a carico del richiedente.
1. Nella pagina dei bucket scegli la scheda **Proprietà**.
1. Scorri verso il basso fino alla sezione **Pagamento a carico del richiedente** e seleziona **Modifica**.
1. Nella pagina **Modifica i pagamenti a carico del richiedente**, seleziona **Abilita**, quindi seleziona **Salva modifiche**.
1. Scegli la scheda **Autorizzazioni**.
1. Seleziona **Modifica** nella sezione **Policy bucket**.
1. Nella pagina **Modifica policy bucket**, applica la policy del bucket che desideri al bucket di origine. La seguente policy di esempio dà accesso a tutti AWS i principali (`"AWS": "*"`), ma il tuo accesso può essere più granulare. Ad esempio, potresti voler specificare solo un ruolo IAM specifico in un altro account.
------
#### [ 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/*"
] } ] }
```
------
## Passaggio 2: creare una policy IAM e collegarvi il ruolo IAM.
Quindi, crea una policy IAM per consentire l'accesso a un bucket. Quindi alleghi la policy al ruolo che verrà utilizzato per accedere al bucket con costi a carico del richiedente.
**Creare una policy IAM per il richiedente paga il bucket e allegare la policy a un ruolo**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel pannello di navigazione della console IAM seleziona **Policy**.
1. Scegli **Crea policy**.
1. Scegli **JSON**.
1. In **Editor di policy**, aggiungi una policy come quella che segue:
------
#### [ 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. Scegli **Next (Successivo)**.
1. Nella pagina **Esamina e crea**, immetti un nome per la policy e una descrizione facoltativa, quindi seleziona **Crea policy**.
1. Nel riquadro di navigazione, seleziona **Ruoli**.
1. Nella pagina **Ruoli**, trova il ruolo che desideri utilizzare, quindi scegli il link al nome del ruolo.
1. Nella sezione **Policy di autorizzazioni**, seleziona **Aggiungi autorizzazioni**, **Collega policy**.
1. Nella sezione **Altre policy di autorizzazione**, seleziona la casella di controllo relativa alla policy che hai creato, quindi seleziona **Aggiungi autorizzazioni**.
## Passaggio 3: aggiungere una proprietà di sessione Athena per Spark
Dopo aver configurato il bucket Amazon S3 e le autorizzazioni associate per i pagamenti dei richiedenti, puoi abilitare la funzionalità in una sessione di Athena for Spark.
**Per abilitare i bucket requester pay in una sessione di Athena for Spark**
1. Nell'editor notebook, nel menu **Session** (Sessione) in alto a destra, scegli **Edit session** (Modifica sessione).
1. **Espandi le proprietà di Spark.**
1. Scegli **Modifica in JSON**.
1. Nell'editor di testo JSON, immetti quanto segue:
```
{
"spark.hadoop.fs.s3.useRequesterPaysHeader":"true"
}
```
1. Scegli **Save** (Salva).
# Utilizzo di Lake Formation con i gruppi di lavoro Athena Spark
Con la versione di rilascio di Apache Spark versione 3.5, puoi sfruttare AWS Lake Formation AWS Glue Data Catalog in cui il ruolo di esecuzione della sessione dispone delle autorizzazioni complete per la tabella. Questa funzionalità consente di leggere e scrivere su tabelle protette da Lake Formation dalle sessioni interattive di Athena Spark. Consulta le seguenti sezioni per saperne di più su Lake Formation e su come usarlo con Athena Spark.
## Passaggio 1: abilitare l'accesso completo alla tabella in Lake Formation
Per utilizzare la modalità Full Table Access (FTA), devi consentire ad Athena Spark di accedere ai dati senza la convalida del tag di sessione IAM. AWS Lake Formation Per abilitarli, seguire i passaggi descritti in [Integrazione delle applicazioni per l'accesso completo alla tabella](https://docs.aws.amazon.com//lake-formation/latest/dg/fta-app-integration.html).
### Passaggio 1.1: Registrare le posizioni dei dati in Lake Formation utilizzando il ruolo definito dall'utente
È necessario utilizzare un ruolo definito dall'utente per registrare le posizioni dei dati in AWS Lake Formation. Per ulteriori dettagli, consulta [Requisiti per i ruoli utilizzati per registrare le posizioni](https://docs.aws.amazon.com//lake-formation/latest/dg/registration-role.html).
## Fase 2: Configurazione delle autorizzazioni IAM per il ruolo di esecuzione della sessione
Per l'accesso in lettura o scrittura ai dati sottostanti, oltre alle autorizzazioni di Lake Formation, il ruolo di esecuzione richiede l'autorizzazione `lakeformation:GetDataAccess` IAM. Con questa autorizzazione, Lake Formation concede la richiesta di credenziali temporanee per accedere ai dati.
Di seguito è riportato un esempio di politica su come fornire autorizzazioni IAM per accedere a uno script in Amazon S3, caricare i log su S3, autorizzazioni API e autorizzazioni per accedere a Lake Formation. AWS Glue
### Passaggio 2.1: Configurare i permessi di Lake Formation
+ I job Spark che leggono dati da S3 richiedono l'autorizzazione di Lake Formation`SELECT`.
+ Spark rileva che write/delete i dati in S3 richiedono l'autorizzazione di Lake Formation`ALL (SUPER)`.
+ I job Spark che interagiscono con AWS Glue Data catalog richiedono l'`DROP`autorizzazione `DESCRIBE``ALTER`, se del caso.
## Passaggio 3: inizializza una sessione Spark per l'accesso completo alla tabella utilizzando Lake Formation
### Prerequisiti
AWS Glue Data Catalog deve essere configurato come metastore per accedere alle tabelle di Lake Formation.
Imposta le seguenti impostazioni per configurare il AWS Glue catalogo come metastore:
```
{
"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"
}
```
Per accedere alle tabelle registrate con AWS Lake Formation, è necessario impostare le seguenti configurazioni durante l'inizializzazione di Spark per configurare Spark per l'utilizzo delle credenziali. AWS Lake Formation
### 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"
}
```
### Tabelle di 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"
}
```
## Considerazioni e limitazioni
+ L'accesso completo alla tabella è supportato per le tabelle Hive, Iceberg, Amazon S3 e le tabelle Delta. Le tabelle Hudi non supportano l'accesso completo alla tabella.
+ Per aggiungere nuovi cataloghi a una sessione attiva, utilizzare `spark.conf.set` con nuove configurazioni di catalogo.
+ Le configurazioni del catalogo sono immutabili. Se desideri aggiornare una configurazione del catalogo, crea un nuovo catalogo utilizzando. `spark.conf.set`
+ Aggiungi solo i cataloghi di cui hai bisogno alla sessione Spark.
+ Per modificare il catalogo predefinito: `spark.catalog.setCurrentCatalog("s3tablesbucket")`
+ Se nel nome del catalogo sono presenti caratteri speciali come: `-`
```
SELECT sales_amount as nums FROM `my-s3-tables-bucket`.`s3namespace`.`daily_sales` LIMIT 100
```
# Abilitare la crittografia Apache Spark
Puoi abilitare la crittografia Apache Spark su Athena. In questo modo si crittografano i dati in transito tra i nodi Spark e si crittografano anche i dati a riposo archiviati localmente da Spark. Per migliorare la sicurezza di questi dati, Athena utilizza la seguente configurazione di crittografia:
```
spark.io.encryption.keySizeBits="256"
spark.io.encryption.keygen.algorithm="HmacSHA384"
```
Per abilitare la crittografia Spark, puoi utilizzare la console Athena, o AWS CLI l'API Athena.
## Utilizzare la console Athena per abilitare la crittografia Spark in un nuovo notebook
**Per creare un nuovo notebook con la crittografia Spark abilitata**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
1. Esegui una delle seguenti operazioni:
+ In **Notebook explorer**, scegli **Create notebook** (Crea notebook).
+ In **Notebook editor** (Editor notebook), scegli **Create notebook** (Crea notebook) oppure seleziona l'icona con il segno più (**\$1**) per aggiungere un notebook.
1. In **Nome notebook**, inserisci un nome per il notebook.
1. Espandi l'opzione delle **Proprietà Spark**.
1. Seleziona **Attiva la crittografia Spark**.
1. Scegli **Create** (Crea).
La sessione notebook che crei è crittografata. Usa il nuovo notebook come faresti normalmente. Quando in seguito lancerai nuove sessioni che utilizzano il notebook, anche le nuove sessioni verranno crittografate.
## Utilizzare la console Athena per abilitare la crittografia Spark per un notebook esistente
Puoi anche utilizzare la console Athena per abilitare la crittografia Spark per un notebook esistente.
**Per abilitare la crittografia per un notebook esistente**
1. [Apri una nuova sessione](notebooks-spark-managing.md#opening-a-previously-created-notebook) per un notebook creato in precedenza.
1. Nell'editor notebook, nel menu **Session** (Sessione) in alto a destra, scegli **Edit session** (Modifica sessione).
1. Nella finestra di dialogo **Modifica i dettagli della sessione**, espandi le **proprietà Spark**.
1. Seleziona **Attiva la crittografia Spark**.
1. Scegli **Save** (Salva).
La console avvia una nuova sessione con la crittografia abilitata. Anche le sessioni successive create per questo notebook avranno la crittografia abilitata.
## Usa per abilitare la crittografia AWS CLI Spark
Puoi utilizzare il AWS CLI per abilitare la crittografia all'avvio di una sessione specificando le proprietà Spark appropriate.
**Da utilizzare per AWS CLI abilitare la crittografia Spark**
1. Utilizzate un comando come il seguente per creare un oggetto JSON di configurazione del motore che specifichi le proprietà di crittografia Spark.
```
ENGINE_CONFIGURATION_JSON=$(
cat <
Per abilitare la crittografia Spark con l'API Athena, usa l'azione e [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)il [EngineConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EngineConfiguration.html)`SparkProperties`relativo parametro per specificare la configurazione di crittografia nella `StartSession` richiesta.
# Configura AWS Glue l'accesso tra account diversi in Athena per Spark
Questo argomento mostra come configurare l'account consumatore *666666666666* e l'account *999999999999* proprietario per l'accesso su più account. AWS Glue Quando gli account sono configurati, l'account consumer può eseguire query da Athena for Spark sui database e sulle tabelle AWS Glue del proprietario.
## Fase 1: In AWS Glue, fornisci l'accesso ai ruoli dei consumatori
Nel AWS Glue, il proprietario crea una politica che fornisce ai ruoli del consumatore l'accesso al catalogo AWS Glue dati del proprietario.
**Per aggiungere una AWS Glue politica che consenta a un ruolo di consumatore di accedere al catalogo dati del proprietario**
1. Accedi a Console di gestione AWS utilizzando l'account del proprietario del catalogo.
1. Apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel riquadro di navigazione, espandi **Data Catalog**, quindi seleziona **Impostazioni catalogo**.
1. Nella pagina **Impostazioni del catalogo dati**, nella sezione **Autorizzazioni**, aggiungi una policy come quella che segue. Questa politica fornisce i ruoli per l'*666666666666*accesso dell'account consumatore al catalogo dati nell'account del proprietario*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/*"
]
}
]
}
```
------
## Passaggio 2: configurare l’account consumer per l’accesso
Nell'account consumatore, crea una politica per consentire l'accesso al proprietario AWS Glue Data Catalog, ai database e alle tabelle e associala a un ruolo. L'esempio seguente utilizza un account consumer*666666666666*.
**Per creare una AWS Glue politica di accesso al proprietario AWS Glue Data Catalog**
1. Accedi con l'account consumer a Console di gestione AWS.
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione, espandi **Gestione accesso**, quindi seleziona **Policy**.
1. Scegli **Crea policy**.
1. Nella pagina **Specifica autorizzazioni**, seleziona **JSON**.
1. Nell'**editor delle politiche**, inserisci un'istruzione JSON come la seguente che consente AWS Glue azioni sul catalogo di dati dell'account proprietario.
------
#### [ 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. Scegli **Next (Successivo)**.
1. Nella pagina **Rivedi e crea**, per **Nome policy ** inserisci un nome per la policy.
1. Scegli **Crea policy**.
Successivamente, utilizzi la console IAM nell'account consumer per allegare la policy che hai appena creato a uno o più ruoli IAM che l'account consumer utilizzerà per accedere al catalogo dati del proprietario.
**Per allegare la AWS Glue politica ai ruoli nell'account consumatore**
1. Nel pannello di navigazione della console IAM dell'account consumer, seleziona **Ruoli**.
1. Nella pagina **Ruoli**, individua il ruolo a cui intendi collegare la policy.
1. Seleziona **Aggiungi autorizzazioni**, quindi seleziona **Collega policy**.
1. Trova la policy che hai appena creato.
1. Seleziona la casella di controllo della policy, quindi seleziona **Aggiungi autorizzazioni**.
1. Ripeti i passaggi per aggiungere la policy agli altri ruoli che intendi utilizzare.
## Passaggio 3: configurare una sessione e creazione di una query
In Athena Spark, nell'account del richiedente, utilizzando il ruolo specificato, crea una sessione per testare l'accesso [creando un notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) o [modificando una sessione corrente](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details). Quando [configuri le proprietà della sessione](notebooks-spark-custom-jar-cfg.md#notebooks-spark-custom-jar-cfg-console), specifica una delle seguenti opzioni:
+ **Il separatore di AWS Glue catalogo**: con questo approccio, includi l'ID dell'account proprietario nelle tue query. Utilizza questo metodo se intendi utilizzare la sessione per eseguire query sui cataloghi di dati di diversa proprietà.
+ **L'ID del AWS Glue catalogo**: con questo approccio, si interroga direttamente il database. Questo metodo è più comodo se intendi utilizzare la sessione per eseguire query sul catalogo dati di una sola proprietà.
### Utilizzate il separatore di AWS Glue catalogo
Quando modificate le proprietà della sessione, aggiungete quanto segue:
```
{
"spark.hadoop.aws.glue.catalog.separator": "/"
}
```
Quando esegui una query in una cella, utilizza una sintassi simile a quella dell'esempio seguente. Tieni presente che nella clausola `FROM`, l'ID del catalogo e il separatore sono obbligatori prima del nome del database.
```
df = spark.sql('SELECT requestip, uri, method, status FROM `999999999999/mydatabase`.cloudfront_logs LIMIT 5')
df.show()
```
### Usa l'ID del AWS Glue catalogo
Quando modificate le proprietà della sessione, inserite la seguente proprietà. *999999999999*Sostituiscilo con l'ID dell'account del proprietario.
```
{
"spark.hadoop.hive.metastore.glue.catalogid": "999999999999"
}
```
Quando esegui una query in una cella, utilizza una sintassi come la seguente: Si noti che nella clausola `FROM`, l'ID del catalogo e il separatore non sono richiesti prima del nome del database.
```
df = spark.sql('SELECT * FROM mydatabase.cloudfront_logs LIMIT 10')
df.show()
```
## Risorse aggiuntive
[Configurare l'accesso tra account ai cataloghi di AWS Glue dati](security-iam-cross-account-glue-catalog-access.md)
[Gestione delle autorizzazioni per più account utilizzando entrambi AWS Glue e Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/hybrid-cross-account.html) nella *AWS Lake Formation Developer* Guide.
[Configura l'accesso tra account a un account condiviso AWS Glue Data Catalog utilizzando Amazon Athena AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-a-shared-aws-glue-data-catalog-using-amazon-athena.html) *in Prescriptive* Guidance Patterns.
# Comprendere le Service Quotas per Athena for Spark
*Le quote di servizio*, note anche come *limiti*, sono il numero massimo di risorse o operazioni di servizio che è Account AWS possibile utilizzare. Per ulteriori informazioni sulle quote di servizio per altri AWS servizi che puoi utilizzare con Amazon Athena per Spark, [AWS consulta le quote di servizio](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) nel. *Riferimenti generali di Amazon Web Services*
**Nota**
I valori predefiniti sono le quote iniziali impostate da AWS, che sono separate dal valore effettivo della quota applicata e dalla quota di servizio massima possibile. New Account AWS potrebbe avere quote iniziali inferiori che possono aumentare nel tempo. Amazon Athena per Apache Spark monitora l'utilizzo degli account all'interno di ciascun account Regione AWS, quindi aumenta automaticamente le quote in base all'utilizzo. Se i tuoi requisiti superano i limiti indicati, contatta l'assistenza clienti.
La tabella seguente elenca le service quotas per Amazon Athena per Apache Spark.
****
| Name | Predefinita | Adattabile | Versione | Description |
| --- | --- | --- | --- | --- |
| Simultaneità delle DPU per Apache Spark | 160 | No | PySpark Versione 3 | Il numero massimo di unità di elaborazione dati (DPUs) che è possibile utilizzare contemporaneamente per i calcoli di Apache Spark per un singolo account nell'attuale sistema. Regione AWS Una DPU è una misura relativa della potenza di elaborazione costituita da 4 V di capacità CPUs di elaborazione e 16 GB di memoria. |
| Simultaneità DPU della sessione Apache Spark | 60 | No | PySpark Versione 3 | Il numero massimo di dati DPUs che puoi utilizzare contemporaneamente per un calcolo di Apache Spark all'interno di una sessione. |
| Su richiesta DPUs | 4 | No | Apache Spark versione 3.5 | Il numero massimo di unità di elaborazione dati (DPUs) che è possibile utilizzare contemporaneamente per le sessioni interattive di Apache Spark nella versione corrente. Regione AWS |
# Usa Athena Spark APIs
**Nota**
I taccuini e i calcoli Athena APIs sono disponibili nella versione di rilascio Pyspark engine versione 3. I taccuini e i calcoli non APIs sono supportati nella versione di rilascio Apache Spark versione 3.5.
L'elenco seguente contiene collegamenti di riferimento alle operazioni dell'API per notebook Athena. Per le strutture dei dati e altre operazioni dell'API Athena, consulta 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)
# Risolvere problemi in Athena per Spark
Utilizza le seguenti informazioni per risolvere i problemi che potresti riscontrare quando utilizzi notebook e sessioni su Athena.
**Topics**
+ [Ottieni informazioni sui problemi noti in Athena per Spark.](notebooks-spark-known-issues.md)
+ [Risolvere problemi relativi ai gruppi di lavoro abilitati per Spark](notebooks-spark-troubleshooting-workgroups.md)
+ [Utilizzare l’istruzione EXPLAIN di Spark per risolvere i problemi relativi a Spark SQL](notebooks-spark-troubleshooting-explain.md)
+ [Registrare eventi dell’applicazione Spark in Athena](notebooks-spark-logging.md)
+ [Utilizzalo CloudTrail per risolvere i problemi relativi alle chiamate API dei notebook Athena](notebooks-spark-troubleshooting-cloudtrail.md)
+ [Superare il limite di dimensione del blocco di codice di 68k](notebooks-spark-troubleshooting-code-block-size-limit.md)
+ [Risolvere gli errori delle sessioni](notebooks-spark-troubleshooting-sessions.md)
+ [Risoluzione degli errori relativi alle tabelle](notebooks-spark-troubleshooting-tables.md)
+ [Ottenere supporto](notebooks-spark-troubleshooting-support.md)
# Ottieni informazioni sui problemi noti in Athena per Spark.
Questa pagina documenta alcuni dei problemi noti di Athena per Apache Spark.
## Eccezione di argomento illegale durante la creazione di una tabella
Sebbene Spark non consenta la creazione di database con una proprietà location vuota, i database in AWS Glue possono avere una `LOCATION` proprietà vuota se vengono creati all'esterno di Spark.
Se crei una tabella e specifichi un AWS Glue database con un `LOCATION` campo vuoto, può verificarsi un'eccezione come la seguente IllegalArgumentException: Impossibile creare un percorso da una stringa vuota.
Ad esempio, il comando seguente genera un'eccezione se il database predefinito in AWS Glue contiene un campo `LOCATION` vuoto:
```
spark.sql("create table testTable (firstName STRING)")
```
**Soluzione consigliata AWS Glue A**: da utilizzare per aggiungere una posizione al database in uso.
**Per aggiungere una posizione a un AWS Glue database**
1. Accedi a Console di gestione AWS e apri la AWS Glue console all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel pannello di navigazione, seleziona **Database**.
1. Nell'elenco dei database, scegli il nome del database da modificare.
1. Nella pagina dei dettagli per il database, scegli **Edit** (Modifica).
1. Nella pagina **Update a database** (Aggiorna un database), in **Location** (Posizione), inserisci una posizione Amazon S3.
1. Scegli **Update Database** (Aggiorna database).
**Soluzione consigliata B**: utilizza un database AWS Glue diverso con una posizione esistente e valida in Amazon S3. Ad esempio, se hai un database denominato `dbWithLocation`, utilizza il comando `spark.sql("use dbWithLocation")` per passare a quel database.
**Soluzione consigliata C**: quando utilizzi Spark SQL per creare la tabella, specifica un valore per `location`, come nell'esempio seguente.
```
spark.sql("create table testTable (firstName STRING)
location 's3://amzn-s3-demo-bucket/'").
```
**Soluzione consigliata D**: se hai specificato una posizione quando hai creato la tabella ma il problema persiste, assicurati che il percorso Amazon S3 fornito abbia una barra finale. Ad esempio, il comando seguente genera un'eccezione di argomento illegale:
```
spark.sql("create table testTable (firstName STRING)
location 's3://amzn-s3-demo-bucket'")
```
Per correggere questo problema, aggiungi una barra finale alla posizione (ad esempio, `'s3://amzn-s3-demo-bucket/'`).
## Database creato in una posizione del gruppo di lavoro
Se si utilizza un comando come `spark.sql('create database db')` per creare un database e non si specifica una posizione per il database, Athena crea una sottodirectory nella posizione del gruppo di lavoro e la utilizza per il database appena creato.
## Problemi con le tabelle gestite da Hive nel database AWS Glue predefinito
Se la `Location` proprietà del database predefinito in non AWS Glue è vuota e specifica una posizione valida in Amazon S3 e utilizzi Athena for Spark per creare una tabella gestita Hive nel AWS Glue tuo database predefinito, i dati vengono scritti nella posizione Amazon S3 specificata nel gruppo di lavoro Athena Spark anziché nella posizione specificata dal database. AWS Glue
Questo problema si verifica a causa del modo in cui Apache Hive gestisce il database predefinito. Apache Hive crea dati di tabella nella posizione principale del magazzino Hive, che può essere diversa dall'effettiva posizione predefinita del database.
Quando usi Athena for Spark per creare una tabella gestita Hive nel database predefinito in AWS Glue, i metadati della AWS Glue tabella possono puntare a due posizioni diverse. Ciò può causare un comportamento imprevisto quando si tenta un'operazione `INSERT` o `DROP TABLE`.
I passaggi per riprodurre il problema sono i seguenti:
1. In Athena for Spark, usi uno dei seguenti metodi per creare o salvare una tabella gestita da Hive:
+ Un'istruzione SQL come `CREATE TABLE $tableName`
+ Un PySpark comando del `df.write.mode("overwrite").saveAsTable($tableName)` genere non specifica l'`path`opzione nell'API Dataframe.
A questo punto, la AWS Glue console potrebbe mostrare una posizione errata in Amazon S3 per la tabella.
1. In Athena per Spark, utilizza l'istruzione `DROP TABLE $table_name` per eliminare la tabella che hai creato.
1. Dopo aver eseguito l'istruzione `DROP TABLE`, noterai che i file sottostanti in Amazon S3 sono ancora presenti.
Per risolvere il problema, procedi in uno dei seguenti modi:
**Soluzione A**: utilizza un AWS Glue database diverso quando crei tabelle gestite da Hive.
**Soluzione B**: specifica un percorso vuoto per il database predefinito in AWS Glue. Quindi, create le tabelle gestite nel database predefinito.
## Incompatibilità dei formati di file CSV e JSON tra Athena for Spark e Athena SQL
A causa di un problema noto con Spark open source, quando crei una tabella in Athena per Spark su dati CSV o JSON, la tabella potrebbe non essere leggibile da Athena SQL e viceversa.
Ad esempio, è possibile creare una tabella in Athena per Spark in uno dei seguenti modi:
+ Con la seguente sintassi `USING csv`:
```
spark.sql('''CREATE EXTERNAL TABLE $tableName (
$colName1 $colType1,
$colName2 $colType2,
$colName3 $colType3)
USING csv
PARTITIONED BY ($colName1)
LOCATION $s3_location''')
```
+ Con la seguente sintassi [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html)API:
```
df.write.format('csv').saveAsTable($table_name)
```
A causa del problema noto con Spark open source, le query di Athena SQL sulle tabelle risultanti potrebbero non avere esito positivo.
**Soluzione consigliata**: prova a creare la tabella in Athena per Spark usando la sintassi Apache Hive. Per ulteriori informazioni, consulta [CREATE HIVEFORMAT TABLE](https://spark.apache.org/docs/latest/sql-ref-syntax-ddl-create-table-hiveformat.html) nella documentazione di Apache Spark.
# Risolvere problemi relativi ai gruppi di lavoro abilitati per Spark
Utilizza le informazioni seguenti per risolvere i problemi relativi ai gruppi di lavoro abilitati per Spark in Athena.
## La sessione smette di rispondere quando si utilizza un ruolo IAM esistente
Se non ne hai creato un nuovo `AWSAthenaSparkExecutionRole` per il tuo gruppo di lavoro abilitato a Spark e hai invece aggiornato o scelto un ruolo IAM esistente, la tua sessione potrebbe smettere di rispondere. In questo caso, potrebbe essere necessario aggiungere le seguenti policy di attendibilità e autorizzazioni al ruolo di esecuzione del gruppo di lavoro abilitato a Spark.
Aggiungi la seguente policy di attendibilità. La policy prevede un controllo "confused deputy" per il ruolo esecutivo. Sostituisci i valori per `111122223333` e `workgroup-name` con l' Account AWS ID e Regione AWS il gruppo di lavoro che stai utilizzando. `aws-region`
------
#### [ 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"
}
}
}
]
}
```
------
Aggiungi una policy di autorizzazioni come la seguente policy predefinita per i gruppi di lavoro abilitati al notebook. Modifica le posizioni segnaposto Amazon S3 in modo che Account AWS IDs corrispondano a quelle che stai utilizzando. Sostituisci i valori per `amzn-s3-demo-bucket`, `aws-region`, `111122223333` e `workgroup-name` con il bucket Amazon S3, la Regione AWS, l'ID dell' Account AWS e il gruppo di lavoro che stai utilizzando.
------
#### [ 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" } } } ] }
```
------
# Utilizzare l’istruzione EXPLAIN di Spark per risolvere i problemi relativi a Spark SQL
Puoi utilizzare l'istruzione `EXPLAIN` di Spark con Spark SQL per risolvere i problemi del codice Spark. I seguenti esempi di codice e output mostrano questo utilizzo.
**Example - Istruzione SELECT di Spark**
```
spark.sql("select * from select_taxi_table").explain(True)
```
**Output**
```
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 - Dataframe Spark**
Il codice di esempio seguente mostra come utilizzare `EXPLAIN` con un dataframe Spark.
```
taxi1_df=taxi_df.groupBy("VendorID", "passenger_count").count()
taxi1_df.explain("extended")
```
**Output**
```
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
```
# Registrare eventi dell’applicazione Spark in Athena
L'editor notebook Athena consente la registrazione standard per Jupyter, Spark e Python. È possibile utilizzarli `df.show()` per visualizzare PySpark DataFrame i contenuti o `print("Output")` per visualizzare i valori nell'output della cella. I risultati dei calcoli `stdout`, `stderr` e `results` vengono scritti nella posizione del bucket dei risultati delle query in Amazon S3.
## Registra gli eventi dell'applicazione Spark su Amazon CloudWatch
Le tue sessioni Athena possono anche scrivere log su [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) nell'account che stai utilizzando.
### Comprendere i flussi di log e dei gruppi di log
CloudWatch organizza l'attività dei log in flussi di log e gruppi di log.
**Flussi di log**: un flusso di CloudWatch log è una sequenza di eventi di log che condividono la stessa fonte. Ogni fonte separata di log in CloudWatch Logs costituisce un flusso di log separato.
**Gruppi di log**: in CloudWatch Logs, un gruppo di log è un gruppo di flussi di log che condividono le stesse impostazioni di conservazione, monitoraggio e controllo degli accessi.
Non vi è alcun limite al numero di flussi di log che possono appartenere a un gruppo di log.
In Athena, quando si avvia una sessione di notebook per la prima volta, Athena crea un gruppo di log in CloudWatch cui viene utilizzato il nome del gruppo di lavoro abilitato per Spark, come nell'esempio seguente.
```
/aws-athena/workgroup-name
```
Questo gruppo di log riceve un flusso di log per ogni esecutore della sessione che produce almeno un log eventi. Un esecutore è l'unità di calcolo più piccola che una sessione di notebook può richiedere ad Athena. In CloudWatch, il nome del flusso di log inizia con l'ID della sessione e l'ID dell'esecutore.
Per ulteriori informazioni sui gruppi di CloudWatch log e sui flussi di log, consulta [Working with log groups and log stream](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) nella Amazon CloudWatch Logs User Guide.
### Utilizzare oggetti logger standard in Athena per Spark
In una sessione di Athena for Spark, puoi utilizzare i seguenti due oggetti logger standard globali per scrivere log su Amazon: CloudWatch
+ **athena\$1user\$1logger** — Invia i log solo a. CloudWatch Usa questo oggetto quando desideri registrare le informazioni direttamente nelle tue applicazioni Spark, come nell'esempio seguente. CloudWatch
```
athena_user_logger.info("CloudWatch log line.")
```
L'esempio scrive un evento di registro CloudWatch simile al seguente:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: CloudWatch log line.
```
+ **athena\$1shared\$1logger** — Invia lo stesso registro sia a che a destinazione per scopi di supporto. CloudWatch AWS È possibile utilizzare questo oggetto per condividere i log con i team di AWS assistenza per la risoluzione dei problemi, come nell'esempio seguente.
```
athena_shared_logger.info("Customer debug line.")
var = [...some variable holding customer data...]
athena_shared_logger.info(var)
```
L'esempio registra la `debug` riga e il valore della `var` variabile in CloudWatch Logs e invia una copia di ogni riga a. Supporto
**Nota**
Per motivi di privacy, il codice di calcolo e i risultati non vengono condivisi con. AWS Assicurati che le tue chiamate a `athena_shared_logger` scrivano solo le informazioni che desideri rendere visibili a Supporto.
I logger forniti scrivono eventi tramite [Apache Log4j](https://logging.apache.org/log4j/) ed ereditano i livelli di registrazione di questa interfaccia. I valori possibili a livello di log sono `DEBUG`, `ERROR`, `FATAL`, `INFO`, `WARN` o `WARNING`. Puoi utilizzare la funzione denominata corrispondente sul logger per produrre questi valori.
**Nota**
Non ricollegare i nomi `athena_user_logger` o `athena_shared_logger`. In questo modo non è possibile scrivere sugli oggetti di registrazione CloudWatch per il resto della sessione.
### Esempio: registra gli eventi del notebook su CloudWatch
La procedura seguente mostra come registrare gli eventi dei notebook Athena su Amazon CloudWatch Logs.
**Per registrare gli eventi dei notebook Athena su Amazon Logs CloudWatch**
1. Segui le istruzioni riportate in [Inizia a usare Apache Spark su Amazon Athena](notebooks-spark-getting-started.md) per creare un gruppo di lavoro compatibile con Spark in Athena con un nome univoco. In questo tutorial si utilizza il nome del gruppo di lavoro `athena-spark-example`.
1. Segui i passaggi illustrati in [Passaggio 7: creare il proprio notebook](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) per creare un notebook e avviare una nuova sessione.
1. Nell'editor notebook Athena, in una nuova cella del notebook, inserisci il seguente comando:
```
athena_user_logger.info("Hello world.")
```
1. Esegui la cella.
1. Recupera l'ID della sessione corrente effettuando una delle seguenti operazioni:
+ Visualizza l'output della cella (ad esempio `... session=72c24e73-2c24-8b22-14bd-443bdcd72de4`).
+ In una nuova cella, esegui il comando [magico](notebooks-spark-magics.md) `%session_id`.
1. Salva l'ID della sessione.
1. Con lo stesso Account AWS che usi per eseguire la sessione del notebook, apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel riquadro di navigazione della CloudWatch console, scegli **Registra gruppi**.
1. Nell'elenco dei gruppi di log, scegli il gruppo di log con il nome del gruppo di lavoro Athena abilitato per Spark, come nell'esempio seguente.
```
/aws-athena/athena-spark-example
```
La sezione **Log streams** (Flussi di log) contiene un elenco di uno o più collegamenti ai flussi di log per il gruppo di lavoro. Ogni nome del flusso di log contiene l'ID di sessione, l'ID dell'esecutore e l'UUID univoco separati da caratteri di barra.
Ad esempio, se l'ID della sessione è `5ac22d11-9fd8-ded7-6542-0412133d3177` e l'ID dell'esecutore è `f8c22d11-9fd8-ab13-8aba-c4100bfba7e2`, il nome del flusso di log è simile al seguente esempio.
```
5ac22d11-9fd8-ded7-6542-0412133d3177/f8c22d11-9fd8-ab13-8aba-c4100bfba7e2/f012d7cb-cefd-40b1-90b9-67358f003d0b
```
1. Scegli il collegamento del flusso di log della tua sessione.
1. Nella pagina **Log events** (Eventi di log), visualizza la colonna **Message** (Messaggio).
Il log eventi per la cella che hai eseguito è simile al seguente:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: Hello world.
```
1. Torna all'editor notebook Athena.
1. In una nuova cella, inserisci il seguente codice. Il codice registra una variabile in CloudWatch:
```
x = 6
athena_user_logger.warn(x)
```
1. Esegui la cella.
1. Torna alla pagina **Registra eventi** della CloudWatch console per lo stesso flusso di log.
1. Il flusso di log ora contiene una voce di log eventi con un messaggio simile al seguente:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 WARN builtins: 6
```
# Utilizzalo CloudTrail per risolvere i problemi relativi alle chiamate API dei notebook Athena
Per risolvere i problemi relativi alle chiamate API dei notebook, puoi esaminare i CloudTrail log di Athena per indagare sulle anomalie o scoprire le azioni avviate dagli utenti. Per informazioni dettagliate sull'utilizzo CloudTrail con Athena, vedere. [Registra le chiamate API Amazon Athena con AWS CloudTrail](monitor-with-cloudtrail.md)
Gli esempi seguenti mostrano le voci di CloudTrail registro per il notebook Athena. APIs
## StartSession
L'esempio seguente mostra il CloudTrail registro di un [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)evento notebook.
```
{
"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'esempio seguente mostra il CloudTrail registro di un [TerminateSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_TerminateSession.html)evento notebook.
```
{
"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'esempio seguente mostra il CloudTrail registro di un [ImportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ImportNotebook.html)evento notebook. Per motivi di sicurezza, alcuni contenuti sono nascosti.
```
{
"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'esempio seguente mostra il CloudTrail registro di un [UpdateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html)evento notebook. Per motivi di sicurezza, alcuni contenuti sono nascosti.
```
{
"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'esempio seguente mostra il CloudTrail registro di un [StartCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartCalculationExecution.html)evento notebook. Per motivi di sicurezza, alcuni contenuti sono nascosti.
```
{
"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"
}
}
```
# Superare il limite di dimensione del blocco di codice di 68k
Athena for Spark ha un limite noto di dimensione del blocco del codice di calcolo di 68000 caratteri. Quando esegui un calcolo con un blocco di codice superiore a questo limite, puoi ricevere il seguente messaggio di errore:
'...' in 'CodeBlock' non è riuscito a soddisfare il vincolo: il member deve avere una lunghezza inferiore o uguale a 68000
L'immagine seguente mostra questo errore nell'editor di notebook della console Athena.
![\[Messaggio di errore relativo alla dimensione del blocco di codice nell'editor di notebook Athena\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-troubleshooting-code-block-size-limit-1.png)
Lo stesso errore può verificarsi quando si utilizza AWS CLI per eseguire un calcolo con un blocco di codice di grandi dimensioni, come nell'esempio seguente.
```
aws athena start-calculation-execution \
--session-id "{SESSION_ID}" \
--description "{SESSION_DESCRIPTION}" \
--code-block "{LARGE_CODE_BLOCK}"
```
Il comando restituisce il seguente messaggio di errore:
*\$1LARGE\$1CODE\$1BLOCK\$1*in 'CodeBlock' non è riuscito a soddisfare il vincolo: il membro deve avere una lunghezza inferiore o uguale a 68000
## Soluzione alternativa
Per risolvere il problema, carica il file contenente la query o il codice di calcolo su Amazon S3. Quindi, usa boto3 per leggere il file ed eseguire il codice o il codice SQL.
Gli esempi seguenti presuppongono che tu abbia già caricato il file contenente la tua query SQL o il codice Python su Amazon S3.
### Esempio SQL
Il codice di esempio seguente legge il file `large_sql_query.sql` da un bucket Amazon S3 e quindi esegue la query di grandi dimensioni che il file contiene.
```
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 esempio
Il seguente esempio di codice legge il file `large_py_spark.py` da Amazon S3 e quindi esegue il blocco di codice di grandi dimensioni contenuto nel file.
```
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)
```
# Risolvere gli errori delle sessioni
Utilizzare le informazioni in questa sezione per risolvere i problemi relativi alle sessioni.
Quando si verifica un errore di configurazione personalizzato durante l'avvio di una sessione, la console Athena for Spark mostra un banner con un messaggio di errore. Per risolvere gli errori di avvio della sessione, puoi controllare la modifica dello stato della sessione o le informazioni di registrazione.
## Visualizzare informazioni sulla modifica dello stato della sessione
Puoi ottenere dettagli sulla modifica dello stato della sessione dall'editor di notebook Athena o dall'API Athena.
**Per visualizzare le informazioni sullo stato della sessione nella console Athena**
1. Nell'editor notebook di Athena, nel menu **Sessione** in alto a destra, scegli **Vedi dettagli**.
1. Visualizza la scheda **Sessione corrente**. La sezione **Informazioni sessione** mostra informazioni come l'ID della sessione, il gruppo di lavoro, lo stato e il motivo del cambio di stato.
La seguente schermata d'esempio mostra le informazioni nella sezione **Motivo modifica stato** della finestra di dialogo **Informazioni sessione** per un errore di sessione Spark in Athena.
![\[Visualizzazione delle informazioni sulla modifica dello stato della sessione nella console Athena for Spark.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/notebooks-spark-custom-jar-cfg-1.jpeg)
**Per visualizzare le informazioni sullo stato della sessione utilizzando l'API Athena**
+ Nell'API Athena, puoi trovare le informazioni sulla modifica dello stato della sessione nel `StateChangeReason` campo dell'[SessionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_SessionStatus.html)oggetto.
**Nota**
Dopo aver interrotto manualmente una sessione o se la sessione si interrompe dopo un timeout di inattività (l'impostazione predefinita è 20 minuti), il valore delle **StateChangeReason**modifiche alla sessione è stato terminato per richiesta.
## Utilizzare la registrazione per risolvere gli errori di avvio della sessione
Gli errori di configurazione personalizzati che si verificano durante l'avvio di una sessione vengono registrati da [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html). Nei tuoi CloudWatch log, cerca i messaggi di errore da cui `AthenaSparkSessionErrorLogger` risolvere un avvio non riuscito della sessione.
Per ulteriori informazioni sull’accesso a Spark, consultare [Registrare eventi dell’applicazione Spark in Athena](notebooks-spark-logging.md).
Per ulteriori informazioni sulla risoluzione dei problemi delle sessioni in Athena per Spark, consulta [Risolvere gli errori delle sessioni](#notebooks-spark-troubleshooting-sessions).
## Problemi specifici alla sessione
Utilizzare le informazioni in questa sezione per risolvere i problemi relativi a specifiche sessioni.
### Sessione in stato non integro
Se ricevi il messaggio di errore Session in unhealthy state. Please create a new session (Sessione in stato non integro. Crea una nuova sessione), termina la sessione esistente e creane una nuova.
### Impossibile stabilire una connessione al server del notebook
Quando apri un notebook, potresti ricevere il seguente messaggio di errore:
```
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.
```
#### Causa
Quando apre un notebook, Athena crea una sessione e si connette al notebook utilizzando un URL del notebook prefirmato. [La connessione al notebook utilizza il protocollo WSS (WebSocketSecure).](https://en.wikipedia.org/wiki/WebSocket)
Questo errore può verificarsi per i seguenti motivi:
+ Un firewall locale (ad esempio un firewall a livello aziendale) sta bloccando il traffico WSS.
+ Il software proxy o antivirus sul computer locale sta bloccando la connessione WSS.
#### Soluzione
Supponiamo di avere una connessione WSS nella Regione `us-east-1` come la seguente:
```
wss://94c2bcdf-66f9-4d17-9da6-7e7338060183.analytics-gateway.us-east-1.amazonaws.com/
api/kernels/33c78c82-b8d2-4631-bd22-1565dc6ec152/channels?session_id=
7f96a3a048ab4917b6376895ea8d7535
```
Per risolvere l'errore, utilizza una delle seguenti strategie.
+ Utilizza la sintassi del pattern wild card per consentire l'elenco del traffico WSS sulla porta `443` attraverso e. Regioni AWS Account AWS
```
wss://*amazonaws.com
```
+ Utilizza la sintassi del pattern wild card per consentire l'elenco del traffico WSS sulla porta `443` in una sola porta Regione AWS e tra quelle Account AWS specificate Regione AWS . Nell'esempio seguente viene utilizzato `us-east-1`.
```
wss://*analytics-gateway.us-east-1.amazonaws.com
```
# Risoluzione degli errori relativi alle tabelle
Utilizzare le informazioni in questa sezione per risolvere gli errori delle tabelle di Athena per Spark.
## Impossibile creare un errore di percorso durante la creazione di una tabella
**Messaggio di errore**: IllegalArgumentException: Impossibile creare un percorso da una stringa vuota.
**Causa**: Questo errore può verificarsi quando si utilizza Apache Spark in Athena per creare una tabella in un AWS Glue database e il database ha una proprietà vuota. `LOCATION`
**Soluzione consigliata**: per ulteriori informazioni e soluzioni, consulta la pagina [Eccezione di argomento illegale durante la creazione di una tabella](notebooks-spark-known-issues.md#notebooks-spark-known-issues-illegal-argument-exception).
## AccessDeniedException quando si eseguono interrogazioni su tabelle AWS Glue
**Messaggio di errore**: pyspark.sql.utils. AnalysisException: Impossibile verificare l'esistenza del database predefinito: com.amazonaws.services.glue.model. AccessDeniedException: User: arn:aws:sts: ::assumed-role/ *aws-account-id* - AWSAthenaSparkExecutionRole/*unique-identifier*- *unique-identifier* non AthenaExecutor è autorizzato a eseguire: glue: on GetDatabase resource: arn:aws:glue: :catalog *aws-region* perché *aws-account-id* nessuna politica basata sull'identità consente l'azione glue: (GetDatabase Service:; Codice di stato: 400; AWSGlue Codice di errore:; Request ID:; Proxy: null) AccessDeniedException *request-id*
Causa**:** al ruolo di esecuzione AWS Glue per il tuo gruppo di lavoro abilitato a Spark mancano le autorizzazioni per accedere alle risorse.
**Soluzione consigliata**: per risolvere questo problema, concedi al ruolo di esecuzione l'accesso alle AWS Glue risorse, quindi modifica la policy del bucket di Amazon S3 per concedere l'accesso al ruolo di esecuzione.
La seguente procedura descrive in modo più dettagliato questi passaggi.
**Per concedere al ruolo di esecuzione l'accesso alle risorse AWS Glue**
1. Apri la console Athena all'indirizzo [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Se il pannello di navigazione della console non è visibile, scegli il menu di espansione a sinistra.
![\[Scegli il menu di espansione.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/nav-pane-expansion.png)
1. Nel pannello di navigazione della console Athena, scegli **Workgroups** (Gruppi di lavoro).
1. Nella pagina **Workgroups** (Gruppi di lavoro), scegli il collegamento del gruppo di lavoro che desideri visualizzare.
1. Nella pagina **Overview Details** (Dettagli della panoramica) del gruppo di lavoro, scegli il collegamento **Role ARN** (ARN del ruolo). Il link apre il ruolo di esecuzione Spark nella console IAM.
1. Nella sezione **Permissions policies** (Policy autorizzazioni), scegli il nome della policy del ruolo con link.
1. Scegli **Edit policy** (Modifica policy), quindi scegli **JSON**.
1. Aggiungi AWS Glue l'accesso al ruolo. In genere, si aggiungono le autorizzazioni per le operazioni `glue:GetDatabase` e `glue:GetTable`. Per ulteriori informazioni sulla configurazione dei ruoli IAM, consulta la pagina [Adding and removing IAM identity permissions](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) (Aggiunta e rimozione di autorizzazioni per identità IAM) nella Guida per l'utente di IAM.
1. Scegli **Review policy (Esamina policy)** e quindi **Save changes (Salva modifiche)**.
1. Modifica la policy del bucket Amazon S3 per concedere l'accesso al ruolo di esecuzione. Nota che devi concedere al ruolo l'accesso sia al bucket sia agli oggetti al suo interno. Per i passaggi dettagliati, consulta la pagina [Adding a bucket policy using the Amazon S3 console](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-bucket-policy.html) (Aggiunta di una policy del bucket utilizzando la console Amazon S3) nella Guida per l'utente di Amazon Simple Storage Service.
# Ottenere supporto
Per ricevere assistenza da AWS, scegli **Support**, **Support Center** dal Console di gestione AWS. Per semplificare l'esperienza, tieni a portata di mano le seguenti informazioni:
+ ID della query Athena
+ ID sessione
+ ID del calcolo