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à.
# Utilizzo dei processi in AWS Glue
Nelle sezioni seguenti vengono fornite informazioni sui processi ETL e Ray in AWS Glue.
**Topics**
+ [AWS Glue versioni](release-notes.md)
+ [Lavorare con Spark jobs in AWS Glue](etl-jobs-section.md)
+ [Lavorare con Ray Jobs in AWS Glue](ray-jobs-section.md)
+ [Configurazione delle proprietà del processo per i processi shell di Python in AWS Glue](add-job-python.md)
+ [Monitoraggio AWS Glue](monitor-glue.md)
# AWS Glue versioni
È possibile configurare il parametro della AWS Glue versione quando si aggiunge o si aggiorna un lavoro. La AWS Glue versione determina le versioni di Apache Spark e Python supportate. AWS Glue La versione Python indica la versione supportata per i processi di tipo Spark. La tabella seguente elenca le versioni AWS Glue disponibili, le versioni Spark e Python corrispondenti e altre modifiche di funzionalità.
Puoi utilizzare gli [aggiornamenti Generative AI per Apache Spark per](upgrade-analysis.md) aggiornare i tuoi job Glue ETL dalle versioni precedenti di Glue (≥ 2.0) all'ultima versione di Glue.
## AWS Glue versioni
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/release-notes.html)
**Nota**
Le seguenti versioni di Glue supportano queste versioni di PythonShell:
PythonShell la versione 3.6 è supportata nella versione 1.0 di Glue.
PythonShell la versione 3.9 è supportata nella versione 3.0 di Glue.
Inoltre, gli endpoint di sviluppo sono supportati solo nelle versioni 1.0 e 0.9 di Glue.
# Policy di supporto versione AWS Glue
AWS Glue è un servizio di integrazione dati serverless che semplifica l'individuazione, la preparazione e la combinazione di dati per analisi dei dati, machine learning e sviluppo di applicazioni. Un *processo AWS Glue* contiene la logica di business che esegue le attività di integrazione dei dati in AWS Glue. Esistono tre tipi di processi in AWS Glue: *Spark (in batch e in streaming)*, *Ray* e *shell Python*. Quando definisci il processo, specifica la versione di AWS Glue che configura le versioni dell'ambiente di runtime Spark, Ray o Python sottostante. Ad esempio: un job Spark AWS Glue versione 5.0 supporta Spark 3.5.4 e Python 3.11.
## Policy di supporto
AWS Glue le versioni sono basate su una combinazione di sistema operativo, linguaggio di programmazione e librerie software soggette a manutenzione e aggiornamenti di sicurezza. AWS Glue la politica di supporto delle versioni prevede di interrompere il supporto per una versione quando uno dei componenti principali della versione raggiunge la fine del supporto comunitario a lungo termine (LTS) e gli aggiornamenti di sicurezza non sono più disponibili. AWS Glue la politica di supporto delle versioni include i seguenti stati:
**End of Support (EOS):** quando una AWS Glue versione raggiunge EOS:
+ AWS Glue non applicherà più patch di sicurezza o altri aggiornamenti alle versioni EOS.
+ AWS Glue le offerte di lavoro sulle versioni EOS non sono idonee al supporto tecnico.
+ AWS Glue potrebbe non funzionare SLAs quando i lavori vengono eseguiti su versioni EOS.
**Fine del ciclo di vita (EOL) -** Quando una AWS Glue versione raggiunge la fine del ciclo di vita (EOL):
+ Non è più possibile creare nuovi AWS Glue lavori o sessioni interattive nelle versioni EOL.
+ Non è più possibile avviare le esecuzioni di job su queste AWS Glue versioni.
+ AWS Glue interromperà le esecuzioni di job e le sessioni interattive esistenti nelle versioni EOL.
+ Le versioni EOL verranno rimosse da AWS Glue SDKs e. APIs
Le seguenti versioni AWS Glue hanno raggiunto la fine del supporto e non saranno più disponibili dopo la data di fine del ciclo di vita. Le modifiche allo stato di supporto di una versione iniziano a mezzanotte (fuso orario del Pacifico) della data specificata.
| **Tipo** | **Versione Glue** | **Fine del supporto** | **Fine del ciclo di vita** |
| --- | --- | --- | --- |
| **Tipo** | **Versione di Python** | **Fine del supporto** | **Fine del ciclo di vita** |
| --- | --- | --- | --- |
| **Tipo** | **Versione notebook** | **Fine del supporto** | **Fine del ciclo di vita** |
| --- | --- | --- | --- |
| Spark | Glue version 0.9 (Spark 2.2, Scala 2, Python 2) | 01/06/2022 | 01/04/2026 |
| Spark | Glue version 1.0 (Spark 2.4, Python 2) | 01/06/2022 | 01/04/2026 |
| Spark | Glue version 1.0 (Spark 2.4, Scala 2, Python 3) | 30/09/2022 | 01/04/2026 |
| Spark | Glue version 2.0 (Spark 2.4, Python 3) | 31/2024 | 1/4/2026 |
| Shell Python | Python 2 (AWS Glue versione 1.0) | 01/06/2022 | 01/04/2026 |
| Shell Python | PythonShell 3.6 (Glue versione 1.0) | 31/03/2026 | N/A |
| Endpoint di sviluppo | Notebook Zeppelin | 30/09/2022 | N/A |
**Nota**
La creazione di nuovi lavori in AWS Glue Python Shell 3.6 non sarà consentita una volta raggiunta la fine del supporto il 31 marzo 2026, ma puoi continuare ad aggiornare ed eseguire i lavori esistenti. Tuttavia, i lavori eseguiti su versioni fuori produzione non sono idonei al supporto tecnico. AWS Glue non applicherà patch di sicurezza o altri aggiornamenti alle versioni fuori produzione. AWS Glue inoltre non verrà rispettato SLAs quando i job vengono eseguiti su versioni fuori produzione.
AWS consiglia la migrazione dei processi alle versioni supportate.
Per informazioni sulla migrazione dei job Spark alla AWS Glue versione più recente, consulta [Migrazione dei AWS Glue job](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-51.html) alla versione 5.1. AWS Glue
Per eseguire la migrazione dei processi di shell Python all'ultima versione di AWS Glue:
+ Nella console, scegli `Python 3 (Glue Version 4.0)`.
+ Nell'[UpdateJob](https://docs.aws.amazon.com/glue/latest/webapi/API_UpdateJob.html)API [CreateJob](https://docs.aws.amazon.com/glue/latest/webapi/API_CreateJob.html)/, imposta il `GlueVersion` parametro su e il `2.0` `PythonVersion` to `3` sotto il parametro. `Command` La configurazione `GlueVersion` non influisce sul comportamento dei processi della shell Python, quindi non c'è alcun vantaggio nell'incrementare `GlueVersion`.
+ Devi rendere lo script del tuo processo compatibile con Python 3.
# Migrazione AWS Glue per i job Spark alla versione 5.1 AWS Glue
Questo argomento descrive le modifiche tra AWS Glue le versioni 0.9, 1.0, 2.0, 3.0, 4.0 e 5.0 per consentire la migrazione delle applicazioni Spark e dei lavori ETL alla 5.1. AWS Glue Descrive inoltre le funzionalità della AWS Glue versione 5.1 e i vantaggi del suo utilizzo.
Per utilizzare questa funzionalità con i tuoi lavori AWS Glue ETL, scegli `Glue version` quando **5.1** crei i tuoi lavori.
**Topics**
+ [Nuove funzionalità](#migrating-version-51-features)
+ [Azioni per migrare alla versione 5.1 AWS Glue](#migrating-version-51-actions)
+ [Elenco di controllo della migrazione](#migrating-version-51-checklist)
+ [Migrazione da 5.0 a 5.1 AWS Glue AWS Glue](#migrating-version-51-from-50)
+ [Migrazione dalle AWS Glue versioni precedenti alla 5.1 AWS Glue](#migrating-older-versions-to-51)
+ [Migrazione di connettori e driver JDBC per 5.1 AWS Glue](#migrating-version-51-connector-driver-migration)
## Nuove funzionalità
Questa sezione descrive le nuove funzionalità e i vantaggi della AWS Glue versione 5.1.
+ Aggiornamento di Apache Spark dalla versione 3.5.4 della AWS Glue versione 5.0 alla versione 3.5.6 della versione 5.1. AWS Glue
+ Open Table Formats (OTF) aggiornati a Hudi 1.0.2, Iceberg 1.10.0 e Delta Lake 3.3.2
+ **Iceberg Materialized Views - Crea e gestisci Iceberg Materialized Views** (MV). [Per ulteriori informazioni, consulta il post del blog](https://aws.amazon.com/blogs/big-data/introducing-apache-iceberg-materialized-views-in-aws-glue-data-catalog/)
+ **Formato Iceberg versione 3.0**: estende i tipi di dati e le strutture di metadati esistenti per aggiungere nuove funzionalità. Per ulteriori informazioni, consulta [Iceberg](https://iceberg.apache.org/spec/) Table Spec.
+ **Hudi Full Table Access** - Controllo completo dell'accesso alla tabella (FTA) per Apache Hudi in Apache Spark in base alle politiche definite in. AWS Lake Formation Questa funzionalità consente le operazioni di lettura e scrittura dai lavori AWS Glue ETL su tabelle AWS Lake Formation registrate quando il ruolo lavorativo ha accesso completo alla tabella.
+ **Supporto nativo di Spark per il controllo granulare degli accessi (FGAC) tramite AWS Lake Formation** DDL/DML operazioni (come CREATE, ALTER, DELETE, DROP) con controllo granulare degli accessi per le tabelle Apache Hive, Apache Iceberg e Delta Lake registrate in. AWS Lake Formation
+ **Contesto di controllo per i lavori Spark: il contesto di controllo per i lavori** AWS Glue ETL sarà disponibile per le chiamate API nei log. AWS Glue AWS Lake Formation AWS CloudTrail
**Problemi noti e limitazioni**
Tieni presente i seguenti problemi e limitazioni noti:
+ Supporto limitato per la clausola View SQL per la creazione di viste materializzate, la riscrittura delle query e l'aggiornamento incrementale. Maggiori dettagli sono disponibili nella pagina di documentazione della [funzionalità Iceberg](https://docs.aws.amazon.com/lake-formation/latest/dg/materialized-views.html#materialized-views-considerations-limitations) Materialized Views
+ Le **scritture Hudi FTA** richiedono l'utilizzo HoodieCredentialedHadoopStorage per la vendita di credenziali durante l'esecuzione del lavoro. Imposta la seguente configurazione durante l'esecuzione dei job Hudi:
`hoodie.storage.class=org.apache.spark.sql.hudi.storage.HoodieCredentialedHadoopStorage`
+ Il supporto di scrittura Hudi FTA funziona solo con le configurazioni Hudi predefinite. Le impostazioni Hudi personalizzate o non predefinite potrebbero non essere completamente supportate e potrebbero causare un comportamento imprevisto. Inoltre, il clustering for Hudi Merge-On-Read (MOR) non è supportato nella modalità di scrittura FTA.
**Modifiche importanti**
Notare le seguenti modifiche speciali:
+ Il file system S3A ha sostituito EMRFS come connettore S3 predefinito. Per informazioni su come effettuare la migrazione, consulta. [Migrazione da 5.0 a 5.1 AWS Glue AWS Glue](#migrating-version-51-from-50)
## Azioni per migrare alla versione 5.1 AWS Glue
Per i processi esistenti, modifica la `Glue version` dalla versione precedente a `Glue 5.1` nella configurazione del processo.
+ In AWS Glue Studio, scegli `Glue 5.1 - Supports Spark 3.5.6, Scala 2, Python 3` in`Glue version`.
+ Nell'API, scegli **5.1** nel parametro `GlueVersion` nell'operazione API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Per i nuovi processi, scegli `Glue 5.1` al momento della creazione.
+ Nella console, scegli `Spark 3.5.6, Python 3 (Glue Version 5.1) or Spark 3.5.6, Scala 2 (Glue Version 5.1)` in `Glue version`.
+ In AWS Glue Studio, scegli `Glue 5.1 - Supports Spark 3.5.6, Scala 2, Python 3` in`Glue version`.
+ Nell'API, scegli **5.1** nel parametro `GlueVersion` nell'operazione API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Per visualizzare i registri degli eventi di Spark della AWS Glue versione 5.1 della versione AWS Glue 2.0 o precedente, [avvia un server di cronologia Spark aggiornato per AWS Glue 5.1](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html) utilizzando o Docker. CloudFormation
## Elenco di controllo della migrazione
Rivedi questo elenco di controllo per la migrazione:
+ [Python] Aggiorna i riferimenti di avvio da 1.34 a 1.40.
## Migrazione da 5.0 a 5.1 AWS Glue AWS Glue
Tutti i parametri di lavoro e le funzionalità principali esistenti in AWS Glue 5.0 esisteranno nella versione AWS Glue 5.1. Nota le seguenti modifiche durante la migrazione:
+ Nella AWS Glue versione 5.1, il filesystem S3A ha sostituito EMRFS come connettore S3 predefinito. Se entrambi `spark.hadoop.fs.s3a.endpoint` e 3 non `spark.hadoop.fs.s3a.endpoint.region` sono impostati, la regione predefinita utilizzata da S3A è. `us-east-2` Ciò può causare problemi, come errori di timeout di caricamento di S3, in particolare per i processi VPC. Per mitigare i problemi causati da questa modifica, imposta la configurazione `spark.hadoop.fs.s3a.endpoint.region` Spark quando usi il file system S3A nella versione 5.1. AWS Glue
+ Per continuare a utilizzare EMRFS anziché S3A, imposta le seguenti configurazioni spark:
```
--conf spark.hadoop.fs.s3.impl=com.amazon.ws.emr.hadoop.fs.EmrFileSystem
--conf spark.hadoop.fs.s3n.impl=com.amazon.ws.emr.hadoop.fs.EmrFileSystem
--conf spark.hadoop.fs.AbstractFileSystem.s3.impl=org.apache.hadoop.fs.s3.EMRFSDelegate
```
Consulta la documentazione relativa alla migrazione di Spark:
+ [Guida alla migrazione: Spark Core](https://spark.apache.org/docs/3.5.6/core-migration-guide.html)
+ [Guida alla migrazione: SQL, set di dati e DataFrame](https://spark.apache.org/docs/3.5.6/sql-migration-guide.html)
+ [Guida alla migrazione: streaming strutturato](https://spark.apache.org/docs/3.5.6/ss-migration-guide.html)
+ [Aggiornamento PySpark](https://spark.apache.org/docs/3.5.6/api/python/migration_guide/pyspark_upgrade.html)
## Migrazione dalle AWS Glue versioni precedenti alla 5.1 AWS Glue
+ Per i passaggi di migrazione relativi alla versione AWS Glue 4.0 alla AWS Glue 5.0, consulta [Migrazione da AWS Glue 4.0 a AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-40) 5.0.
+ Per le fasi di migrazione relative alla AWS Glue versione 3.0 alla AWS Glue 5.0, consulta [Migrazione da AWS Glue 3.0 a AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-30) 5.0.
+ Per le fasi di migrazione relative alla versione AWS Glue 2.0 alla AWS Glue 5.0 e un elenco delle differenze di migrazione tra la AWS Glue versione 2.0 e 4.0, consulta [Migrazione dalla AWS Glue 2.0 alla AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html#migrating-version-50-from-20) 5.0.
## Migrazione di connettori e driver JDBC per 5.1 AWS Glue
Per le versioni dei connettori JDBC e data lake che sono state aggiornate, consulta:
+ [Appendice B: aggiornamenti dei driver JDBC](#migrating-version-51-appendix-jdbc-driver)
+ [Appendice C: Aggiornamenti dei connettori](#migrating-version-51-appendix-connector)
+ [Appendice D: Aggiornamenti di formato a tabella aperta](#migrating-version-51-appendix-open-table-formats)
Le seguenti modifiche si applicano agli aggiornamenti della versione OTF identificati nella [Appendice D: Aggiornamenti di formato a tabella aperta](#migrating-version-51-appendix-open-table-formats) versione 5.1. AWS Glue
**Apache Hudi**
Nota le seguenti modifiche:
+ Supporta l'accesso in lettura e scrittura FTA sulle tabelle registrate di Lake Formation.
**Apache Iceberg**
Nota le seguenti modifiche:
+ Supporta la versione 3 del formato Iceberg. Sono supportate le seguenti funzionalità:
+ Trasformazioni multiargomento per il partizionamento e l'ordinamento.
+ Tracciamento del lignaggio delle righe.
+ Vettori di cancellazione. Scopri di più nel [post del blog](https://aws.amazon.com/blogs/big-data/unlock-the-power-of-apache-iceberg-v3-deletion-vectors-on-amazon-emr/)
+ Chiavi di crittografia delle tabelle.
+ Supporto dei valori predefiniti per le colonne.
+ Supporta le scritture FGAC native di Spark su tabelle registrate. AWS Lake Formation
+ Compatibilità con Athena SQL - Impossibile leggere le tabelle Iceberg V3 create da EMR Spark a causa di un errore: `GENERIC_INTERNAL_ERROR: Cannot read unsupported version 3`
**Delta Lake**
Nota le seguenti modifiche:
+ Supporta l'accesso in lettura e scrittura FTA sulle tabelle registrate di Lake Formation.
### Appendice A: Aggiornamenti importanti delle dipendenze
Di seguito sono riportati gli aggiornamenti delle dipendenze:
| Dipendenza | Versione in 5.1 AWS Glue | Versione in AWS Glue 5.0 | Versione in AWS Glue 4.0 | Versione in AWS Glue 3.0 | Versione in AWS Glue 2.0 | Versione in AWS Glue 1.0 |
| --- | --- | --- | --- | --- | --- | --- |
| Java | 17 | 17 | 8 | 8 | 8 | 8 |
| Spark | 3.5.6 | 3,5,4 | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.4.1 | 3.4.1 | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2,12,18 | 2,12,18 | 2,12 | 2,12 | 2.11 | 2.11 |
| Jackson | 2,15,2 | 2,15,2 | 2,12 | 2,12 | 2.11 | 2.11 |
| Hive | 2.3.9-amzn-4 | 2.3.9-amzn-4 | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2,73,0 | 2,69,0 | 2,54,0 | 2,46,0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 3.7.0-M11 | 3.7.0-M11 | 36.6 | 3.5.x | 3.5.x |
| Arrow | 120,1 | 12,0.1 | 7,0,0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS Glue Client Data Catalog | 4.9.0 | 4.5.0 | 3.7.0 | 3.0.0 | 1.10.0 | N/D |
| AWS SDK per Java | 2.35.5 | 2,29,52 | 1.12 | 1.12 | | |
| Python | 3,11 | 3,11 | 3,10 | 3.7 | 2.7 e 3.6 | 2.7 e 3.6 |
| Boto | 1,40,61 | 1,34,131 | 1,26 | 1,18 | 1.12 | N/D |
| Connettore EMR DynamoDB | 5.7.0 | 5.6.0 | 4,16,0 | | | |
### Appendice B: aggiornamenti dei driver JDBC
Di seguito sono riportati gli aggiornamenti dei driver JDBC:
| Driver | Versione del driver JDBC in 5.1 AWS Glue | Versione del driver JDBC nella versione 5.0 AWS Glue | Versione del driver JDBC nella versione 4.0 AWS Glue | Versione del driver JDBC nella versione 3.0 AWS Glue | Versione del driver JDBC nelle versioni precedenti AWS Glue |
| --- | --- | --- | --- | --- | --- |
| MySQL | 8.0.33 | 8,0,33 | 8.0.23 | 8.0.23 | 5.1 |
| Microsoft SQL Server | 102,0 | 10.2,0 | 9,40 | 7,0,0 | 6.1.0 |
| Database Oracle | 23,3,023,09 | 23,3,023,09 | 21,7 | 21,1 | 11.2 |
| PostgreSQL | 42,7,3 | 42,7,3 | 42,36 | 4,2,18 | 42,1,0 |
| Amazon Redshift | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
| SAP Hana | 2,20,17 | 2,20,17 | 2,17,12 | | |
| Teradata | 20,00,00,33 | 20,00,00,33 | 20,00,00,06 | | |
### Appendice C: Aggiornamenti dei connettori
Di seguito sono riportati gli aggiornamenti dei connettori:
| Driver | Versione del connettore in 5.1 AWS Glue | Versione del connettore in AWS Glue 5.0 | Versione del connettore in AWS Glue 4.0 | Versione del connettore in AWS Glue 3.0 |
| --- | --- | --- | --- | --- |
| Connettore EMR DynamoDB | 5.7.0 | 5.6.0 | 4.16.0 | |
| Amazon Redshift | 6.4.2 | 64,0 | 6.1.3 | |
| OpenSearch | 1.2.0 | 1.2.0 | 1.0.1 | |
| MongoDB | 10.3.0 | 10.3.0 | 10.0.4 | 3.0.0 |
| Snowflake | 3.1.1 | 3.0.0 | 2.12.0 | |
| Google BigQuery | 0.32.2 | 0,32,2 | 0,32,2 | |
| AzureCosmos | 4,33,0 | 4,33,0 | 42,0 | |
| AzureSQL | 1.3.0 | 1.3.0 | 1.3.0 | |
| Vertica | 33,5 | 3.3.5 | 3.3.5 | |
### Appendice D: Aggiornamenti di formato a tabella aperta
Di seguito sono riportati gli aggiornamenti di formato a tabella aperta:
| OTF | Versione del connettore in 5.1 AWS Glue | Versione del connettore in AWS Glue 5.0 | Versione del connettore in AWS Glue 4.0 | Versione del connettore in AWS Glue 3.0 |
| --- | --- | --- | --- | --- |
| Hudi | 1.0.2 | 0.15.0 | 0.12.1 | 0,10,1 |
| Delta Lake | 3.3.2 | 3.3.0 | 2.1.0 | 1.0.0 |
| Iceberg | 1.10.0 | 1.7.1 | 1.0.0 | 0.13.1 |
# Migrazione AWS Glue per i job Spark alla versione 5.0 AWS Glue
Questo argomento descrive le modifiche tra AWS Glue le versioni 0.9, 1.0, 2.0, 3.0 e 4.0 per consentire la migrazione delle applicazioni Spark e dei lavori ETL alla 5.0. AWS Glue Descrive inoltre le funzionalità della AWS Glue versione 5.0 e i vantaggi del suo utilizzo.
Per utilizzare questa funzionalità con i tuoi lavori AWS Glue ETL, scegli `Glue version` quando **5.0** crei i tuoi lavori.
**Topics**
+ [Nuove funzionalità](#migrating-version-50-features)
+ [Azioni per migrare alla versione 5.0 AWS Glue](#migrating-version-50-actions)
+ [Elenco di controllo della migrazione](#migrating-version-50-checklist)
+ [AWS Glue Funzionalità 5.0](#migrating-version-50-features)
+ [Migrazione da 4.0 a 5.0 AWS Glue AWS Glue](#migrating-version-50-from-40)
+ [Migrazione da AWS Glue 3.0 a 5.0 AWS Glue](#migrating-version-50-from-30)
+ [Migrazione da AWS Glue 2.0 a 5.0 AWS Glue](#migrating-version-50-from-20)
+ [Modifiche al comportamento di registrazione nella versione 5.0 AWS Glue](#enable-continous-logging-changes-glue-50)
+ [Migrazione di connettori e driver JDBC per 5.0 AWS Glue](#migrating-version-50-connector-driver-migration)
## Nuove funzionalità
Questa sezione descrive le nuove funzionalità e i vantaggi della AWS Glue versione 5.0.
+ Aggiornamento di Apache Spark dalla versione 3.3.0 della versione AWS Glue 4.0 alla versione 3.5.4 della versione 5.0. AWS Glue Per informazioni, consulta [Miglioramenti principali da Spark 3.3.0 a Spark 3.5.4](#migrating-version-50-features-spark).
+ Controllo granulare degli accessi (FGAC) nativo di Spark con Lake Formation. Ciò include FGAC per le tabelle Iceberg, Delta e Hudi. Per ulteriori informazioni, consulta [Using AWS Glue with AWS Lake Formation](https://docs.aws.amazon.com/glue/latest/dg/security-lf-enable.html) per il controllo granulare degli accessi.
Tenere a mente le seguenti considerazioni o limitazioni per l'FGAC nativo di Spark:
+ Attualmente la scrittura dei dati non è supportata
+ Scrivere in Iceberg `GlueContext` tramite Lake Formation richiede invece l'uso del controllo degli accessi IAM
Per un elenco completo delle limitazioni e delle considerazioni relative all'utilizzo di FGAC nativo di Spark, consultare [Considerazioni e limitazioni](security-lf-enable-considerations.md).
+ Supporto per Amazon S3 Access Grants come soluzione scalabile di controllo degli accessi ai tuoi dati Amazon S3 da. AWS Glue Per ulteriori informazioni, consulta [Utilizzo di Amazon S3 Access Grants con AWS Glue](security-s3-access-grants.md).
+ Formati a tabella aperta (OTF) aggiornati a Hudi 0.15.0, Iceberg 1.7.1 e Delta Lake 3.3.0
+ Supporto per Amazon SageMaker Unified Studio.
+ Amazon SageMaker Lakehouse e l'integrazione dell'astrazione dei dati. Per ulteriori informazioni, consulta [Interrogazione dei cataloghi di dati dei metastore da ETL AWS Glue](#migrating-version-50-features-metastore).
+ Supporto per l'installazione di librerie Python aggiuntive utilizzando `requirements.txt`. Per ulteriori informazioni, consulta [Installazione di librerie Python aggiuntive in AWS Glue 5.0 o versioni successive utilizzando requirements.txt](aws-glue-programming-python-libraries.md#addl-python-modules-requirements-txt).
+ AWS Glue 5.0 supporta la derivazione dei dati in Amazon DataZone. Puoi AWS Glue configurare la raccolta automatica delle informazioni sulla derivazione durante le esecuzioni dei job Spark e inviare gli eventi di derivazione da visualizzare in Amazon. DataZone Per ulteriori informazioni, consulta [Data lineage in Amazon DataZone](https://docs.aws.amazon.com/datazone/latest/userguide/datazone-data-lineage.html).
Per configurarlo sulla AWS Glue console, attiva **Generate lineage events** e inserisci il tuo ID di DataZone dominio Amazon nella scheda **Job details**.
![\[Lo screenshot mostra l'attivazione di Amazon DataZone date lineage per. AWS Glue\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/glue-50-data-lineage.png)
In alternativa, puoi fornire il seguente parametro di lavoro (inserisci il tuo ID di DataZone dominio):
+ Chiave: `--conf`
+ Valore:
```
extraListeners=io.openlineage.spark.agent.OpenLineageSparkListener
—conf spark.openlineage.transport.type=amazon_datazone_api
-conf spark.openlineage.transport.domainId=
```
+ Aggiornamenti del connettore e dei driver JDBC. Per ulteriori informazioni, consultare [Appendice B: aggiornamenti dei driver JDBC](#migrating-version-50-appendix-jdbc-driver) e [Appendice C: Aggiornamenti dei connettori](#migrating-version-50-appendix-connector).
+ Aggiornamento Java da 8 a 17.
+ Maggiore spazio di archiviazione AWS Glue `G.1X` e `G.2X` lavoro per i lavoratori con spazio su disco che è aumentato rispettivamente a 94 GB e 138 GB. Inoltre, `R.8X` sono disponibili nuovi tipi di `G.12X` worker e versioni ottimizzate per `R.1X` la `R.2X` memoria nella versione AWS Glue 4.0 e successive. `G.16X` `R.4X` Per ulteriori informazioni, consulta [Jobs](aws-glue-api-jobs-job.md)
+ **Support for AWS SDK for Java, versione 2 AWS Glue - 5.0,** i job possono utilizzare le [versioni](https://github.com/aws/aws-sdk-java/tree/1.12.569) Java 1.12.569 [o](https://github.com/aws/aws-sdk-java-v2/tree/2.28.8) 2.28.8 se il job supporta la versione 2. L' AWS SDK for Java 2.x è un'importante riscrittura del codice base della versione 1.x. È stata sviluppata su base Java 8\$1 e aggiunge diverse caratteristiche richieste frequentemente. Queste includono il supporto per I/O senza blocchi e la possibilità di connettere un'implementazione HTTP diversa durante il runtime. Per ulteriori informazioni, inclusa una Guida alla migrazione da SDK per Java v1 a v2, consultare la guida [AWS SDK per Java, versione 2](https://docs.aws.amazon.com/sdk-for-java).
**Modifiche importanti**
Notare le seguenti modifiche speciali:
+ Nella AWS Glue versione 5.0, quando si utilizza il file system S3A e se sia `fs.s3a.endpoint` che `fs.s3a.endpoint.region` non sono impostati, la regione predefinita utilizzata da S3A è `us-east-2`. Ciò può causare problemi, come errori di timeout di caricamento di S3, in particolare per i processi VPC. Per mitigare i problemi causati da AWS Glue questa modifica, imposta la configurazione Spark `fs.s3a.endpoint.region` quando usi il file system S3A nella versione 5.0.
+ Controllo granulare degli accessi (FGAC) di Lake Formation
+ AWS Glue 5.0 supporta solo il nuovo DataFrames FGAC nativo di Spark che utilizza Spark. Non supporta l'utilizzo di FGAC. AWS Glue DynamicFrames
+ L'uso di FGAC nella versione 5.0 richiede la migrazione da Spark AWS Glue DynamicFrames DataFrames
+ Se non hai bisogno di FGAC, non è necessario migrare a Spark DataFrame e le GlueContext funzionalità, come i segnalibri di lavoro e i predicati push down, continueranno a funzionare.
+ I processi con FGAC nativo di Spark richiedono un minimo di 4 worker: un driver utente, un driver di sistema, un esecutore di sistema e un esecutore utente in standby.
+ Per ulteriori informazioni, consulta [Using AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/security-lf-enable.html) with per un controllo granulare degli accessi. AWS Lake Formation
+ Accesso completo alla tabella (FTA) con Lake Formation
+ AWS Glue 5.0 supporta FTA con Spark native DataFrames (nuove) e GlueContext DynamicFrames (legacy, con limitazioni)
+ FTA nativo di Spark
+ Se utilizzi lo script 4.0 GlueContext, esegui la migrazione all'utilizzo di Spark nativo.
+ Questa funzionalità è limitata alle tabelle hive e iceberg
+ Per maggiori informazioni sulla configurazione di un processo 5.0 per usare FTA nativo di Spark, consultare
+ GlueContext DynamicFrame FTA
+ Non è necessaria alcuna modifica del codice
+ Questa funzionalità è limitata alle tabelle non OTF: non funzionerà con Iceberg, Delta Lake e Hudi.
+ [Il lettore SIMD CSV vettorializzato](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-csv-home.html#aws-glue-programming-etl-format-simd-csv-reader) non è supportato.
+ La [registrazione continua](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html) nel gruppo di log di output non è supportata. Utilizzare invece il gruppo di log `error`.
+ Il AWS Glue job run insights `job-insights-rule-driver` è stato obsoleto. Il flusso di log `job-insights-rca-driver` si trova ora nel gruppo di log di errore.
+ I custom/marketplace connettori basati su Athena non sono supportati.
+ I connettori Adobe Marketo Engage, Facebook Ads, Google Ads, Google Analytics 4, Google Sheets, Hubspot, Instagram Ads, Intercom, Jira Cloud, Oracle, Salesforce, Salesforce Marketing Cloud NetSuite, Salesforce Marketing Cloud Account Engagement, SAP, Slack, Snapchat Ads, Stripe, Zendesk e Zoho CRM non sono OData supportati ServiceNow.
+ Le AWS Glue proprietà log4j personalizzate non sono supportate nella versione 5.0.
### Miglioramenti principali da Spark 3.3.0 a Spark 3.5.4
Nota i seguenti miglioramenti:
+ Client Python per Spark Connect ([SPARK-39375](https://issues.apache.org/jira/browse/SPARK-39375)).
+ Implementare il supporto per i valori DEFAULT per le colonne nelle tabelle ([SPARK-38334).](https://issues.apache.org/jira/browse/SPARK-38334)
+ Supportare i “riferimenti agli alias delle colonne laterali” ([SPARK-27561](https://issues.apache.org/jira/browse/SPARK-27561)).
+ Rafforzare l'utilizzo di SQLSTATE per le classi di errore ([SPARK-41994).](https://issues.apache.org/jira/browse/SPARK-41994)
+ Abilitare i join del filtro Bloom per impostazione predefinita ([SPARK-38841](https://issues.apache.org/jira/browse/SPARK-38841)).
+ Migliore scalabilità dell'interfaccia utente Spark e stabilità dei driver per applicazioni di grandi dimensioni ([SPARK-41053](https://issues.apache.org/jira/browse/SPARK-41053)).
+ Monitoraggio asincrono dei progressi nello streaming strutturato ([SPARK-39591](https://issues.apache.org/jira/browse/SPARK-39591)).
+ Elaborazione stateful arbitraria in Python nello streaming strutturato ([SPARK-40434](https://issues.apache.org/jira/browse/SPARK-40434)).
+ [Miglioramenti della copertura dell'API Pandas ([SPARK-42882) e supporto di input in (SPARK-39405](https://issues.apache.org/jira/browse/SPARK-42882)). NumPy PySpark ](https://issues.apache.org/jira/browse/SPARK-39405)
+ [Fornisci un profiler di memoria per le funzioni definite dall'utente (SPARK-40281). PySpark ](https://issues.apache.org/jira/browse/SPARK-40281)
+ PyTorch [Implementa il distributore (SPARK-41589).](https://issues.apache.org/jira/browse/SPARK-41589)
+ Pubblicare artefatti SBOM ([SPARK-41893](https://issues.apache.org/jira/browse/SPARK-41893)).
+ Ambiente IPv6 di solo supporto ([SPARK-39457](https://issues.apache.org/jira/browse/SPARK-39457)).
+ [Scheduler K8s personalizzato ( YuniKorn Apache e Volcano) GA (SPARK-42802).](https://issues.apache.org/jira/browse/SPARK-42802)
+ Supporto client di Scala and Go in Spark Connect ([SPARK-42554](https://issues.apache.org/jira/browse/SPARK-42554)) e ([SPARK-43351](https://issues.apache.org/jira/browse/SPARK-43351)).
+ PyTorchsupporto ML distribuito basato su Spark Connect ([SPARK-42471](https://issues.apache.org/jira/browse/SPARK-42471)).
+ Supporto dello streaming strutturato per Spark Connect in Python e Scala ([SPARK-42938](https://issues.apache.org/jira/browse/SPARK-42938)).
+ Supporto dell'API Pandas per il client Python Spark Connect ([SPARK-42497](https://issues.apache.org/jira/browse/SPARK-42497)).
+ Introduci Arrow Python UDFs ([SPARK-40307](https://issues.apache.org/jira/browse/SPARK-40307)).
+ Supportare le funzioni di tabella definite dall'utente in Python ([SPARK-43798](https://issues.apache.org/jira/browse/SPARK-43798)).
+ [Migra PySpark gli errori nelle classi di errore (SPARK-42986).](https://issues.apache.org/jira/browse/SPARK-42986)
+ PySpark [framework di test (SPARK-44042).](https://issues.apache.org/jira/browse/SPARK-44042)
+ [Aggiungi il supporto per HllSketch Datasketches (SPARK-16484).](https://issues.apache.org/jira/browse/SPARK-16484)
+ Miglioramento della funzione SQL integrata ([SPARK-41231](https://issues.apache.org/jira/browse/SPARK-41231)).
+ Clausola IDENTIFIER ([SPARK-43205](https://issues.apache.org/jira/browse/SPARK-43205)).
+ Aggiungere funzioni SQL nelle API Scala, Python e R ([SPARK-43907](https://issues.apache.org/jira/browse/SPARK-43907)).
+ Aggiungere il supporto per argomenti denominati per le funzioni SQL ([SPARK-43922](https://issues.apache.org/jira/browse/SPARK-43922)).
+ Evitare la riesecuzione di attività non necessarie su una lista di esecutori disattivati se i dati shuffle vengono migrati ([SPARK-41469](https://issues.apache.org/jira/browse/SPARK-41469)).
+ ML distribuito <> spark connect ([SPARK-42471](https://issues.apache.org/jira/browse/SPARK-42471)).
+ DeepSpeed [distributore (SPARK-44264).](https://issues.apache.org/jira/browse/SPARK-44264)
+ Implementare il checkpoint del changelog per l'archivio di stato RockSDB ([SPARK-43421](https://issues.apache.org/jira/browse/SPARK-43421)).
+ Introdurre la propagazione delle filigrane tra gli operatori ([SPARK-42376](https://issues.apache.org/jira/browse/SPARK-42376)).
+ [Introduci dropDuplicatesWithin Watermark (SPARK-42931).](https://issues.apache.org/jira/browse/SPARK-42931)
+ Miglioramenti alla gestione della memoria del provider di archivi di stato RocksDB ([SPARK-43311](https://issues.apache.org/jira/browse/SPARK-43311)).
## Azioni per migrare alla versione 5.0 AWS Glue
Per i processi esistenti, modifica la `Glue version` dalla versione precedente a `Glue 5.0` nella configurazione del processo.
+ In AWS Glue Studio, scegli `Glue 5.0 - Supports Spark 3.5.4, Scala 2, Python 3` in`Glue version`.
+ Nell'API, scegli **5.0** nel parametro `GlueVersion` nell'operazione API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Per i nuovi processi, scegli `Glue 5.0` al momento della creazione.
+ Nella console, scegli `Spark 3.5.4, Python 3 (Glue Version 5.0) or Spark 3.5.4, Scala 2 (Glue Version 5.0)` in `Glue version`.
+ In AWS Glue Studio, scegli `Glue 5.0 - Supports Spark 3.5.4, Scala 2, Python 3` in`Glue version`.
+ Nell'API, scegli **5.0** nel parametro `GlueVersion` nell'operazione API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Per visualizzare i log degli eventi di Spark della AWS Glue versione 5.0 della versione AWS Glue 2.0 o precedente, [avvia un server di cronologia Spark aggiornato per la AWS Glue versione 5.0](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html) utilizzando o Docker. CloudFormation
## Elenco di controllo della migrazione
Rivedi questo elenco di controllo per la migrazione:
+ Aggiornamenti di Java 17
+ [Scala] Aggiorna le chiamate AWS SDK dalla v1 alla v2
+ Migrazione da Python 3.10 a 3.11
+ [Python] Aggiornare i riferimenti di avvio da 1.26 a 1.34
## AWS Glue Funzionalità 5.0
Questa sezione descrive AWS Glue le funzionalità in modo più dettagliato.
### Interrogazione dei cataloghi di dati dei metastore da ETL AWS Glue
Puoi registrare il tuo AWS Glue lavoro per accedere a AWS Glue Data Catalog, il che rende disponibili tabelle e altre risorse di metastore per diversi consumatori. Il Data Catalog supporta una gerarchia multicatalogo, che unifica tutti i dati nei data lake Amazon S3. Fornisce inoltre sia un'API del metastore Hive che un'API Apache Iceberg open source per l'accesso ai dati. Queste funzionalità sono disponibili per altri servizi orientati ai dati come Amazon EMR, Amazon Athena AWS Glue e Amazon Redshift.
Quando crei risorse nel Data Catalog, puoi accedervi da qualsiasi motore SQL che supporti l'API REST di Apache Iceberg. AWS Lake Formation gestisce le autorizzazioni. Dopo la configurazione, è possibile sfruttare le funzionalità AWS Glue di interrogazione di dati diversi interrogando queste risorse di metastore con applicazioni familiari. Queste includono Apache Spark e Trino.
#### Come sono organizzate le risorse dei metadati
I dati sono organizzati in una gerarchia logica di cataloghi, database e tabelle, utilizzando: AWS Glue Data Catalog
+ Catalogo: un contenitore logico che contiene oggetti provenienti da un archivio dati, come schemi o tabelle.
+ Database: organizza oggetti di dati come tabelle e viste in un catalogo.
+ Tabelle e viste: oggetti di dati in un database che forniscono un livello di astrazione con uno schema comprensibile. Semplificano l'accesso ai dati sottostanti, che possono essere in vari formati e in varie posizioni.
## Migrazione da 4.0 a 5.0 AWS Glue AWS Glue
Tutti i parametri di lavoro e le funzionalità principali esistenti in AWS Glue 4.0 esisteranno nella AWS Glue versione 5.0, ad eccezione delle trasformazioni di machine learning.
Sono stati aggiunti i nuovi parametri seguenti:
+ `--enable-lakeformation-fine-grained-access`: abilita la funzionalità di controllo degli accessi a grana fine (FGAC) nelle tabelle di Lake Formation. AWS
Consulta la documentazione relativa alla migrazione di Spark:
+ [Guida alla migrazione: Spark Core](https://spark.apache.org/docs/3.5.6/core-migration-guide.html)
+ [Guida alla migrazione: SQL, set di dati e DataFrame](https://spark.apache.org/docs/3.5.6/sql-migration-guide.html)
+ [Guida alla migrazione: streaming strutturato](https://spark.apache.org/docs/3.5.6/ss-migration-guide.html)
+ [Aggiornamento PySpark](https://spark.apache.org/docs/3.5.6/api/python/migration_guide/pyspark_upgrade.html)
## Migrazione da AWS Glue 3.0 a 5.0 AWS Glue
**Nota**
Per le fasi di migrazione relative alla AWS Glue versione 4.0, consulta[Migrazione dalla 3.0 alla 4.0 AWS Glue AWS Glue](migrating-version-40.md#migrating-version-40-from-30).
Tutti i parametri di lavoro e le funzionalità principali esistenti nella AWS Glue versione 3.0 esisteranno nella AWS Glue versione 5.0, ad eccezione delle trasformazioni di apprendimento automatico.
## Migrazione da AWS Glue 2.0 a 5.0 AWS Glue
**Nota**
Per i passaggi di migrazione relativi alla AWS Glue 4.0 e un elenco delle differenze di migrazione tra la AWS Glue versione 3.0 e 4.0, consulta[Migrazione dalla 3.0 alla 4.0 AWS Glue AWS Glue](migrating-version-40.md#migrating-version-40-from-30).
Tieni inoltre presente le seguenti differenze di migrazione tra AWS Glue le versioni 3.0 e 2.0:
+ Tutti i parametri di lavoro e le funzionalità principali esistenti nella AWS Glue versione 2.0 esisteranno nella AWS Glue versione 5.0, ad eccezione delle trasformazioni di apprendimento automatico.
+ Diverse modifiche di Spark da sole potrebbero richiedere la revisione degli script per garantire che non si faccia riferimento alle caratteristiche rimosse. Ad esempio, Spark 3.1.1 e versioni successive non abilitano Scala-Untyped UDFs ma Spark 2.4 li consente.
+ Python 2.7 non è supportato.
+ Qualsiasi jar aggiuntivo fornito nei job AWS Glue 2.0 esistenti può creare dipendenze in conflitto poiché sono stati effettuati aggiornamenti in diverse dipendenze. È possibile evitare conflitti di dipendenze con il parametro `--user-jars-first` del processo.
+ Modifiche al comportamento dei file in parquet con timestamp. loading/saving from/to Per ulteriori dettagli, consultare Aggiornamento da Spark SQL 3.0 a 3.1.
+ Diverso parallelismo delle attività Spark per la configurazione. driver/executor È possibile regolare il parallelismo delle attività passando l'argomento del processo `--executor-cores`.
## Modifiche al comportamento di registrazione nella versione 5.0 AWS Glue
Di seguito sono riportate le modifiche al comportamento di registrazione nella AWS Glue versione 5.0. Per ulteriori informazioni, vedere [Registrazione dei lavori](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html). AWS Glue
+ Tutti i log (log di sistema, log dei daemon Spark, log degli utenti e log di Glue Logger) vengono ora scritti nel gruppo di log `/aws-glue/jobs/error` per impostazione predefinita.
+ Il gruppo di log `/aws-glue/jobs/logs-v2` utilizzato per la registrazione continua nelle versioni precedenti non viene più utilizzato.
+ Non è più possibile rinominare o personalizzare i nomi dei gruppi di log o dei flussi di log utilizzando gli argomenti di registrazione continua rimossi. Consultate invece i nuovi argomenti relativi al lavoro nella AWS Glue versione 5.0.
### Nella AWS Glue versione 5.0 vengono introdotti due nuovi argomenti relativi al lavoro
+ `––custom-logGroup-prefix`: consente di specificare un prefisso personalizzato per i gruppi di log `/aws-glue/jobs/error` e `/aws-glue/jobs/output`.
+ `––custom-logStream-prefix`: consente di specificare un prefisso personalizzato per i nomi dei flussi di log all'interno dei gruppi di log.
Le regole e le limitazioni di convalida per i prefissi personalizzati includono:
+ L'intero nome del flusso di log deve contenere da 1 a 512 caratteri.
+ Il prefisso personalizzato per i nomi dei flussi di log è limitato a 400 caratteri.
+ I caratteri consentiti nei prefissi includono caratteri alfanumerici, caratteri di sottolineatura (`\$1`), trattini (`-`) e barre (`/`).
### Argomenti di registrazione continua obsoleti nella versione 5.0 AWS Glue
I seguenti argomenti di lavoro per la registrazione continua sono obsoleti nella versione 5.0 AWS Glue
+ `––enable-continuous-cloudwatch-log`
+ `––continuous-log-logGroup`
+ `––continuous-log-logStreamPrefix`
+ `––continuous-log-conversionPattern`
+ `––enable-continuous-log-filter`
## Migrazione di connettori e driver JDBC per 5.0 AWS Glue
Per le versioni dei connettori JDBC e data lake che sono state aggiornate, consulta:
+ [Appendice B: aggiornamenti dei driver JDBC](#migrating-version-50-appendix-jdbc-driver)
+ [Appendice C: Aggiornamenti dei connettori](#migrating-version-50-appendix-connector)
+ [Appendice D: Aggiornamenti di formato a tabella aperta](#migrating-version-50-appendix-open-table-formats)
Le seguenti modifiche si applicano alle versioni dei connettori o dei driver identificate nelle appendici di Glue 5.0.
**Amazon Redshift**
Nota le seguenti modifiche:
+ Aggiunge il supporto per i nomi di tabella in tre parti per consentire al connettore di interrogare le tabelle di condivisione dei dati di Redshift.
+ Corregge la mappatura di Spark `ShortType` per utilizzare Redshift `SMALLINT` anziché `INTEGER` per adattarla meglio alla dimensione prevista dei dati.
+ È stato aggiunto il supporto per Custom Cluster Names (CNAME) per Amazon Redshift serverless.
**Apache Hudi**
Nota le seguenti modifiche:
+ Supporta l'indice di livello record.
+ Supporta la generazione automatica di chiavi di registrazione. Ora non è necessario specificare il campo della chiave di registrazione.
**Apache Iceberg**
Nota le seguenti modifiche:
+ Supporta il controllo granulare degli accessi con. AWS Lake Formation
+ Supporta la ramificazione e il tagging, che sono riferimenti denominati a snapshot con cicli di vita indipendenti.
+ È stata aggiunta una procedura di visualizzazione del registro delle modifiche che genera una vista che contiene le modifiche apportate a una tabella in un periodo specificato o tra snapshot specifici.
**Delta Lake**
Nota le seguenti modifiche:
+ Supporta Delta Universal Format (UniForm) che consente un accesso senza interruzioni tramite Apache Iceberg e Apache Hudi.
+ Supporta i vettori di cancellazione che implementano un Merge-on-Read paradigma.
**AzureCosmos**
Nota le seguenti modifiche:
+ È stato aggiunto il supporto per chiavi di partizione gerarchiche.
+ È stata aggiunta l'opzione per utilizzare lo schema personalizzato con StringType (raw json) per una proprietà annidata.
+ È stata aggiunta l'opzione di configurazione `spark.cosmos.auth.aad.clientCertPemBase64` per consentire l'utilizzo dell'autenticazione SPN (ServicePrincipal nome) con certificato anziché il segreto del client.
Per ulteriori informazioni, consulta il [registro delle modifiche del connettore Azure Cosmos DB Spark](https://github.com/Azure/azure-sdk-for-java/blob/main/sdk/cosmos/azure-cosmos-spark_3-2_2-12/CHANGELOG.md).
**Microsoft SQL Server**
Nota le seguenti modifiche:
+ La crittografia TLS è abilita per impostazione predefinita.
+ Quando encrypt = false ma il server richiede la crittografia, il certificato viene convalidato in base all'impostazione della connessione `trustServerCertificate`.
+ `aadSecurePrincipalId` e `aadSecurePrincipalSecret` resi obsoleti.
+ `getAADSecretPrincipalId` API rimossa.
+ È stata aggiunta la risoluzione CNAME quando viene specificato il realm.
**MongoDB**
Nota le seguenti modifiche:
+ Supporto per la modalità micro-batch con Spark Structured Streaming.
+ Supporto per i tipi di dati BSON.
+ È stato aggiunto il supporto per la lettura di più raccolte quando si utilizzano modalità di streaming micro-batch o continuo.
+ Se il nome di una raccolta utilizzata nell'opzione di configurazione `collection` contiene una virgola, Spark Connector la considera come due raccolte diverse. Per risolvere questo problema, è necessario evitare la virgola facendola precedere da una barra rovesciata (\$1).
+ Se il nome di una raccolta utilizzata nell'opzione di `collection` configurazione è “\$1”, Spark Connector la interpreta come una specifica per la scansione di tutte le raccolte. Per risolvere questo problema, è necessario evitare l'asterisco facendolo precedere da una barra rovesciata (\$1).
+ Se il nome di una raccolta utilizzata nell'opzione di configurazione `collection` contiene una barra rovesciata (\$1), Spark Connector considera la barra rovesciata come un carattere di escape, il che potrebbe cambiare il modo in cui interpreta il valore. Per risolvere questo problema, è necessario evitare la barra rovesciata facendola precedere da un'altra barra rovesciata.
Per ulteriori informazioni, consultare il [connettore MongoDB per le note di rilascio di Spark](https://www.mongodb.com/docs/spark-connector/current/release-notes/).
**Snowflake**
Nota le seguenti modifiche:
+ È stato introdotto un nuovo parametro `trim_space` che è possibile utilizzare per rifinire automaticamente i valori delle colonne `StringType` durante il salvataggio in una tabella Snowflake. Default: `false`.
+ Per impostazione predefinita, il parametro `abort_detached_query` è stato disabilitato a livello di sessione.
+ È stato rimosso il requisito del parametro `SFUSER` quando si utilizza OAUTH.
+ È stata rimossa la funzionalità Advanced Query Pushdown. Sono disponibili alternative alla funzionalità. Ad esempio, anziché caricare i dati dalle tabelle Snowflake, gli utenti possono caricare direttamente i dati dalle query SQL di Snowflake.
Per ulteriori informazioni, consultare il [connettore Snowflake per le note di rilascio di Spark](https://docs.snowflake.com/en/release-notes/clients-drivers/spark-connector-2024).
### Appendice A: Aggiornamenti importanti delle dipendenze
Di seguito sono riportati gli aggiornamenti delle dipendenze:
| Dipendenza | Versione 5.0 AWS Glue | Versione in AWS Glue 4.0 | Versione in AWS Glue 3.0 | Versione in AWS Glue 2.0 | Versione in AWS Glue 1.0 |
| --- | --- | --- | --- | --- | --- |
| Java | 17 | 8 | 8 | 8 | 8 |
| Spark | 3.5.4 | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.4.1 | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2,12,18 | 2,12 | 2,12 | 2.11 | 2.11 |
| Jackson | 2,15,2 | 2,12 | 2,12 | 2.11 | 2.11 |
| Hive | 2.3.9-amzn-4 | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2,69,0 | 2,54,0 | 2,46,0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 3.7.0-M11 | 36.6 | 3.5.x | 3.5.x |
| Arrow | 12,0,1 | 7,0,0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS Glue Client Data Catalog | 4.5.0 | 3.7.0 | 3.0.0 | 1.10.0 | N/D |
| AWS SDK per Java | 2.29.52 | 1.12 | 1.12 | | |
| Python | 3,11 | 3,10 | 3.7 | 2.7 e 3.6 | 2.7 e 3.6 |
| Boto | 1,34,131 | 1,26 | 1,18 | 1.12 | N/D |
| Connettore EMR DynamoDB | 5.6.0 | 4,16,0 | | | |
### Appendice B: aggiornamenti dei driver JDBC
Di seguito sono riportati gli aggiornamenti dei driver JDBC:
| Driver | Versione del driver JDBC nella versione 5.0 AWS Glue | Versione del driver JDBC nella versione 4.0 AWS Glue | Versione del driver JDBC nella versione 3.0 AWS Glue | Versione del driver JDBC nelle versioni precedenti AWS Glue |
| --- | --- | --- | --- | --- |
| MySQL | 8.0.33 | 8.0.23 | 8.0.23 | 5.1 |
| Microsoft SQL Server | 10,2,0 | 9,40 | 7,0,0 | 6.1,0 |
| Database Oracle | 23,3,023,09 | 21,7 | 21,1 | 11.2 |
| PostgreSQL | 42,7,3 | 42,36 | 4,2,18 | 42,1,0 |
| Amazon Redshift | redshift-jdbc42-2.1.0.29 | redshift-jdbc42-2.1.0.16 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 |
| SAP Hana | 2,20,17 | 2,17,12 | | |
| Teradata | 20,00,00,33 | 20,00,00,06 | | |
### Appendice C: Aggiornamenti dei connettori
Di seguito sono riportati gli aggiornamenti dei connettori:
| Driver | Versione del connettore in 5.0 AWS Glue | Versione del connettore in AWS Glue 4.0 | Versione del connettore in AWS Glue 3.0 |
| --- | --- | --- | --- |
| Connettore EMR DynamoDB | 5.6.0 | 4.16.0 | |
| Amazon Redshift | 64,0 | 6.1.3 | |
| OpenSearch | 1.2.0 | 1.0.1 | |
| MongoDB | 10.3,0 | 10.0.4 | 3.0.0 |
| Snowflake | 3.0.0 | 2.12.0 | |
| Google BigQuery | 0.32.2 | 0,32,2 | |
| AzureCosmos | 4,33,0 | 42,0 | |
| AzureSQL | 1.3.0 | 1.3.0 | |
| Vertica | 33,5 | 3.3.5 | |
### Appendice D: Aggiornamenti di formato a tabella aperta
Di seguito sono riportati gli aggiornamenti di formato a tabella aperta:
| OTF | Versione del connettore nella versione 5.0 AWS Glue | Versione del connettore in AWS Glue 4.0 | Versione del connettore in AWS Glue 3.0 |
| --- | --- | --- | --- |
| Hudi | 0.15.0 | 0.12.1 | 0,10,1 |
| Delta Lake | 3.3.0 | 2.1.0 | 1.0.0 |
| Iceberg | 1.7.1 | 1.0.0 | 0.13.1 |
# Migrazione AWS Glue per i job Spark alla versione 4.0 AWS Glue
Questo argomento descrive le modifiche tra AWS Glue le versioni 0.9, 1.0, 2.0 e 3.0 per consentire la migrazione delle applicazioni Spark e dei lavori ETL alla 4.0. AWS Glue Descrive inoltre le funzionalità della AWS Glue versione 4.0 e i vantaggi del suo utilizzo.
Per utilizzare questa funzionalità con i tuoi lavori AWS Glue ETL, scegli `Glue version` quando **4.0** crei i tuoi lavori.
**Topics**
+ [Nuove caratteristiche supportate](#migrating-version-40-features)
+ [Azioni AWS Glue per migrare alla versione 4.0](#migrating-version-40-actions)
+ [Elenco di controllo della migrazione](#migrating-version-40-checklist)
+ [Migrazione dalla 3.0 alla 4.0 AWS Glue AWS Glue](#migrating-version-40-from-30)
+ [Migrazione da 2.0 a 4.0 AWS Glue AWS Glue](#migrating-version-40-from-20)
+ [Migrazione da AWS Glue 1.0 a 4.0 AWS Glue](#migrating-version-40-from-10)
+ [Migrazione da 0.9 a 4.0 AWS Glue AWS Glue](#migrating-version-40-from-09)
+ [Migrazione di connettori e driver JDBC per 4.0 AWS Glue](#migrating-version-40-connector-driver-migration)
+ [Appendice A: Aggiornamenti importanti delle dipendenze](#migrating-version-40-appendix-dependencies)
+ [Appendice B: aggiornamenti dei driver JDBC](#migrating-version-40-appendix-jdbc-driver)
+ [Appendice C: Aggiornamenti dei connettori](#migrating-version-40-appendix-connector)
## Nuove caratteristiche supportate
Questa sezione descrive le nuove funzionalità e i vantaggi della AWS Glue versione 4.0.
+ Si basa su Apache Spark 3.3.0, ma presenta ottimizzazioni in AWS Glue e Amazon EMR, come esecuzioni adattive delle query, lettori vettorizzati e shuffle e coalescenza delle partizioni ottimizzati.
+ Driver JDBC aggiornati per tutte le fonti AWS Glue native tra cui MySQL, Microsoft SQL Server, Oracle, PostgreSQL, MongoDB e le librerie e dipendenze Spark aggiornate introdotte da Spark 3.3.0.
+ Aggiornato con un nuovo connettore Amazon Redshift e driver JDBC.
+ Accesso Amazon S3 ottimizzato con EMRFS aggiornato e committer di output ottimizzati per Amazon S3 abilitati per impostazione predefinita.
+ Accesso ottimizzato al catalogo dati con indici delle partizioni, predicati pushdown, elenco delle partizioni e un client metastore Hive aggiornato.
+ Integrazione con Lake Formation per tabelle di catalogo governate con filtraggio a livello di cella e transazioni data lake.
+ Ridotta la latenza di avvio per migliorare i tempi complessivi di completamento dei processi e dell'interattività.
+ I processi Spark vengono fatturati in incrementi di 1 secondo con una durata minima di fatturazione 10 volte inferiore, da un minimo di 10 minuti a un minimo di 1 minuto.
+ Supporto nativo per framework open data lake con Apache Hudi, Delta Lake e Apache Iceberg.
+ Supporto nativo per il Cloud Shuffle Storage Plugin basato su Amazon S3 (un plug-in Apache Spark) per utilizzare Amazon S3 per lo shuffling e la capacità di archiviazione elastica.
**Miglioramenti principali da Spark 3.1.1 a Spark 3.3.0**
Nota i seguenti miglioramenti:
+ Filtraggio di runtime a livello di riga ([SPARK-32268](https://issues.apache.org/jira/browse/SPARK-32268)).
+ Miglioramenti ANSI ([SPARK-38860](https://issues.apache.org/jira/browse/SPARK-38860)).
+ Miglioramenti ai messaggi di errore ([SPARK-38781](https://issues.apache.org/jira/browse/SPARK-38781)).
+ Supporto dei tipi complessi per il lettore vettorializzato Parquet ([SPARK-34863](https://issues.apache.org/jira/browse/SPARK-34863)).
+ Supporto di metadati di file nascosti per Spark SQL ([SPARK-37273](https://issues.apache.org/jira/browse/SPARK-37273)).
+ Fornisci [un](https://issues.apache.org/jira/browse/SPARK-37443) profiler per Python/Pandas UDFs (SPARK-37443).
+ Presenta Trigger. AvailableNow [per eseguire query di streaming come Trigger.Once in più batch (SPARK-36533).](https://issues.apache.org/jira/browse/SPARK-36533)
+ Funzionalità di pushdown Datasource V2 più complete ([SPARK-38788](https://issues.apache.org/jira/browse/SPARK-38788)).
+ Migrazione da log4j 1 a log4j 2 ([SPARK-37814](https://issues.apache.org/jira/browse/SPARK-37814)).
**Altre modifiche importanti**
Nota le seguenti modifiche:
+ Modifiche importanti
+ [Elimina i riferimenti al supporto per Python 3.6 nei documenti e Python/docs (SPARK-36977).](https://issues.apache.org/jira/browse/SPARK-36977)
+ Rimuove l'hack di tuple specificate sostituendo il pickle integrato con cloudpickle ([SPARK-32079](https://issues.apache.org/jira/browse/SPARK-32079)).
+ Porta la versione minima di Pandas a 1.0.5 ([SPARK-37465](https://issues.apache.org/jira/browse/SPARK-37465)).
## Azioni AWS Glue per migrare alla versione 4.0
Per i processi esistenti, modifica la `Glue version` dalla versione precedente a `Glue 4.0` nella configurazione del processo.
+ In AWS Glue Studio, scegli `Glue 4.0 - Supports Spark 3.3, Scala 2, Python 3` in`Glue version`.
+ Nell'API, scegli **4.0** nel parametro `GlueVersion` nell'operazione API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-UpdateJob).
Per i nuovi processi, scegli `Glue 4.0` al momento della creazione.
+ Nella console, scegli `Spark 3.3, Python 3 (Glue Version 4.0) or Spark 3.3, Scala 2 (Glue Version 3.0)` in `Glue version`.
+ In AWS Glue Studio, scegli `Glue 4.0 - Supports Spark 3.3, Scala 2, Python 3` in`Glue version`.
+ Nell'API, scegli **4.0** nel parametro `GlueVersion` nell'operazione API [https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html#aws-glue-api-jobs-job-CreateJob).
Per visualizzare i registri degli eventi di Spark della AWS Glue versione 4.0 della versione AWS Glue 2.0 o precedente, [avvia un server di cronologia Spark aggiornato per AWS Glue 4.0](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-history.html) utilizzando o Docker. CloudFormation
## Elenco di controllo della migrazione
+ Le librerie Python esterne del processo dipendono da Python 2.7/3.6?
+ Aggiorna le librerie dipendenti da Python 2.7/3.6 a Python 3.10, poiché Spark 3.3.0 ha rimosso il supporto per Python 2.7 e 3.6.
## Migrazione dalla 3.0 alla 4.0 AWS Glue AWS Glue
Nota le seguenti modifiche durante la migrazione:
+ Tutti i parametri di lavoro e le funzionalità principali esistenti nella AWS Glue versione 3.0 esisteranno nella AWS Glue versione 4.0.
+ AWS Glue 3.0 utilizza Spark 3.1.1 ottimizzato per Amazon EMR e 4.0 AWS Glue utilizza Spark 3.3.0 ottimizzato per Amazon EMR.
Diverse modifiche di Spark da sole potrebbero richiedere la revisione degli script per garantire che non si faccia riferimento alle funzionalità rimosse.
+ AWS Glue 4.0 include anche un aggiornamento a EMRFS e Hadoop. Per la versione specifica, consulta [Appendice A: Aggiornamenti importanti delle dipendenze](#migrating-version-40-appendix-dependencies).
+ L' AWS SDK fornito nei job ETL è ora aggiornato da 1.11 a 1.12.
+ Tutti i processi Python utilizzeranno la versione 3.10 di Python. In precedenza, Python 3.7 veniva utilizzato nella 3.0. AWS Glue
Di conseguenza, alcuni pymodules forniti out-of-the-box da AWS Glue vengono aggiornati.
+ Log4j è stato aggiornato a Log4j2.
+ Per informazioni sul percorso di migrazione di Log4j2, consulta la [documentazione di Log4j](https://logging.apache.org/log4j/2.x/manual/migration.html#Log4j2API).
+ È invece necessario rinominare qualsiasi file log4j.properties personalizzato come file log4j2.properties, con le proprietà log4j2 appropriate.
+ Per la migrazione di connettori specifici, consulta [Migrazione di connettori e driver JDBC per 4.0 AWS Glue](#migrating-version-40-connector-driver-migration).
+ L' AWS Encryption SDK viene aggiornato da 1.x a 2.x. AWS Glue sono interessati i lavori che utilizzano configurazioni AWS Glue di sicurezza e i lavori dipendenti dalla dipendenza di AWS Encryption SDK fornita in fase di esecuzione. Consulta le istruzioni per AWS Glue la migrazione dei job.
È possibile aggiornare in sicurezza un lavoro AWS Glue 2.0/3.0 a un lavoro AWS Glue 4.0 perché AWS Glue 2.0/3.0 contiene già la versione bridge AWS Encryption SDK.
Consulta la documentazione relativa alla migrazione di Spark:
+ [Aggiornamento da Spark SQL 3.1 a 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Aggiornamento da Spark SQL 3.2 a 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
## Migrazione da 2.0 a 4.0 AWS Glue AWS Glue
Nota le seguenti modifiche durante la migrazione:
**Nota**
Per i passaggi di migrazione relativi alla AWS Glue versione 3.0, consulta[Migrazione dalla 3.0 alla 4.0 AWS Glue AWS Glue](#migrating-version-40-from-30).
+ Tutti i parametri di lavoro e le funzionalità principali esistenti nella AWS Glue versione 2.0 esisteranno nella AWS Glue versione 4.0.
+ Il committer ottimizzato per EMRFS S3 per la scrittura di dati Parquet in Amazon S3 è abilitato per impostazione predefinita dalla versione 3.0. AWS Glue Tuttavia, puoi disabilitarlo impostando `--enable-s3-parquet-optimized-committer` a `false`.
+ AWS Glue 2.0 utilizza Spark 2.4 open source e AWS Glue 4.0 utilizza Spark 3.3.0 ottimizzato per Amazon EMR.
+ Diverse modifiche di Spark da sole potrebbero richiedere la revisione degli script per garantire che non si faccia riferimento alle funzionalità rimosse.
+ Ad esempio, Spark 3.3.0 non abilita UDFs Scala-untyped, ma Spark 2.4 li consente.
+ L' AWS SDK fornito nei job ETL è ora aggiornato da 1.11 a 1.12.
+ AWS Glue 4.0 include anche un aggiornamento a EMRFS, driver JDBC aggiornati e inclusioni di ottimizzazioni aggiuntive su Spark stesso fornite da. AWS Glue
+ Scala è stato aggiornato da 2.11 a 2.12 e Scala 2.12 non è compatibile con Scala 2.11.
+ Python 3.10 è la versione predefinita utilizzata per gli script Python mentre AWS Glue 2.0 utilizzava solo Python 3.7 e 2.7.
+ Python 2.7 non è supportato con Spark 3.3.0. Qualsiasi lavoro che richieda Python 2 nella configurazione del lavoro avrà esito negativo con un. IllegalArgumentException
+ Un nuovo meccanismo di installazione di moduli Python aggiuntivi è disponibile a partire dalla AWS Glue versione 2.0.
+ Diversi aggiornamenti delle dipendenze, evidenziati in [Appendice A: Aggiornamenti importanti delle dipendenze](#migrating-version-40-appendix-dependencies).
+ Qualsiasi file JAR aggiuntivo fornito nei job AWS Glue 2.0 esistenti potrebbe creare dipendenze in conflitto perché sono stati effettuati aggiornamenti in diverse dipendenze dalla versione 4.0 alla 2.0. È possibile evitare conflitti tra percorsi di classe nella AWS Glue versione 4.0 con il parametro job. `--user-jars-first` AWS Glue
+ AWS Glue 4.0 utilizza Spark 3.3. A partire da Spark 3.1, c'è stato un cambiamento nel comportamento dei file loading/saving di parquet timestamps from/to . Per ulteriori dettagli, consulta [Aggiornamento da Spark SQL 3.0 a 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31).
Si consiglia di impostare i seguenti parametri quando si tratta di dati che contengono reading/writing colonne con timestamp. L'impostazione di questi parametri può risolvere il problema di incompatibilità del calendario che si verifica durante l'aggiornamento da Spark 2 a Spark 3, sia per AWS Glue Dynamic Frame che per Spark Data Frame. Utilizzare l'opzione CORRECTED per leggere il valore datetime così com'è e l'opzione LEGACY per cambiare la base dei valori datetime in relazione alla differenza di calendario durante la lettura.
```
- Key: --conf
- Value: spark.sql.legacy.parquet.int96RebaseModeInRead=[CORRECTED|LEGACY] --conf spark.sql.legacy.parquet.int96RebaseModeInWrite=[CORRECTED|LEGACY] --conf spark.sql.legacy.parquet.datetimeRebaseModeInRead=[CORRECTED|LEGACY]
```
+ Per la migrazione di connettori specifici, consulta [Migrazione di connettori e driver JDBC per 4.0 AWS Glue](#migrating-version-40-connector-driver-migration).
+ L' AWS Encryption SDK viene aggiornato da 1.x a 2.x. AWS Glue sono interessati i lavori che utilizzano configurazioni AWS Glue di sicurezza e i lavori dipendenti dalla dipendenza di AWS Encryption SDK fornita in fase di esecuzione. Consulta queste istruzioni per AWS Glue la migrazione dei job:
+ È possibile aggiornare in sicurezza un lavoro AWS Glue 2.0 a un lavoro AWS Glue 4.0 perché la versione AWS Glue 2.0 contiene già la versione bridge AWS Encryption SDK.
Consulta la documentazione relativa alla migrazione di Spark:
+ [Aggiornamento da Spark SQL 2.4 a 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Aggiornamento da Spark SQL 3.1 a 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Aggiornamento da Spark SQL 3.2 a 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Cambiamenti nel comportamento di Datetime previsti da Spark 3.0.](https://issues.apache.org/jira/browse/SPARK-31408)
## Migrazione da AWS Glue 1.0 a 4.0 AWS Glue
Nota le seguenti modifiche durante la migrazione:
+ AWS Glue 1.0 utilizza Spark 2.4 e AWS Glue 4.0 open source utilizza Spark 3.3.0 ottimizzato per Amazon EMR.
+ Diverse modifiche di Spark da sole potrebbero richiedere la revisione degli script per garantire che non si faccia riferimento alle funzionalità rimosse.
+ Ad esempio, Spark 3.3.0 non abilita UDFs Scala-untyped, ma Spark 2.4 li consente.
+ Tutti i job della AWS Glue versione 4.0 verranno eseguiti con tempi di avvio notevolmente migliorati. I processi Spark verranno fatturati in incrementi di 1 secondo con una durata minima di fatturazione 10 volte inferiore poiché la latenza di avvio passerà da un massimo di 10 minuti a un massimo di 1 minuto.
+ Il comportamento di registrazione è cambiato in modo significativo nella AWS Glue versione 4.0, Spark 3.3.0 ha un requisito minimo di Log4j2.
+ Diversi aggiornamenti delle dipendenze, descritti nell'appendice.
+ Scala è stato inoltre aggiornato da 2.11 a 2.12 e Scala 2.12 non è compatibile con Scala 2.11.
+ Python 3.10 è anche la versione di predefinita utilizzata per gli script Python, mentre AWS Glue 0.9 utilizzava solo Python 2.
Python 2.7 non è supportato con Spark 3.3.0. Qualsiasi lavoro che richieda Python 2 nella configurazione del lavoro avrà esito negativo con un. IllegalArgumentException
+ Un nuovo meccanismo di installazione di moduli Python aggiuntivi tramite pip è disponibile dalla versione 2.0. AWS Glue Per ulteriori informazioni, consulta [Installazione di moduli Python aggiuntivi con pip in AWS Glue 2.0\$1](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-python-libraries.html#addl-python-modules-support).
+ AWS Glue 4.0 non funziona su Apache YARN, quindi le impostazioni YARN non si applicano.
+ AWS Glue 4.0 non dispone di un Hadoop Distributed File System (HDFS).
+ Qualsiasi file JAR aggiuntivo fornito nei job AWS Glue 1.0 esistenti potrebbe creare dipendenze in conflitto perché nella versione 4.0 sono stati effettuati aggiornamenti in diverse dipendenze dalla versione 1.0. Per evitare questo problema, abilitiamo la AWS Glue versione 4.0 con il parametro `--user-jars-first` AWS Glue job di default.
+ AWS Glue 4.0 supporta il ridimensionamento automatico. Pertanto, la ExecutorAllocationManager metrica sarà disponibile quando la scalabilità automatica è abilitata.
+ Nei lavori della AWS Glue versione 4.0, si specifica il numero di lavoratori e il tipo di lavoratore, ma non si specifica a. `maxCapacity`
+ AWS Glue La versione 4.0 non supporta ancora le trasformazioni dell'apprendimento automatico.
+ Per la migrazione di connettori specifici, consulta [Migrazione di connettori e driver JDBC per 4.0 AWS Glue](#migrating-version-40-connector-driver-migration).
+ L' AWS Encryption SDK viene aggiornato da 1.x a 2.x. AWS Glue sono interessati i lavori che utilizzano configurazioni AWS Glue di sicurezza e i lavori dipendenti dalla dipendenza di AWS Encryption SDK fornita in fase di esecuzione. Consulta queste istruzioni per AWS Glue la migrazione dei job.
+ Non è possibile migrare direttamente un lavoro da AWS Glue 0,9/1,0 a un lavoro AWS Glue 4.0. Questo perché quando si esegue l'aggiornamento diretto alla versione 2.x o successiva e si abilitano immediatamente tutte le nuove funzionalità, AWS Encryption SDK non sarà in grado di decrittografare il testo cifrato crittografato con le versioni precedenti di Encryption SDK. AWS
+ Per un aggiornamento sicuro, consigliamo innanzitutto di migrare a un AWS Glue job 2.0/3.0 che contenga la versione bridge di Encryption SDK. AWS Esegui il processo una volta per utilizzare la versione bridge Encryption SDK AWS .
+ Al termine, è possibile migrare in sicurezza il job AWS Glue 2.0/3.0 a 4.0. AWS Glue
Consulta la documentazione relativa alla migrazione di Spark:
+ [Aggiornamento da Spark SQL 2.4 a 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Aggiornamento da Spark SQL 3.0 a 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31)
+ [Aggiornamento da Spark SQL 3.1 a 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Aggiornamento da Spark SQL 3.2 a 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Cambiamenti nel comportamento di Datetime previsti da Spark 3.0.](https://issues.apache.org/jira/browse/SPARK-31408)
## Migrazione da 0.9 a 4.0 AWS Glue AWS Glue
Nota le seguenti modifiche durante la migrazione:
+ AWS Glue 0.9 utilizza Spark 2.2.1 e 4.0 open source AWS Glue utilizza Spark 3.3.0 ottimizzato per Amazon EMR.
+ Diverse modifiche di Spark da sole potrebbero richiedere la revisione degli script per garantire che non si faccia riferimento alle funzionalità rimosse.
+ Ad esempio, Spark 3.3.0 non abilita Scala-untyped, ma Spark 2.2 li consente. UDFs
+ Tutti i job della AWS Glue versione 4.0 verranno eseguiti con tempi di avvio notevolmente migliorati. I processi Spark verranno fatturati in incrementi di 1 secondo con una durata minima di fatturazione 10 volte inferiore poiché la latenza di avvio passerà da un massimo di 10 minuti a un massimo di 1 minuto.
+ Il comportamento di registrazione è cambiato in modo significativo rispetto alla AWS Glue versione 4.0, Spark 3.3.0 ha un requisito minimo di Log4j2 come indicato qui (\$1 -32-to-33). https://spark.apache.org/docs/latest/core-migration-guide.html upgrading-from-core
+ Diversi aggiornamenti delle dipendenze, descritti nell'appendice.
+ Scala è stato inoltre aggiornato da 2.11 a 2.12 e Scala 2.12 non è compatibile con Scala 2.11.
+ Python 3.10 è anche la versione di predefinita utilizzata per gli script Python, mentre AWS Glue 0.9 utilizzava solo Python 2.
+ Python 2.7 non è supportato con Spark 3.3.0. Qualsiasi lavoro che richieda Python 2 nella configurazione del lavoro avrà esito negativo con un. IllegalArgumentException
+ È disponibile un nuovo meccanismo di installazione di moduli Python aggiuntivi tramite pip.
+ AWS Glue 4.0 non funziona su Apache YARN, quindi le impostazioni YARN non si applicano.
+ AWS Glue 4.0 non dispone di un Hadoop Distributed File System (HDFS).
+ Qualsiasi file JAR aggiuntivo fornito nei job AWS Glue 0.9 esistenti potrebbe creare dipendenze in conflitto perché nella versione 3.0 sono stati effettuati aggiornamenti in diverse dipendenze dalla versione 0.9. È possibile evitare conflitti tra percorsi di classe nella AWS Glue versione 3.0 con il parametro job. `--user-jars-first` AWS Glue
+ AWS Glue 4.0 supporta il ridimensionamento automatico. Pertanto, la ExecutorAllocationManager metrica sarà disponibile quando la scalabilità automatica è abilitata.
+ Nei lavori della AWS Glue versione 4.0, si specifica il numero di lavoratori e il tipo di lavoratore, ma non si specifica a. `maxCapacity`
+ AWS Glue La versione 4.0 non supporta ancora le trasformazioni dell'apprendimento automatico.
+ Per la migrazione di connettori specifici, consulta [Migrazione di connettori e driver JDBC per 4.0 AWS Glue](#migrating-version-40-connector-driver-migration).
+ L' AWS Encryption SDK viene aggiornato da 1.x a 2.x. AWS Glue sono interessati i lavori che utilizzano configurazioni AWS Glue di sicurezza e i lavori dipendenti dalla dipendenza di AWS Encryption SDK fornita in fase di esecuzione. Consulta queste istruzioni per AWS Glue la migrazione dei job.
+ Non è possibile migrare direttamente un lavoro da AWS Glue 0,9/1,0 a un lavoro AWS Glue 4.0. Questo perché quando si esegue l'aggiornamento diretto alla versione 2.x o successiva e si abilitano immediatamente tutte le nuove funzionalità, AWS Encryption SDK non sarà in grado di decrittografare il testo cifrato crittografato con le versioni precedenti di Encryption SDK. AWS
+ Per un aggiornamento sicuro, consigliamo innanzitutto di migrare a un AWS Glue job 2.0/3.0 che contenga la versione bridge di Encryption SDK. AWS Esegui il processo una volta per utilizzare la versione bridge Encryption SDK AWS .
+ Al termine, è possibile migrare in sicurezza il job AWS Glue 2.0/3.0 a 4.0. AWS Glue
Consulta la documentazione relativa alla migrazione di Spark:
+ [Aggiornamento da Spark SQL 2.2 a 2.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-22-to-23)
+ [Aggiornamento da Spark SQL 2.3 a 2.4](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-23-to-24)
+ [Aggiornamento da Spark SQL 2.4 a 3.0](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-24-to-30)
+ [Aggiornamento da Spark SQL 3.0 a 3.1](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-30-to-31)
+ [Aggiornamento da Spark SQL 3.1 a 3.2](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-31-to-32)
+ [Aggiornamento da Spark SQL 3.2 a 3.3](https://spark.apache.org/docs/latest/sql-migration-guide.html#upgrading-from-spark-sql-32-to-33)
+ [Cambiamenti nel comportamento di Datetime previsti da Spark 3.0.](https://issues.apache.org/jira/browse/SPARK-31408)
## Migrazione di connettori e driver JDBC per 4.0 AWS Glue
Per le versioni dei connettori JDBC e data lake che sono state aggiornate, consulta:
+ [Appendice B: aggiornamenti dei driver JDBC](#migrating-version-40-appendix-jdbc-driver)
+ [Appendice C: Aggiornamenti dei connettori](#migrating-version-40-appendix-connector)
### Hudi
+ Miglioramenti al supporto Spark SQL:
+ Tramite il comando `Call Procedure`, viene aggiunto il supporto per l'aggiornamento, il downgrade, il bootstrap, la pulizia e la riparazione. In Spark SQL è possibile utilizzare la sintassi `Create/Drop/Show/Refresh Index`.
+ È stato colmato un divario di prestazioni tra l'utilizzo tramite Spark DataSource e Spark SQL. Le scritture di Datasource in passato erano più veloci di SQL.
+ Tutti i generatori di chiavi integrati implementano operazioni API specifiche di Spark più performanti.
+ Ha sostituito la trasformazione UDF nelle `insert` operazioni di massa con le trasformazioni RDD per ridurre i costi di utilizzo. SerDe
+ Spark SQL con Hudi richiede la specifica di una `primaryKey` da parte di `tblproperites` o più opzioni nell'istruzione SQL. Per le operazioni di aggiornamento ed eliminazione, è necessario anche `preCombineField`.
+ Qualsiasi tabella Hudi creata prima della versione 0.10.0 senza una `primaryKey` deve essere creata nuovamente con un campo `primaryKey` a partire dalla versione 0.10.0.
### PostgreSQL
+ Sono state risolte diverse vulnerabilità (). CVEs
+ Java 8 è supportato in modo nativo.
+ Se il processo utilizza array di array, ad eccezione degli array di byte, questo scenario può essere trattato come array multidimensionali.
### MongoDB
+ Il connettore MongoDB corrente supporta Spark versione 3.1 o versione successiva e MongoDB versione 4.0 o successiva.
+ A causa dell'aggiornamento del connettore, alcuni nomi di proprietà sono cambiati. Ad esempio, il nome della proprietà URI è stato modificato in `connection.uri`. Per ulteriori informazioni sulle opzioni correnti, consulta il [blog di MongoDB Spark Connector](https://www.mongodb.com/docs/spark-connector/current/configuration/).
+ L'utilizzo di MongoDB 4.0 ospitato da Amazon DocumentDB presenta alcune differenze funzionali. Per ulteriori informazioni, consulta i seguenti argomenti:
+ [Differenze funzionali: Amazon DocumentDB e MongoDB](https://docs.aws.amazon.com/documentdb/latest/developerguide/functional-differences.html)
+ [ APIsMongoDB, operazioni e tipi di dati supportati](https://docs.aws.amazon.com/documentdb/latest/developerguide/mongo-apis.html).
+ L'opzione "partitioner" è limitata a `ShardedPartitioner`, `PaginateIntoPartitionsPartitioner` e `SinglePartitionPartitioner`. Non può utilizzare `SamplePartitioner` e `PaginateBySizePartitioner` predefiniti per Amazon DocumentDB perché l'operatore stage non supporta l'API MongoDB. Per ulteriori informazioni, consulta [ APIsMongoDB, operazioni e tipi di dati supportati](https://docs.aws.amazon.com/documentdb/latest/developerguide/mongo-apis.html).
### Delta Lake
+ Delta Lake ora supporta i [viaggi nel tempo in SQL](https://docs.delta.io/2.1.0/delta-batch.html#query-an-older-snapshot-of-a-table-time-travel) per interrogare facilmente i dati più vecchi. Con questo aggiornamento, il viaggio nel tempo è ora disponibile sia in Spark SQL che tramite l'API. DataFrame È stato aggiunto il supporto per la versione corrente di TIMESTAMP in SQL.
+ [Spark 3.3 introduce Trigger. AvailableNow](https://issues.apache.org/jira/browse/SPARK-36533)per eseguire query in streaming come equivalente a quelle in batch`Trigger.Once`. Questo supporto è disponibile anche quando si utilizzano le tabelle Delta come fonte di streaming.
+ Supporto per SHOW COLUMNS per restituire l'elenco delle colonne in una tabella.
+ Support per [DESCRIVE DETAIL](https://docs.delta.io/2.1.0/delta-utility.html#retrieve-delta-table-details) nelle API Scala e Python DeltaTable . Recupera informazioni dettagliate su una tabella Delta utilizzando l' DeltaTable API o Spark SQL.
+ Supporto per la restituzione di parametri operativi dai comandi SQL [Delete](https://github.com/delta-io/delta/pull/1328), [Merge](https://github.com/delta-io/delta/pull/1327) e [Update](https://github.com/delta-io/delta/pull/1331). In precedenza questi comandi SQL restituivano un valore vuoto DataFrame, ora restituiscono un valore DataFrame con metriche utili sull'operazione eseguita.
+ Ottimizza i miglioramenti in termini di prestazioni:
+ Imposta l'opzione di configurazione `spark.databricks.delta.optimize.repartition.enabled=true` in modo da utilizzare `repartition(1)` anziché `coalesce(1)` nel comando Optimize per migliorare le prestazioni durante la compattazione di numerosi file di piccole dimensioni.
+ [Prestazioni migliorate](https://github.com/delta-io/delta/pull/1315) grazie a un approccio basato su code per parallelizzare i lavori di compattazione.
+ Altre modifiche importanti:
+ [Supporto per l'utilizzo di variabili](https://github.com/delta-io/delta/issues/1267) nei comandi VACUUM e OPTIMIZE SQL.
+ Miglioramenti per CONVERT TO DELTA con tabelle di catalogo che includono:
+ [Completamento automatico dello schema delle partizioni](https://github.com/delta-io/delta/commit/18d4d12ed06f973006501f6c39c8785db51e2b1f) dal catalogo quando non è fornito.
+ [Uso delle informazioni sulle partizioni](https://github.com/delta-io/delta/commit/ebff29904f3ababb889897343f8f8f7a010a1f71) dal catalogo per trovare i file di dati da salvare invece di eseguire una scansione completa della directory. Invece di salvare tutti i file di dati nella directory delle tabelle, verranno salvati solo i file di dati nelle directory delle partizioni attive.
+ [Supporto per le letture batch di Change Data Feed (CDF)](https://github.com/delta-io/delta/issues/1349) sulle tabelle abilitate alla mappatura delle colonne quando DROP COLUMN e RENAME COLUMN non sono stati utilizzati. Per ulteriori informazioni, consulta la [documentazione di Delta Lake](https://docs.delta.io/2.1.0/delta-change-data-feed.html#known-limitations).
+ [Miglioramento delle prestazioni dei comandi di aggiornamento](https://github.com/delta-io/delta/pull/1202) abilitando l'eliminazione dello schema nel primo passaggio.
### Apache Iceberg
+ Sono stati aggiunti diversi [miglioramenti delle prestazioni](https://iceberg.apache.org/releases/#performance-improvements) per la pianificazione delle scansioni e le query Spark.
+ È stato aggiunto un client di catalogo REST comune che utilizza i commit basati sulle modifiche per risolvere i conflitti di commit lato del servizio.
+ La sintassi `AS OF` per le query SQL relative ai viaggi temporali è supportata.
+ È stato aggiunto merge-on-read il supporto per le query MERGE e UPDATE.
+ È stato aggiunto il supporto per riscrivere le partizioni utilizzando l'ordine Z.
+ Sono state aggiunte una specifica e un'implementazione per Puffin, un formato per statistiche di grandi dimensioni e blob di indici, come [schizzi Theta](https://datasketches.apache.org/docs/Theta/InverseEstimate.html) o filtri bloom.
+ Sono state aggiunte nuove interfacce per il consumo incrementale dei dati (scansioni di aggiunta e log delle modifiche).
+ È stato aggiunto il supporto per operazioni di massa e letture a intervalli alle interfacce FileIO.
+ Sono state aggiunte altre tabelle di metadati per mostrare i file di eliminazione nella struttura dei metadati.
+ Il comportamento della tabella di eliminazione è cambiato. In Iceberg 0.13.1, l'esecuzione di `DROP TABLE` rimuove la tabella dal catalogo e ne elimina anche il contenuto. In Iceberg 1.0.0, `DROP TABLE` rimuove solo la tabella dal catalogo. Per eliminare il contenuto della tabella, utilizza `DROP TABLE PURGE`.
+ Le letture vettorializzate in Parquet sono abilitate per impostazione predefinita in Iceberg 1.0.0. Se desideri disabilitare le letture vettorializzate, imposta `read.parquet.vectorization.enabled` su `false`.
### Oracle
Le modifiche sono di lieve entità.
### MySQL
Le modifiche sono di lieve entità.
### Amazon Redshift
AWS Glue 4.0 presenta un nuovo connettore Amazon Redshift con un nuovo driver JDBC. Per informazioni sui miglioramenti e su come migrare dalle versioni precedenti, consulta. AWS Glue [Connessioni Redshift](aws-glue-programming-etl-connect-redshift-home.md)
## Appendice A: Aggiornamenti importanti delle dipendenze
Di seguito sono riportati gli aggiornamenti delle dipendenze:
| Dipendenza | Versione in 4.0 AWS Glue | Versione in AWS Glue 3.0 | Versione in AWS Glue 2.0 | Versione in AWS Glue 1.0 |
| --- | --- | --- | --- | --- |
| Spark | 3.3.0-amzn-1 | 3.1.1-amzn-0 | 2.4.3 | 2.4.3 |
| Hadoop | 3.3.3-amzn-0 | 3.2.1-amzn-3 | 2.8.5-amzn-5 | 2.8.5-amzn-1 |
| Scala | 2.12 | 2,12 | 2.11 | 2.11 |
| Jackson | 2,13,3 | 2.10.x | 2.7.x | 2.7.x |
| Hive | 2.3.9-amzn-2 | 2.3.7-amzn-4 | 1.2 | 1.2 |
| EMRFS | 2,54,0 | 2,46,0 | 2.38.0 | 2.30.0 |
| Json4s | 3.7.0-M11 | 36.6 | 3.5.x | 3.5.x |
| Arrow | 7,0,0 | 2.0.0 | 0.10.0 | 0.10.0 |
| AWS Glue Client Data Catalog | 3.7.0 | 3.0.0 | 1.10.0 | N/D |
| Python | 3.10 | 3.7 | 2.7 e 3.6 | 2.7 e 3.6 |
| Boto | 1,26 | 1,18 | 1.12 | N/D |
## Appendice B: aggiornamenti dei driver JDBC
Di seguito sono riportati gli aggiornamenti dei driver JDBC:
| Driver | Versione del driver JDBC nelle versioni precedenti AWS Glue | Versione del driver JDBC nella versione 3.0 AWS Glue | Versione del driver JDBC nella versione 4.0 AWS Glue |
| --- | --- | --- | --- |
| MySQL | 5.1 | 8.0.23 | 8.0.23 |
| Microsoft SQL Server | 6.1.0 | 7,0,0 | 9,40 |
| Database Oracle | 11.2 | 21,1 | 21,7 |
| PostgreSQL | 42,1,0 | 4,2,18 | 42,36 |
| MongoDB | 2.0.0 | 4.0.0 | 4,7,2 |
| Amazon Redshift | redshift-jdbc41-1.2.12.1017 | redshift-jdbc41-1.2.12.1017 | redshift-jdbc42-2.1.0.16 |
## Appendice C: Aggiornamenti dei connettori
Di seguito sono riportati gli aggiornamenti dei connettori:
| Driver | Versione del connettore in 3.0 AWS Glue | Versione del connettore in AWS Glue 4.0 |
| --- | --- | --- |
| MongoDB | 3.0.0 | 10.0.4 |
| Hudi | 010.1 | 0.12.1 |
| Delta Lake | 1.0.0 | 2.1.0 |
| Iceberg | 0.13.1 | 1.0.0 |
| DynamoDB | 1.11 | 1.12 |
# Aggiornamenti generativi dell'intelligenza artificiale per Apache Spark in Glue AWS
Spark Upgrades in AWS Glue consente ai data engineer e agli sviluppatori di aggiornare e migrare i job AWS Glue Spark esistenti alle ultime release di Spark utilizzando l'intelligenza artificiale generativa. I data engineer possono utilizzarlo per AWS scansionare i lavori di Glue Spark, generare piani di aggiornamento, eseguire piani e convalidare gli output. Riduce i tempi e i costi degli aggiornamenti di Spark automatizzando il lavoro indifferenziato di identificazione e aggiornamento degli script, delle configurazioni, delle dipendenze, dei metodi e delle funzionalità di Spark.
![\[La GIF mostra un'implementazione completa di un esempio di workflow di analisi degli aggiornamenti.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/demo_lumos.gif)
## Come funziona
Quando utilizzi l'analisi degli aggiornamenti, AWS Glue identifica le differenze tra le versioni e le configurazioni nel codice del lavoro per generare un piano di aggiornamento. Il piano di aggiornamento descrive tutte le modifiche al codice e le fasi di migrazione richieste. Successivamente, AWS Glue crea ed esegue l'applicazione aggiornata in un ambiente per convalidare le modifiche e genera un elenco di modifiche al codice per la migrazione del lavoro. È possibile visualizzare lo script aggiornato insieme al riepilogo che descrive in dettaglio le modifiche proposte. Dopo aver eseguito i tuoi test, accetta le modifiche e il lavoro AWS Glue verrà aggiornato automaticamente alla versione più recente con il nuovo script.
Il processo di analisi degli aggiornamenti può richiedere un po' di tempo per il completamento, in funzione della complessità del processo e del carico di lavoro. I risultati dell'analisi dell'aggiornamento verranno archiviati nel percorso Amazon S3 specificato, che può essere esaminato per comprendere l'aggiornamento ed eventuali problemi di compatibilità. Dopo aver esaminato i risultati dell'analisi dell'aggiornamento, si può decidere se procedere con l'aggiornamento effettivo o apportare le modifiche necessarie al processo prima dell'aggiornamento.
## Prerequisiti
I seguenti prerequisiti sono necessari per utilizzare l'intelligenza artificiale generativa per aggiornare i lavori in AWS Glue:
+ AWS Glue 2 PySpark jobs: solo i lavori AWS Glue 2 possono essere aggiornati a AWS Glue 5.
+ Le autorizzazioni IAM sono necessarie per avviare l'analisi, esaminare i risultati e aggiornare il processo. Per ulteriori informazioni, consultare gli esempi nella sezione [Permissions](#auto-upgrade-permissions) seguente.
+ Se si utilizza AWS KMS per crittografare gli artefatti di analisi, sono necessarie autorizzazioni aggiuntive AWS AWS KMS . Per ulteriori informazioni, consultare gli esempi nella sezione [AWS KMS politica](#auto-upgrade-kms-policy) seguente.
### Permissions
#### Per avviare una nuova analisi degli aggiornamenti, sono necessarie le seguenti autorizzazioni:
1. Aggiornare la policy IAM del chiamante con la seguente autorizzazione:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StartJobUpgradeAnalysis",
"glue:StartJobRun",
"glue:GetJobRun",
"glue:GetJob",
"glue:BatchStopJobRun"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/script-location/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/results/*"
]
},
{
"Effect": "Allow",
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey"
],
"Resource": "arn:aws:kms:us-east-1:111122223333:key/key-id"
}
]
}
```
------
1. Aggiornare il ruolo di esecuzione del processo in fase di aggiornamento per includere la seguente policy in linea:
```
{
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": [
"ARN of the Amazon S3 path provided on API",
"ARN of the Amazon S3 path provided on API/*"
]
}
```
Ad esempio, se si utilizza il percorso `s3://amzn-s3-demo-bucket/upgraded-result` di Amazon S3, la policy sarà:
```
{
"Effect": "Allow",
"Action": ["s3:GetObject"],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/upgraded-result/",
"arn:aws:s3:::amzn-s3-demo-bucket/upgraded-result/*"
]
}
```
#### Per recuperare i dettagli di un'analisi, sono necessarie le seguenti autorizzazioni:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetJobUpgradeAnalysis"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Per interrompere un'analisi in corso, sono necessarie le seguenti autorizzazioni:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StopJobUpgradeAnalysis",
"glue:BatchStopJobRun"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Per elencare tutte le analisi inviate per un processo specifico, sono necessarie le seguenti autorizzazioni:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:ListJobUpgradeAnalyses"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:job/jobName"
]
}
]
}
```
------
#### Per accettare le modifiche di un'analisi e aggiornare un processo, sono necessarie le seguenti autorizzazioni:
### AWS KMS politica
Per passare la tua AWS KMS chiave personalizzata all'avvio di un'analisi, consulta la sezione seguente per configurare le autorizzazioni appropriate sulle AWS KMS chiavi.
#### Configurazione della crittografia degli artefatti dei risultati utilizzando una chiave: AWS KMS
Questa politica garantisce di disporre sia delle autorizzazioni di crittografia che di decrittografia sulla chiave. AWS KMS
```
{
"Effect": "Allow",
"Principal":{
"AWS": ""
},
"Action": [
"kms:Decrypt",
"kms:GenerateDataKey",
],
"Resource": ""
}
```
## Esecuzione di un'analisi degli aggiornamenti e applicazione dello script di aggiornamento
È possibile eseguire un'analisi degli aggiornamenti, che genererà un piano di aggiornamento su un processo selezionato dalla vista **Processi**.
1. Da **Jobs**, selezionate un job AWS Glue 2.0, quindi scegliete **Esegui analisi di aggiornamento** dal menu **Azioni**.
![\[La schermata mostra l'analisi degli aggiornamenti con l'IA dal menu delle operazioni.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/upgrade-analysis-run-action-menu.png)
1. Nel modale, selezionare un percorso per memorizzare il piano di aggiornamento generato nel **Percorso dei risultati**. Questo deve essere il bucket Amazon S3 a cui si può accedere e su cui scrivere.
![\[Lo screenshot mostra l'analisi degli aggiornamenti completata. Il pulsante per Applica lo script aggiornato è visibile.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/upgrade-analysis-configuration-options.png)
1. Configurare le opzioni aggiuntive, se necessario:
+ **Configurazione di esecuzione** - opzionale: la configurazione di esecuzione è un'impostazione opzionale che consente di personalizzare vari aspetti delle esecuzioni di convalida eseguite durante l'analisi degli aggiornamenti. Questa configurazione viene utilizzata per eseguire lo script aggiornato e consente di selezionare le proprietà dell'ambiente di calcolo (tipo di worker, numero di worker, ecc.). È necessario utilizzare gli account di sviluppatore non di produzione per eseguire le convalide su set di dati di esempio prima di esaminare, accettare le modifiche e applicarle agli ambienti di produzione. La configurazione di esecuzione include i seguenti parametri personalizzabili:
+ Tipo di worker: è possibile specificare il tipo di worker da utilizzare per le esecuzioni di convalida, in modo da scegliere le risorse di calcolo appropriate in base ai requisiti.
+ Numero di worker: è possibile definire il numero di worker da assegnare per le esecuzioni di convalida, in modo da scalare le risorse in base alle esigenze del carico di lavoro.
+ Timeout del processo (in minuti): questo parametro consente di impostare un limite di tempo per le esecuzioni di convalida, assicurando che i processi terminino dopo una durata specificata per evitare un consumo eccessivo di risorse.
+ Configurazione della sicurezza: è possibile configurare le impostazioni di sicurezza, come la crittografia e il controllo degli accessi, per garantire la protezione dei dati e delle risorse durante le esecuzioni di convalida.
+ Parametri di processo aggiuntivi: se necessario, è possibile aggiungere nuovi parametri di processo per personalizzare ulteriormente l'ambiente di esecuzione per le esecuzioni di convalida.
Sfruttando la configurazione di esecuzione, è possibile personalizzare le esecuzioni di convalida in base ai requisiti specifici. Ad esempio, è possibile configurare le esecuzioni di convalida per utilizzare un set di dati più piccolo, che consente di completare l'analisi più rapidamente e di ottimizzare i costi. Questo approccio garantisce che l'analisi degli aggiornamenti venga eseguita in modo efficiente, riducendo al minimo l'utilizzo delle risorse e i costi associati durante la fase di convalida.
+ **Configurazione della crittografia** - (opzionale):
+ **Abilitare la crittografia degli artefatti di aggiornamento**: abilitare la crittografia a riposo durante la scrittura dei dati nel percorso dei risultati. Se non si desidera crittografare gli elementi di aggiornamento, lasciare questa opzione deselezionata.
1. Scegliere **Esegui** per avviare l'analisi degli aggiornamenti. Mentre l'analisi è in esecuzione, è possibile visualizzare i risultati nella scheda **Analisi dell'aggiornamento**. La finestra dei dettagli dell'analisi mostrerà informazioni sull'analisi e collegamenti agli artefatti di aggiornamento.
+ **Percorso dei risultati**: è qui che vengono archiviati il riepilogo dei risultati e lo script di aggiornamento.
+ **Script aggiornato in Amazon** S3: la posizione dello script di aggiornamento in Amazon S3. È possibile visualizzare lo script prima di applicare l'aggiornamento.
+ **Riepilogo dell'aggiornamento in Amazon S3**: la posizione del riepilogo dell'aggiornamento in Amazon S3. È possibile visualizzare il riepilogo dell'aggiornamento prima di applicarlo.
1. Una volta completata con successo l'analisi dell'aggiornamento, è possibile applicare lo script di aggiornamento per aggiornare automaticamente il processo scegliendo **Applica script aggiornato**.
Una volta applicata, la versione AWS Glue verrà aggiornata alla 4.0. È possibile visualizzare lo script nella scheda **Script**.
![\[Lo screenshot mostra l'analisi degli aggiornamenti completata. Il pulsante per Applica lo script aggiornato è visibile.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/upgrade-analysis-analysis-details-preview.png)
## Comprendere il riepilogo dell'aggiornamento
Questo esempio dimostra il processo di aggiornamento di un lavoro AWS Glue dalla versione 2.0 alla versione 4.0. Il processo di esempio legge i dati di prodotto da un bucket Amazon S3, applica diverse trasformazioni ai dati utilizzando Spark SQL e quindi salva i risultati trasformati in un bucket Amazon S3.
### Codice originale (AWS Glue 2.0) - prima dell'aggiornamento
```
from awsglue.transforms import *
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from pyspark.sql.types import *
from pyspark.sql.functions import *
from awsglue.job import Job
import json
from pyspark.sql.types import StructType
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
gdc_database = "s3://aws-glue-scripts-us-east-1-gamma/demo-database/"
schema_location = (
"s3://aws-glue-scripts-us-east-1-gamma/DataFiles/"
)
products_schema_string = spark.read.text(
f"{schema_location}schemas/products_schema"
).first()[0]
product_schema = StructType.fromJson(json.loads(products_schema_string))
products_source_df = (
spark.read.option("header", "true")
.schema(product_schema)
.option(
"path",
f"{gdc_database}products/",
)
.csv(f"{gdc_database}products/")
)
products_source_df.show()
products_temp_view_name = "spark_upgrade_demo_product_view"
products_source_df.createOrReplaceTempView(products_temp_view_name)
query = f"select {products_temp_view_name}.*, format_string('%0$s-%0$s', category, subcategory) as unique_category from {products_temp_view_name}"
products_with_combination_df = spark.sql(query)
products_with_combination_df.show()
products_with_combination_df.createOrReplaceTempView(products_temp_view_name)
product_df_attribution = spark.sql(
f"""
SELECT *,
unbase64(split(product_name, ' ')[0]) as product_name_decoded,
unbase64(split(unique_category, '-')[1]) as subcategory_decoded
FROM {products_temp_view_name}
"""
)
product_df_attribution.show()
product_df_attribution.write.mode("overwrite").option("header", "true").option(
"path", f"{gdc_database}spark_upgrade_demo_product_agg/"
).saveAsTable("spark_upgrade_demo_product_agg", external=True)
spark_upgrade_demo_product_agg_table_df = spark.sql(
f"SHOW TABLE EXTENDED in default like 'spark_upgrade_demo_product_agg'"
)
spark_upgrade_demo_product_agg_table_df.show()
job.commit()
```
### Nuovo codice (Glue 4.0), dopo l'aggiornamento
```
from awsglue.transforms import *
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from pyspark.sql.types import *
from pyspark.sql.functions import *
from awsglue.job import Job
import json
from pyspark.sql.types import StructType
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# change 1
spark.conf.set("spark.sql.adaptive.enabled", "false")
# change 2
spark.conf.set("spark.sql.legacy.pathOptionBehavior.enabled", "true")
job = Job(glueContext)
gdc_database = "s3://aws-glue-scripts-us-east-1-gamma/demo-database/"
schema_location = (
"s3://aws-glue-scripts-us-east-1-gamma/DataFiles/"
)
products_schema_string = spark.read.text(
f"{schema_location}schemas/products_schema"
).first()[0]
product_schema = StructType.fromJson(json.loads(products_schema_string))
products_source_df = (
spark.read.option("header", "true")
.schema(product_schema)
.option(
"path",
f"{gdc_database}products/",
)
.csv(f"{gdc_database}products/")
)
products_source_df.show()
products_temp_view_name = "spark_upgrade_demo_product_view"
products_source_df.createOrReplaceTempView(products_temp_view_name)
# change 3
query = f"select {products_temp_view_name}.*, format_string('%1$s-%1$s', category, subcategory) as unique_category from {products_temp_view_name}"
products_with_combination_df = spark.sql(query)
products_with_combination_df.show()
products_with_combination_df.createOrReplaceTempView(products_temp_view_name)
# change 4
product_df_attribution = spark.sql(
f"""
SELECT *,
try_to_binary(split(product_name, ' ')[0], 'base64') as product_name_decoded,
try_to_binary(split(unique_category, '-')[1], 'base64') as subcategory_decoded
FROM {products_temp_view_name}
"""
)
product_df_attribution.show()
product_df_attribution.write.mode("overwrite").option("header", "true").option(
"path", f"{gdc_database}spark_upgrade_demo_product_agg/"
).saveAsTable("spark_upgrade_demo_product_agg", external=True)
spark_upgrade_demo_product_agg_table_df = spark.sql(
f"SHOW TABLE EXTENDED in default like 'spark_upgrade_demo_product_agg'"
)
spark_upgrade_demo_product_agg_table_df.show()
job.commit()
```
### Spiegazione del riepilogo dell'analisi
![\[Lo screenshot mostra il riepilogo dell'analisi degli aggiornamenti.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/upgrade-analysis-explanation-summary.png)
In base al riepilogo, ci sono quattro modifiche proposte da AWS Glue per aggiornare correttamente lo script da AWS Glue 2.0 a AWS Glue 4.0:
1. **Configurazione SQL di Spark (spark.sql.adaptive.enabled)**: questa modifica serve a ripristinare il comportamento dell'applicazione quando una nuova funzionalità per l'esecuzione adattiva delle query Spark SQL viene introdotta a partire da Spark 3.2. Si può ispezionare questa modifica alla configurazione e abilitarla o disabilitarla ulteriormente secondo le preferenze.
1. **DataFrame Modifica dell'API**: l'opzione path non può coesistere con altre DataFrameReader operazioni come`load()`. Per mantenere il comportamento precedente, AWS Glue ha aggiornato lo script per aggiungere una nuova configurazione SQL **(spark.sql.legacy). pathOptionBehavior.abilitato).**
1. **Modifica dell'API SQL di Spark**: il comportamento di `strfmt` in `format_string(strfmt, obj, ...)` è stato aggiornato in modo da non consentire `0$` come primo argomento. Per garantire la compatibilità, AWS Glue ha modificato lo script da utilizzare invece `1$` come primo argomento.
1. **Modifica dell'API SQL di Spark**: la funzione `unbase64` non consente input di stringhe in formato errato. Per mantenere il comportamento precedente, AWS Glue ha aggiornato lo script per utilizzare la `try_to_binary` funzione.
## Interruzione di un'analisi di aggiornamento in corso
È possibile annullare un'analisi dell'aggiornamento in corso o semplicemente interromperla.
1. Scegliere la scheda **Analisi dell'aggiornamento**.
1. Selezionare il processo in esecuzione, poi scegliere **Interrompi**. Questo interromperà l'analisi. È quindi possibile eseguire un'altra analisi degli aggiornamenti sullo stesso processo.
![\[La schermata mostra la scheda di analisi dell'aggiornamento con un processo selezionato. Il processo è ancora in esecuzione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/upgrade-analysis-tab.png)
## Considerazioni
Quando inizi a utilizzare Spark Upgrades, ci sono diversi aspetti importanti da considerare per un utilizzo ottimale del servizio.
+ **Ambito e limitazioni del servizio**: la versione corrente si concentra sugli aggiornamenti PySpark del codice dalle versioni 2.0 alla versione 5.0 di AWS Glue. Al momento, il servizio gestisce PySpark codice che non si basa su dipendenze di libreria aggiuntive. È possibile eseguire aggiornamenti automatici per un massimo di 10 processi contemporaneamente in un AWS account, in modo da aggiornare in modo efficiente più processi mantenendo al contempo la stabilità del sistema.
+ Sono supportati solo i PySpark lavori.
+ L'analisi degli aggiornamenti scadrà dopo 24 ore.
+ È possibile eseguire solo un'analisi di aggiornamento attiva alla volta per un singolo processo. A livello di account, possono essere eseguite fino a 10 analisi degli aggiornamenti attive nello stesso momento.
+ **Ottimizzazione dei costi durante il processo di aggiornamento**: poiché Spark Upgrades utilizza l'intelligenza artificiale generativa per convalidare il piano di aggiornamento attraverso più iterazioni, con ogni iterazione eseguita come processo AWS Glue nel tuo account, è essenziale ottimizzare le configurazioni di esecuzione del processo di convalida per ridurre i costi. A tal fine, consigliamo di specificare una configurazione di esecuzione all'avvio di un'analisi degli aggiornamenti nel modo seguente:
+ Usare account di sviluppo non di produzione e selezionare esempi di set di dati fittizi che rappresentino i dati di produzione ma di dimensioni più piccole per la convalida con Spark Upgrades.
+ Utilizzare risorse di calcolo della giusta dimensione, come i worker G.1X, e selezionare un numero appropriato di worker per l'elaborazione dei dati di esempio.
+ Attivazione dell'auto-scaling dei job di AWS Glue, se applicabile, per regolare automaticamente le risorse in base al carico di lavoro.
Ad esempio, se il processo di produzione elabora terabyte di dati con 20 worker G.2X, è possibile configurare il processo di aggiornamento per elaborare alcuni gigabyte di dati rappresentativi con 2 worker G.2X e il dimensionamento automatico abilitato per la convalida.
+ **Migliori pratiche**: consigliamo vivamente di iniziare il percorso di aggiornamento con lavori non di produzione. Questo approccio consente di acquisire familiarità con il flusso di lavoro di aggiornamento e di comprendere come il servizio gestisce i diversi tipi di modelli di codice Spark.
+ **Allarmi e notifiche**: quando utilizzi la funzionalità di aggiornamento dell'intelligenza artificiale generativa su un lavoro, assicurati che alarms/notifications le esecuzioni dei job non riusciti siano disattivate. Durante il processo di aggiornamento, potrebbero verificarsi fino a 10 esecuzioni di processi non riusciti nell'account prima che vengano forniti gli artefatti aggiornati.
+ **Regole di rilevamento delle anomalie**: disattivate le regole di rilevamento delle anomalie sul processo in fase di aggiornamento, poiché i dati scritti nelle cartelle di output durante le esecuzioni intermedie dei processi potrebbero non essere nel formato previsto durante la convalida dell'aggiornamento.
+ **Utilizzare l'analisi degli aggiornamenti con processi di idempotenza**: utilizzare l'analisi degli aggiornamenti con processi idempotenti per garantire che ogni successivo tentativo di esecuzione del processo di convalida sia simile a quello precedente e non comporti problemi. I processi idempotenti sono processi che possono essere eseguiti più volte con gli stessi dati di input e produrranno ogni volta lo stesso output. Quando si utilizzano gli aggiornamenti di intelligenza artificiale generativa per Apache Spark in AWS Glue, il servizio eseguirà più iterazioni del job come parte del processo di convalida. Durante ogni iterazione, apporterà modifiche al codice e alle configurazioni Spark per convalidare il piano di aggiornamento. Se il processo Spark non è idempotente, eseguirlo più volte con gli stessi dati di input potrebbe causare problemi.
## Regioni supportate
Gli aggiornamenti generativi dell'intelligenza artificiale per Apache Spark sono disponibili nelle seguenti regioni:
+ **Asia Pacifico**: Tokyo (ap-northeast-1), Seul (ap-northeast-2), Mumbai (ap-south-1), Singapore (ap-southeast-1) e Sydney (ap-southeast-2)
+ **Nord America**: Canada (ca-central-1)
+ **Europa**: Francoforte (eu-central-1), Stoccolma (eu-north-1), Irlanda (eu-west-1), Londra (eu-west-2) e Parigi (eu-west-3)
+ **Sud America**: San Paolo (sa-east-1)
+ **Stati Uniti**: Virginia del Nord (us-east-1), Ohio (us-east-2) e Oregon (us-west-2)
## Inferenza tra regioni in Spark Upgrades
Spark Upgrades è basato e sfrutta l'inferenza interregionale (CRIS). Amazon Bedrock Con CRIS, Spark Upgrades selezionerà automaticamente la regione ottimale all'interno dell'area geografica (come descritto più dettagliatamente [qui](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html)) per elaborare la richiesta di inferenza, massimizzare le risorse di calcolo disponibili e la disponibilità dei modelli e fornire la migliore esperienza al cliente. L'utilizzo dell'inferenza tra regioni non prevede costi aggiuntivi.
Le richieste di inferenza tra regioni vengono conservate all'interno delle AWS regioni che fanno parte della geografia in cui risiedono originariamente i dati. Ad esempio, una richiesta effettuata negli Stati Uniti viene conservata nelle AWS regioni degli Stati Uniti. Sebbene i dati rimangano archiviati solo nella regione primaria, quando si utilizza l'inferenza tra regioni, i prompt di input e i risultati di output potrebbero spostarsi al di fuori della regione primaria. Tutti i dati verranno trasmessi crittografati attraverso la rete sicura di Amazon.
# Lavorare con Spark jobs in AWS Glue
Fornisce informazioni sui lavori AWS Glue Spark ETL.
**Topics**
+ [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md)
+ [AWS Glue Spark e lavori PySpark](spark_and_pyspark.md)
+ [AWS Glue tipi di lavoratori](worker-types.md)
+ [Aggiunta di processi di streaming ETL in AWS Glue](add-job-streaming.md)
+ [Record di abbinamento con AWS Lake Formation FindMatches](machine-learning.md)
+ [Esegui la migrazione dei programmi Apache Spark a AWS Glue](glue-author-migrate-apache-spark.md)
# Utilizzo dei parametri del lavoro nei lavori AWS Glue
Quando si crea un lavoro AWS Glue, si impostano alcuni campi standard, come `Role` e`WorkerType`. È possibile fornire informazioni di configurazione aggiuntive tramite i campi `Argument` (**Parametri del processo** nella console). In questi campi, è possibile fornire ai job AWS Glue gli argomenti (parametri) elencati in questo argomento.
Per ulteriori informazioni sull'API AWS Glue Job, consulta[Jobs](aws-glue-api-jobs-job.md).
**Nota**
Gli argomenti del processo possono avere una dimensione massima di 260 KB. Se la dimensione dell'argomento è superiore a 260 KB, un controllo di convalida genererà un errore.
## Impostazione dei parametri del processo
È possibile configurare un processo tramite la console nella scheda **Job details** (Dettagli del processo), sotto l'intestazione **Job parameters** (Parametri del processo). Puoi anche configurare un lavoro tramite AWS CLI by setting `DefaultArguments` o `NonOverridableArguments` on a job oppure impostando `Arguments` on a job run. Gli argomenti impostati nel processo verranno trasmessi ogni volta che il processo viene eseguito, mentre gli argomenti impostati durante l'esecuzione del processo verranno trasmessi solo per quella singola esecuzione.
Ad esempio, di seguito è riportata la sintassi per l'esecuzione di un processo utilizzando `--arguments` per impostare un parametro di processo.
```
$ aws glue start-job-run --job-name "CSV to CSV" --arguments='--scriptLocation="s3://my_glue/libraries/test_lib.py"'
```
## Accesso ai parametri di processo
Quando scrivi script AWS Glue, potresti voler accedere ai valori dei parametri di lavoro per modificare il comportamento del tuo codice. Forniamo metodi di supporto per eseguire questa operazione tramite le nostre librerie. Questi metodi riescono a risolvere i valori dei parametri di esecuzione del processo che sostituiscono i valori dei parametri del processo. Quando si risolvono i parametri impostati in più posizioni, il processo `NonOverridableArguments` sostituisce l'esecuzione del processo `Arguments`, che sostituisce il processo `DefaultArguments`.
**In Python:**
Nei processi Python, forniamo una funzione denominata `getResolvedParameters`. Per ulteriori informazioni, consulta [Accesso ai parametri utilizzando `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md). I parametri del processo sono disponibili nella variabile `sys.argv`.
**In Scala:**
Nei processi Scala, forniamo un oggetto denominato `GlueArgParser`. Per ulteriori informazioni, consulta [AWS GlueScala GlueArgParser APIs](glue-etl-scala-apis-glue-util-glueargparser.md). I parametri del processo sono disponibili nella variabile `sysArgs`.
## Riferimento ai parametri di processo
**AWS Glue riconosce i seguenti nomi di argomenti che è possibile utilizzare per configurare l'ambiente di script per i job e le esecuzioni dei job:**
**`--additional-python-modules`**
Un elenco delimitato da virgole che rappresenta un insieme di pacchetti Python da installare. Puoi installare pacchetti da PyPI o fornire una distribuzione personalizzata. Una voce del pacchetto PyPI sarà nel formato `package==version`, con il nome e la versione del pacchetto di destinazione. Una voce della distribuzione personalizzata è rappresentata dal percorso S3 della distribuzione.
Le voci utilizzano la versione di Python corrispondente al pacchetto e alla versione, in modo che l'utente non debba utilizzare due segni uguali, come `==`. Per ulteriori informazioni su altri operatori che corrispondono alle versioni, consulta la pagina [PEP 440](https://peps.python.org/pep-0440/#version-matching).
Per inviare le opzioni di installazione del modulo a `pip3`, utilizza il parametro [--python-modules-installer-option](#python-modules-installer-option).
**`--auto-scale-within-microbatch`**
Il valore di default è true. Questo parametro può essere utilizzato solo per i lavori di streaming AWS Glue, che elaborano i dati di streaming in una serie di micro batch, e la scalabilità automatica deve essere abilitata. Quando si imposta questo valore su "false", viene calcolata la media mobile esponenziale della durata del batch per i microbatch completati e questo valore viene confrontato con la dimensione della finestra per determinare se aumentare o ridurre verticalmente il numero di esecutori. Il dimensionamento avviene solo quando viene completato un microbatch. Quando si imposta questo valore su "true", durante un microbatch, l'aumento avviene quando il numero di attività Spark rimane invariato per 30 secondi o se l'elaborazione del batch corrente è maggiore della dimensione della finestra. Il numero di esecutori diminuisce se un esecutore è rimasto inattivo per più di 60 secondi o se la media mobile esponenziale della durata del batch è bassa.
**`--class`**
La classe Scala che funge da punto di accesso per lo script Scala. Questo vale solo se il tuo `--job-language` è impostato su `scala`.
**`--continuous-log-conversionPattern`**
Specifica un modello di log di conversione personalizzato per un processo abilitato per la registrazione continua. Il modello di conversione si applica solo ai log dei driver e ai log delle esecuzioni. Non influisce sulla barra di avanzamento di AWS Glue.
**`--continuous-log-logGroup`**
Specifica un nome di gruppo di CloudWatch log Amazon personalizzato per un job abilitato alla registrazione continua.
**`--continuous-log-logStreamPrefix`**
Specifica un prefisso di CloudWatch log stream personalizzato per un job abilitato alla registrazione continua.
**`--customer-driver-env-vars` e `--customer-executor-env-vars`**
Questi parametri impostano le variabili di ambiente nel sistema operativo rispettivamente per ogni worker (driver o executor). Puoi utilizzare questi parametri quando crei piattaforme e framework personalizzati su AWS Glue, per consentire ai tuoi utenti di scrivere lavori su di esso. L'attivazione di questi due flag consentirà di impostare diverse variabili di ambiente rispettivamente sul driver e sull'executor senza dover inserire la stessa logica nello script del processo.
**Esempio di utilizzo**
Di seguito è riportato un esempio di utilizzo di questi parametri:
```
"—customer-driver-env-vars", "CUSTOMER_KEY1=VAL1,CUSTOMER_KEY2=\"val2,val2 val2\"",
"—customer-executor-env-vars", "CUSTOMER_KEY3=VAL3,KEY4=VAL4"
```
La loro impostazione nell'argomento dell'esecuzione del processo equivale all'esecuzione dei seguenti comandi:
Nel driver:
+ export CUSTOMER\$1 = KEY1 VAL1
+ export CUSTOMER\$1 KEY2 ="val2, val2 val2"
Nell'executor:
+ esporta CUSTOMER\$1 KEY3 = VAL3
Quindi, nello script del processo, è possibile recuperare le variabili di ambiente utilizzando `os.environ.get("CUSTOMER_KEY1")` o `System.getenv("CUSTOMER_KEY1")`.
**Sintassi applicata**
Osservare i seguenti standard quando si definiscono le variabili di ambiente:
+ Ogni chiave deve avere il `CUSTOMER_ prefix`.
Ad esempio: per `"CUSTOMER_KEY3=VAL3,KEY4=VAL4"`, `KEY4=VAL4` verrà ignorato e non impostato.
+ Ogni coppia di chiavi e valori deve essere delineata con una sola virgola.
Ad esempio: `"CUSTOMER_KEY3=VAL3,CUSTOMER_KEY4=VAL4"`
+ Se “value” contiene spazi o virgole, deve essere definito tra virgolette.
Ad esempio: `CUSTOMER_KEY2=\"val2,val2 val2\"`
Questa sintassi modella da vicino gli standard di impostazione delle variabili di ambiente bash.
**`--datalake-formats` **
Supportato in AWS Glue 3.0 e versioni successive.
Specifica il framework del data lake da utilizzare. AWS Glue aggiunge i file JAR richiesti per i framework specificati in. `classpath` Per ulteriori informazioni, consulta [Utilizzo di framework di data lake con AWS Glue processi ETL](aws-glue-programming-etl-datalake-native-frameworks.md).
Puoi specificare uno o più dei seguenti valori, separati da una virgola:
+ `hudi`
+ `delta`
+ `iceberg`
Ad esempio, invia il seguente argomento per specificare tutti e tre i framework.
```
'--datalake-formats': 'hudi,delta,iceberg'
```
**`--disable-proxy-v2`**
Disattiva il proxy del servizio per consentire le chiamate di AWS servizio ad Amazon S3 e AWS Glue provenienti dallo script tramite il tuo VPC. CloudWatch Per ulteriori informazioni, consulta [Configurazione di chiamate AWS affinché passino attraverso il tuo VPC](https://docs.aws.amazon.com/glue/latest/dg/connection-VPC-disable-proxy.html). Per disabilitare il proxy del servizio, imposta il valore di questo parametro su `true`.
**`--enable-auto-scaling`**
Attiva la scalabilità automatica e la fatturazione per operatore quando imposti il valore su `true`.
**`--enable-continuous-cloudwatch-log`**
Consente la registrazione continua in tempo reale per i lavori AWS Glue. Puoi visualizzare i log dei processi Apache Spark in tempo reale in CloudWatch.
**`--enable-continuous-log-filter`**
Specifica un filtro standard (`true`) o nessun filtro (`false`) durante la creazione o la modifica di un processo abilitato per la registrazione continua. La scelta del filtro standard elimina i messaggi di registro del battito cardiaco non utili di Apache Spark driver/executor e Apache Hadoop YARN. Non scegliendo alcun filtro si ottengono tutti i messaggi di log.
**`--enable-glue-datacatalog`**
Consente di utilizzare AWS Glue Data Catalog come metastore Apache Spark Hive. Imposta questo valore su `true` per abilitare questa funzionalità.
**`--enable-job-insights`**
Consente un monitoraggio aggiuntivo dell'analisi degli errori con AWS Glue job run insights. Per informazioni dettagliate, vedi [Monitoraggio con AWS Glue Job Run Insights](monitor-job-insights.md). Per impostazione predefinita, il valore è impostato su `true` e le informazioni dettagliate sull'esecuzione dei processi sono abilitate.
Questa opzione è disponibile per AWS Glue versione 2.0 e 3.0.
**`--enable-lakeformation-fine-grained-access`**
Consente un controllo granulare degli accessi per i lavori AWS Glue. Per ulteriori informazioni, consulta [Utilizzo di AWS Glue with AWS Lake Formation per un controllo degli accessi a grana fine](security-lf-enable.md).
**`--enable-metrics`**
Abilita la raccolta di parametri per la profilatura del processo per questa esecuzione. Queste metriche sono disponibili sulla console AWS Glue e sulla CloudWatch console Amazon. Il valore di questo parametro non è rilevante. Per abilitare questa funzionalità, è possibile fornire a questo parametro qualsiasi valore, ma `true` è consigliabile per motivi di chiarezza. Per disabilitare la funzionalità, rimuovi questo parametro dalla configurazione del processo.
**`--enable-observability-metrics`**
Abilita una serie di metriche di osservabilità per generare informazioni su ciò che accade all'interno di ogni lavoro eseguito nella pagina Job Runs Monitoring nella console AWS Glue e nella Amazon CloudWatch console. Per abilitare questa funzionalità, imposta il valore del parametro su "true". Per disabilitare questa funzionalità, impostalo su `false` o rimuovi questo parametro dalla configurazione del processo.
**`--enable-rename-algorithm-v2`**
Imposta la versione dell'algoritmo di ridenominazione EMRFS alla versione 2. Quando un processo Spark utilizza la modalità di sovrascrittura della partizione dinamica, è possibile che venga creata una partizione duplicata. Ad esempio, si può ottenere una partizione duplicata come `s3://bucket/table/location/p1=1/p1=1`. Qui, P1 è la partizione che viene sovrascritta. La versione 2 dell'algoritmo di ridenominazione risolve questo problema.
Questa opzione è disponibile solo nella versione 1.0 di AWS Glue.
**`--enable-s3-parquet-optimized-committer`**
Abilita il committer ottimizzato EMRFS S3 per la scrittura dei dati Parquet in Amazon S3. È possibile fornire la parameter/value coppia tramite la console AWS Glue durante la creazione o l'aggiornamento di un lavoro AWS Glue. L'impostazione del valore su **true** abilita il committer. Per impostazione predefinita, il flag è attivato in AWS Glue 3.0 e disattivato in AWS Glue 2.0.
Per ulteriori informazioni, consulta [Utilizzo del committer ottimizzato EMRFS S3](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-s3-optimized-committer.html).
**`--enable-spark-ui`**
Se impostato su`true`, attiva la funzionalità per utilizzare l'interfaccia utente Spark per monitorare ed eseguire il debug dei lavori AWS Glue ETL.
**`--executor-cores`**
Numero di attività spark che possono essere eseguite in parallelo. Questa opzione è supportata su AWS Glue 3.0\$1. Il valore non deve superare il doppio del numero di v CPUs del tipo di lavoratore, ovvero 8 on`G.1X`, 16 on`G.2X`, 32 on`G.4X`, 64 on`G.8X`, 96 on`G.12X`, 128 on `G.16X` e 8 on`R.1X`, 16 on, 32 on `R.2X``R.4X`, 64 on. `R.8X` È necessario prestare attenzione durante l'aggiornamento di questa configurazione in quanto potrebbe influire sulle prestazioni del processo; l'incremento del parallelismo, infatti, esercita pressione sulla memoria e sul disco, oltre a limitare i sistemi di origine e destinazione (ad esempio, potrebbe causare più connessioni simultanee su Amazon RDS).
**`--extra-files`**
I percorsi Amazon S3 dei file aggiuntivi, come file di configurazione, che AWS Glue copia nella directory di lavoro del tuo script sul nodo del driver prima di eseguirlo. I valori multipli devono essere percorsi completi separati dalla virgola (`,`). Il valore può essere rappresentato da singoli file o posizioni di directory. Questa opzione non è supportata per i tipi di processo shell Python.
**`--extra-jars`**
Amazon S3 conduce a file aggiuntivi che AWS Glue copia nel driver e negli executor. AWS Glue aggiunge anche questi file al classpath Java prima di eseguire lo script. I valori multipli devono essere percorsi completi separati dalla virgola (`,`). L'estensione non deve essere `.jar`
**`--extra-py-files`**
I percorsi di Amazon S3 verso moduli Python aggiuntivi che AWS Glue aggiunge al percorso Python sul nodo driver prima di eseguire lo script. I valori multipli devono essere percorsi completi separati dalla virgola (`,`). Solo i singoli file sono supportati, non il percorso di una directory.
**`--job-bookmark-option`**
Controlla il comportamento di un segnalibro del processo. É possibile impostare i seguenti valori opzione.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)
Ad esempio, per abilitare un segnalibro di processo, passa l'argomento seguente.
```
'--job-bookmark-option': 'job-bookmark-enable'
```
**`--job-language`**
Il linguaggio di programmazione script. Questo valore deve essere `scala` o `python`. Se questo parametro non è presente, il valore predefinito è `python`.
**`--python-modules-installer-option`**
Una stringa di testo semplice che definisce le opzioni da inviare a `pip3` quando si installano i moduli con [--additional-python-modules](#additional-python-modules). Fornisci le opzioni come faresti nella riga di comando, separate da spazi e precedute da trattini. Per ulteriori informazioni sull'utilizzo, consulta [Installazione di moduli Python aggiuntivi con pip in AWS Glue 2.0 o versioni successive](aws-glue-programming-python-libraries.md#addl-python-modules-support).
Questa opzione non è supportata per i lavori AWS Glue quando si utilizza Python 3.9.
**`--scriptLocation`**
La posizione di Amazon Simple Storage Service (Amazon S3) in cui si trova lo script ETL (nel formato `s3://path/to/my/script.py`). Questo parametro sovrascrive un percorso script impostato nell'oggetto `JobCommand`.
**`--spark-event-logs-path`**
Specifica un percorso Amazon S3. Quando si utilizza la funzionalità di monitoraggio dell'interfaccia utente di Spark, AWS Glue scarica i log degli eventi Spark su questo percorso Amazon S3 ogni 30 secondi in un bucket utilizzabile come directory temporanea per la memorizzazione di eventi dell'interfaccia utente Spark.
**`--TempDir`**
Specifica un percorso Amazon S3 a un bucket utilizzabile come directory temporanea per il processo.
Ad esempio, per impostare una directory temporanea, passa l'argomento seguente.
```
'--TempDir': 's3-path-to-directory'
```
AWS Glue crea un bucket temporaneo per i lavori se un bucket non esiste già in una regione. Questo bucket potrebbe consentire l'accesso pubblico. Puoi modificare il bucket in Amazon S3 per impostare il blocco dell'accesso pubblico oppure eliminare il bucket in un secondo momento dopo che tutti i processi in quella regione sono stati completati.
**`--use-postgres-driver`**
Impostando questo valore su `true`, assegna la priorità al driver JDBC Postgres nella variabile classpath per evitare un conflitto con il driver JDBC Amazon Redshift. Questa opzione è disponibile solo nella versione 2.0 di AWS Glue.
**`--user-jars-first`**
Impostando questo valore su `true`, dà la priorità ai file JAR aggiuntivi del cliente nella variabile classpath. Questa opzione è disponibile solo nella versione 2.0 o successiva di AWS Glue.
**`--conf`**
Controlla i parametri di configurazione di Spark. È per casi d'uso avanzati.
**`--encryption-type`**
Parametro legacy. Il comportamento corrispondente deve essere configurato utilizzando le configurazioni di sicurezza. Per ulteriori informazioni sulle configurazioni di sicurezza, consulta la pagina [Crittografia dei dati scritti da AWS Glue](encryption-security-configuration.md).
AWS Glue utilizza internamente i seguenti argomenti e non dovresti mai usarli:
+ `--debug`— Interno a AWS Glue. Non impostare.
+ `--mode`— Interno a AWS Glue. Non impostare.
+ `--JOB_NAME`— Interno a AWS Glue. Non impostare.
+ `--endpoint`— Interno a AWS Glue. Non impostare.
##
AWS Glue supporta il bootstrap di un ambiente con il `site` modulo Python utilizzato `sitecustomize` per eseguire personalizzazioni specifiche del sito. L'avvio delle proprie funzioni di inizializzazione è consigliato solo per casi d'uso avanzati ed è supportato al massimo su Glue 4.0. AWS
Il prefisso della variabile di ambiente, `GLUE_CUSTOMER`, è riservato all'uso da parte dei clienti.
# AWS Glue Spark e lavori PySpark
AWS Glue supporta Spark e jobs. PySpark Un job Spark viene eseguito in un ambiente Apache Spark gestito da. AWS Glue Elabora i dati in batch. Un processo ETL di streaming è simile a un processo Spark, ad eccezione del fatto che esegue ETL sui flussi di dati. Esso utilizza il framework Apache Spark Structured Streaming. Alcune caratteristiche dei processi Spark non sono disponibili per i processi ETL in streaming.
Le seguenti sezioni forniscono informazioni su AWS Glue Spark e sui job. PySpark
**Topics**
+ [Configurazione delle proprietà dei job per i job Spark in AWS Glue](add-job.md)
+ [Modifica degli script Spark nella console AWS Glue](edit-script-spark.md)
+ [Processi (legacy)](console-edit-script.md)
+ [Monitoraggio dei dati elaborati mediante segnalibri di processo](monitor-continuations.md)
+ [Memorizzazione dei dati shuffle di Spark](monitor-spark-shuffle-manager.md)
+ [Monitoraggio dei processi Spark AWS Glue](monitor-spark.md)
+ [Risoluzione dei problemi di intelligenza artificiale generativa per Apache Spark in Glue AWS](troubleshoot-spark.md)
+ [Utilizzo di viste materializzate con AWS Glue](materialized-views.md)
# Configurazione delle proprietà dei job per i job Spark in AWS Glue
Quando definisci il tuo job sulla AWS Glue console, fornisci i valori delle proprietà per controllare l'ambiente AWS Glue di runtime.
## Definire le proprietà di processo per i processi Spark
L'elenco seguente descrive le proprietà di un processo Spark. Per le proprietà di un processo shell di Python, consulta [Definire le proprietà del processo per i processi shell di Python](add-job-python.md#create-job-python-properties). Per le proprietà di un processo ETL di streaming, vedere [Definizione delle proprietà di processo per un processo di streaming ETL](add-job-streaming.md#create-job-streaming-properties).
Le proprietà sono elencate nell'ordine in cui appaiono nella procedura guidata **Aggiungi lavoro** sulla AWS Glue console.
**Name**
Stringa UTF-8 con un massimo di 255 caratteri.
**Description**
Fornisci una descrizione facoltativa di un massimo di 2.048 caratteri.
**Ruolo IAM**
Specifica il ruolo IAM; utilizzato per definire l'autorizzazione alle risorse utilizzate per eseguire il processo e accedere agli archivi dati. Per ulteriori informazioni sulle autorizzazioni per l'esecuzione di lavori in AWS Glue, vedere. [Gestione delle identità e degli accessi per AWS Glue](security-iam.md)
**Tipo**
Il tipo di processo ETL. Viene impostato automaticamente in base al tipo di origini dati selezionate.
+ **Spark** esegue uno script ETL di Apache Spark con il comando del processo denominato `glueetl`.
+ **Spark Streaming** esegue uno script ETL di streaming Apache Spark con il comando del processo denominato `gluestreaming`. Per ulteriori informazioni, consulta [Aggiunta di processi di streaming ETL in AWS Glue](add-job-streaming.md).
+ **Shell di Python** esegue uno script Python con il comando di processo denominato `pythonshell`. Per ulteriori informazioni, consulta [Configurazione delle proprietà del processo per i processi shell di Python in AWS Glue](add-job-python.md).
**Versione AWS Glue **
AWS Glue version determina le versioni di Apache Spark e Python disponibili per il job, come specificato nella tabella seguente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/add-job.html)
**Lingua**
Il codice nello script ETL definisce la logica del processo. Lo script può essere codificato in Python o Scala. Puoi scegliere se lo script eseguito dal job viene generato da te AWS Glue o fornito da te. Puoi fornire il nome e la posizione dello script in Amazon Simple Storage Service (Amazon S3). Conferma che non esiste un file con lo stesso nome della directory di script nel percorso. Per ulteriori informazioni sull'uso degli script, consulta [AWS Glue guida alla programmazione](edit-script.md).
**Tipo di lavoratore**
Sono disponibili i seguenti tipi di worker:
Le risorse disponibili per i AWS Glue lavoratori vengono misurate in DPUs. Una DPU è una misura relativa della potenza di elaborazione costituita da 4 V CPUs di capacità di elaborazione e 16 GB di memoria.
+ **G.025X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue il mapping a 0,25 DPU (2 vCPUs, 4 GB di memoria) con disco da 84 GB (circa 34 GB liberi). Consigliamo questo tipo di worker per i processi di streaming a basso volume. Questo tipo di worker è disponibile solo per i lavori di streaming della AWS Glue versione 3.0 o successiva.
+ **G.1X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni lavoratore esegue il mapping su 1 DPU (4 vCPUs, 16 GB di memoria) con disco da 94 GB (circa 44 GB gratuiti). Questi tipi di worker sono raccomandati per carichi di lavoro come trasformazioni di dati, join e query, in quanto offrono un modo scalabile ed economico per eseguire la maggior parte dei processi.
+ **G.2X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue il mapping su 2 DPU (8 vCPUs, 32 GB di memoria) con disco da 138 GB (circa 78 GB gratuiti). Questi tipi di worker sono raccomandati per carichi di lavoro come trasformazioni di dati, join e query, in quanto offrono un modo scalabile ed economico per eseguire la maggior parte dei processi.
+ **G.4X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue il mapping a 4 DPU (16 vCPUs, 64 GB di memoria) con disco da 256 GB (circa 230 GB gratuiti). Questi tipi di worker sono raccomandati per i processi i cui carichi di lavoro contengono trasformazioni, aggregazioni, join e query con i requisiti più elevati.
+ **G.8X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue il mapping a 8 DPU (32 vCPUs, 128 GB di memoria) con disco da 512 GB (circa 485 GB gratuiti). Questi tipi di worker sono raccomandati per i processi i cui carichi di lavoro contengono trasformazioni, aggregazioni, join e query con i requisiti più elevati.
+ **G.12X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue il mapping a 12 DPU (48 vCPUs, 192 GB di memoria) con disco da 768 GB (circa 741 GB liberi). Consigliamo questo tipo di worker per processi con carichi di lavoro molto grandi e che richiedono molte risorse con una capacità di calcolo significativa.
+ **G.16X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue il mapping a 16 DPU (64 vCPUs, 256 GB di memoria) con disco da 1024 GB (circa 996 GB gratuiti). Consigliamo questo tipo di worker per processi con i carichi di lavoro più grandi e che richiedono più risorse con una capacità di calcolo massima.
+ **R.1X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue la mappatura su 1 DPU con configurazione ottimizzata per la memoria. Consigliamo questo tipo di worker per carichi di lavoro che richiedono un uso intensivo della memoria e che presentano spesso errori o richiedono rapporti elevati. out-of-memory memory-to-CPU
+ **R.2X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue la mappatura su 2 DPU con configurazione ottimizzata per la memoria. Consigliamo questo tipo di worker per carichi di lavoro che richiedono molta memoria e che presentano spesso errori o richiedono rapporti elevati. out-of-memory memory-to-CPU
+ **R.4X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue la mappatura su 4 DPU con configurazione ottimizzata per la memoria. Consigliamo questo tipo di worker per carichi di lavoro che richiedono grandi quantità di memoria e che presentano spesso errori o richiedono rapporti elevati. out-of-memory memory-to-CPU
+ **R.8X**: quando si sceglie questo tipo, si fornisce anche un valore per **Numero di worker**. Ogni worker esegue la mappatura su 8 DPU con configurazione ottimizzata per la memoria. Consigliamo questo tipo di worker per carichi di lavoro di grandi dimensioni che richiedono un uso intensivo della memoria e che presentano spesso errori o richiedono rapporti elevati. out-of-memory memory-to-CPU
**Specifiche del tipo di worker**
La tabella seguente fornisce le specifiche dettagliate per tutti i tipi di worker G disponibili:
**Specifiche del tipo worker G**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/add-job.html)
**Importante:** i tipi di worker G.12X e G.16X, così come tutti i tipi di worker R (da R.1X a R.8X), hanno una latenza di avvio più elevata.
Ti viene addebitata una tariffa oraria basata sul numero di job ETL DPUs utilizzati per eseguire i tuoi job ETL. Per ulteriori informazioni, consultare la [pagina dei prezzi di AWS Glue](https://aws.amazon.com/glue/pricing/).
Per la AWS Glue versione 1.0 o precedente, quando si configura un lavoro utilizzando la console e si specifica un **tipo di lavoratore** su **Standard**, viene impostata la **capacità massima** e il **numero di lavoratori** diventa il valore di **Capacità massima** - 1. Se si utilizza AWS Command Line Interface (AWS CLI) o AWS SDK, è possibile specificare il parametro **Capacità massima** oppure specificare sia il **tipo di lavoratore** che il **numero di lavoratori**.
Per i lavori della AWS Glue versione 2.0 o successiva, non è possibile specificare una **capacità massima**. È invece necessario specificare un **Worker type (Tipo di worker)** e il **Number of workers (Numero di worker)**.
**G.4X**e i tipi di **G.8X** lavoratori sono disponibili solo per i lavori Spark ETL AWS Glue versione 3.0 o successiva AWS nelle seguenti regioni: Stati Uniti orientali (Ohio), Stati Uniti orientali (Virginia settentrionale), Stati Uniti occidentali (California settentrionale), Stati Uniti occidentali (Oregon), Asia Pacifico (Mumbai), Asia Pacifico (Seoul), Asia Pacifico (Singapore), Asia Pacifico (Sydney), Asia Pacifico (Tokyo), Canada (Centrale), Europa (Francoforte), Europa (Irlanda), Europa (Londra), Europa (Spagna), Europa (Stoccolma) e Sud America (San Paolo).
**G.12X****G.16X**, e **R.1X** tramite i tipi di **R.8X** worker sono disponibili solo per i job Spark ETL AWS Glue versione 4.0 o successiva AWS nelle seguenti regioni: Stati Uniti orientali (Virginia settentrionale), Stati Uniti occidentali (Oregon), Stati Uniti orientali (Ohio), Europa (Irlanda) ed Europa (Francoforte). In futuro verranno supportate regioni aggiuntive.
**Numero di worker richiesto**
Per la maggior parte dei tipi di worker è necessario specificare il numero di worker allocati quando il processo viene eseguito.
**Segnalibro Job**
Specificate in che modo AWS Glue i processi definiscono le informazioni durante l'esecuzione del processo. Puoi ricordare di aver già elaborato i dati, aggiornato le informazioni sullo stato o ignorato le informazioni sullo stato. Per ulteriori informazioni, consulta [Monitoraggio dei dati elaborati mediante segnalibri di processo](monitor-continuations.md).
**Coda per l'esecuzione dei processi**
Specifica se le esecuzioni dei processi vengono messe in coda per essere eseguite in un secondo momento quando le quote di servizio non sono sufficienti.
Se selezionato, la coda per l'esecuzione dei processi viene abilitata. Se non è compilato, le esecuzioni del processo non saranno prese in considerazione per la coda.
Se questa impostazione non corrisponde al set di valori impostato nell'esecuzione del processo, verrà utilizzato il valore presente nel campo di esecuzione del processo.
**Esecuzione flessibile**
Quando configuri un lavoro utilizzando AWS Studio o l'API, puoi specificare una classe di esecuzione del lavoro standard o flessibile. I tuoi processo possono avere diversi gradi di priorità e sensibilità temporale. La classe di esecuzione standard è ideale per carichi di lavoro sensibili al tempo che richiedono un avvio rapido dei processi e risorse dedicate.
La classe di esecuzione flessibile è adatta per processi non urgenti come i processi di pre-produzione, test e caricamenti di dati una tantum. Le esecuzioni di job flessibili sono supportate per i lavori che utilizzano la AWS Glue versione 3.0 o successiva `G.1X` e/o per i tipi di `G.2X` worker. I nuovi tipi di worker (`G.12X`, `G.16X` e da `R.1X` a `R.8X`) non supportano l'esecuzione flessibile.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/FnHCoTuDLXU)
Le esecuzioni dei processi flessibili vengono fatturate in base al numero di worker che vengono eseguiti alla volta. Il numero di worker può essere aggiunto o rimosso per un'esecuzione di lavoro flessibile in esecuzione. Invece di fatturare come semplice calcolo di `Max Capacity` \$1 `Execution Time`, ogni worker contribuirà per il tempo che è stato eseguito durante l'esecuzione del processo. La fattura è la somma di (`Number of DPUs per worker` \$1 `time each worker ran`).
Per ulteriori informazioni, consulta il pannello di aiuto in AWS Studio oppure [Jobs](aws-glue-api-jobs-job.md) e[Esecuzioni di processi](aws-glue-api-jobs-runs.md).
**Numero di tentativi**
Specificate il numero di volte, da 0 a 10, che AWS Glue devono riavviare automaticamente il processo in caso di errore. I processi che raggiungono il limite di timeout non vengono riavviati.
**Timeout dei processi**
Imposta il tempo di esecuzione massimo in minuti. Il valore massimo è 7 giorni o 10.080 minuti. In caso contrario, i processi genereranno un'eccezione.
Quando il valore viene lasciato vuoto, il timeout viene impostato sul valore predefinito di 2.880 minuti.
Tutti i AWS Glue lavori esistenti con un valore di timeout superiore a 7 giorni verranno impostati come impostazione predefinita su 7 giorni. Ad esempio, se un processo in batch ha impostato un timeout di 20 giorni, sarà interrotto al settimo giorno.
**Best practice per i timeout dei processi**
I processi vengono fatturati in base al tempo di esecuzione. Per evitare addebiti imprevisti, configura i valori di timeout appropriati per il tempo di esecuzione previsto del processo.
**Proprietà avanzate**
**Nome del file dello script**
Un nome univoco dello script per il processo. Non può essere denominato **Processo senza titolo**.
**Percorso dello script**
La posizione Amazon S3 dello script. Il percorso deve essere nel formato `s3://bucket/prefix/path/`. Deve terminare con una barra (`/`) e non includere alcun file.
**Parametri del processo**
Attiva o disattiva la creazione di CloudWatch metriche Amazon durante l'esecuzione di questo processo. Per visualizzare i dati di profiling, è necessario abilitare questa opzione. Per ulteriori informazioni su come attivare e visualizzare i parametri, consulta [Monitoraggio e debug dei processi](monitor-profile-glue-job-cloudwatch-metrics.md).
**Metriche di osservabilità dei processi**
Attiva la creazione di CloudWatch parametri di osservabilità aggiuntivi durante l'esecuzione di questo processo. Per ulteriori informazioni, consulta [Monitoraggio con parametri AWS Glue di osservabilità](monitor-observability.md).
**Registrazione continua**
Attiva la registrazione continua su Amazon CloudWatch. Se questa opzione non è abilitata, i registri sono disponibili solo dopo il completamento del processo. Per ulteriori informazioni, consulta [Registrazione dei lavori AWS Glue](monitor-continuous-logging.md).
**Interfaccia utente Spark**
Attiva l'uso dell'interfaccia utente di Spark per monitorare questo processo. Per ulteriori informazioni, consulta [Abilitazione dell'interfaccia utente Web di Apache Spark per processi AWS Glue](monitor-spark-ui-jobs.md).
**Percorso dei log dell'interfaccia utente di Spark**
Il percorso per scrivere i log quando l'interfaccia utente di Spark è abilitata.
**Configurazione della registrazione e del monitoraggio dell'interfaccia utente di Spark**
Scegli una delle seguenti opzioni:
+ *Standard*: scrivi i log usando l'ID di esecuzione del AWS Glue processo come nome del file. Attiva il monitoraggio dell'interfaccia utente Spark nella console. AWS Glue
+ *Legacy*: scrivi i log usando “spark-application- \$1timestamp\$1” come nome del file. Non attivare il monitoraggio dell'interfaccia utente di Spark.
+ *Standard e legacy*: scrivi i log sia nelle posizioni standard che in quelle legacy. Attiva il monitoraggio dell'interfaccia utente Spark nella AWS Glue console.
**Simultaneità massima**
Imposta il numero massimo di esecuzioni simultanee consentite per il processo. Il valore di default è 1. Viene restituito un errore al raggiungimento della soglia. Il valore massimo che è possibile specificare è controllato da un limite di servizio. Ad esempio, se un'esecuzione di un processo precedente non è ancora terminata quando una nuova istanza viene avviata, è possibile restituire un errore per evitare che due istanze dello stesso processo vengano eseguite simultaneamente.
**Percorso temporaneo**
Fornisci la posizione di una directory di lavoro in Amazon S3 in cui vengono scritti i risultati intermedi temporanei durante l' AWS Glue esecuzione dello script. Conferma che non esiste un file con lo stesso nome della directory temporanea nel percorso. Questa directory viene utilizzata durante la AWS Glue lettura e la scrittura su Amazon Redshift e per determinate AWS Glue trasformazioni.
AWS Glue crea un bucket temporaneo per i lavori se un bucket non esiste già in una regione. Questo bucket potrebbe consentire l'accesso pubblico. Puoi modificare il bucket in Amazon S3 per impostare il blocco dell'accesso pubblico oppure eliminare il bucket in un secondo momento dopo che tutti i processi in quella regione sono stati completati.
**Soglia notifica di ritardo (minuti)**
Imposta la soglia (in minuti) prima di inviare una notifica di ritardo. Puoi impostare questa soglia per inviare notifiche quando l'esecuzione di un processo `RUNNING`, `STARTING` o `STOPPING` impiega di più rispetto alla quantità di minuti attesa.
**Configurazione di sicurezza**
Scegliere una configurazione di sicurezza dall'elenco. Una configurazione di sicurezza specifica come vengono crittografati i dati del target Amazon S3: nessuna crittografia, crittografia lato server con chiavi gestite da AWS KMS(SSE-KMS) o chiavi di crittografia gestite da Amazon S3 (SSE-S3).
**Crittografia lato server**
Se selezioni questa opzione, quando il processo ETL scrive in Amazon S3, i dati vengono crittografati quando sono inattivi tramite crittografia SSE-S3. Vengono crittografati sia i dati di destinazione Amazon S3 sia tutti gli altri dati scritti in una directory temporanea Amazon S3. Questa opzione viene passata come parametro del processo. Per ulteriori informazioni, consulta [Protezione dei dati mediante la crittografia lato server con chiavi di crittografia gestite da Amazon S3 (SSE-S3)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html) nella *Guida per l'utente di Amazon Simple Storage Service*.
Questa opzione viene ignorata se viene specificata una configurazione di protezione.
**Opzione per l'uso del catalogo dati di Glue come metastore Hive**
Seleziona di utilizzare AWS Glue Data Catalog come metastore Hive. Il ruolo IAM utilizzato per il processo deve disporre dell'autorizzazione `glue:CreateDatabase`. Viene creato un database chiamato "default" nel catalogo dati, nel caso non fosse già presente.
**Connessioni**
Scegli una configurazione VPC per accedere alle origini dati di Amazon S3 situate nel cloud privato virtuale (VPC). Puoi creare e gestire una connessione di rete in AWS Glue. Per ulteriori informazioni, consulta [Connessione ai dati](glue-connections.md).
**Libraries (Librerie)**
**Percorso della libreria Python, percorso dipendente e JARs percorso dei file di riferimento**
Specificare queste opzioni se lo script le richiede. Puoi definire percorsi separati da virgole Amazon S3 per queste opzioni quando definisci il processo. Puoi sostituire tali percorsi quando esegui il processo. Per ulteriori informazioni, consulta [Fornire i propri script personalizzati](console-custom-created.md).
**Parametri Job**
Un insieme di coppie chiave-valore che vengono passate come parametri denominati allo script. Si tratta di valori predefiniti che vengono utilizzati quando lo script viene eseguito, ma è possibile ignorarli nei trigger o quando si esegue il processo. È necessario prefissare il nome della chiave con `--`; ad esempio: `--myKey`. I parametri del lavoro vengono passati come mappa quando si utilizza AWS Command Line Interface.
Per ulteriori esempi, vedere i parametri Python in [Passaggio di parametri Python in AWS Glue e accesso ai parametri](aws-glue-programming-python-calling.md#aws-glue-programming-python-calling-parameters).
**Tag**
Il tag si applica al processo tramite una **Tag key (Chiave tag)** e un **Tag value (Valore tag)** facoltativo. Una volta create, le chiavi di tag sono di sola lettura. Usa i tag su alcune risorse per facilitarne l'organizzazione e l'individuazione. Per ulteriori informazioni, consulta [AWS tag in AWS Glue](monitor-tags.md).
## Restrizioni per i processi che accedono alle tabelle gestite da Lake Formation
Tieni presente le seguenti note e restrizioni quando crei lavori che leggono o scrivono su tabelle gestite da AWS Lake Formation:
+ Le seguenti caratteristiche non sono supportate nei processi che accedono alle tabelle con filtri a livello di cella:
+ [Segnalibri di processo](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) ed [esecuzione limitata](https://docs.aws.amazon.com/glue/latest/dg/bounded-execution.html)
+ [Predicati pushdown](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns)
+ [Predicati delle partizioni dei cataloghi lato server](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-cat-predicates)
+ [enableUpdateCatalog](https://docs.aws.amazon.com/glue/latest/dg/update-from-job.html)
# Modifica degli script Spark nella console AWS Glue
Uno script contiene il codice che estrae i dati dalle fonti, li trasforma e li carica in obiettivi. AWS Glue esegue uno script quando avvia un processo.
Gli script ETL AWS Glue possono essere codificati in Python o Scala. Gli script Python utilizzano un linguaggio che è un'estensione del dialetto PySpark Python per i lavori di estrazione, trasformazione e caricamento (ETL). Lo script contiene *costrutti estesi* per gestire le trasformazioni ETL. Quando si genera automaticamente la logica del codice sorgente per un processo, viene creato lo script. Puoi modificare questo script oppure puoi fornire il tuo script per elaborare il lavoro ETL.
Per informazioni sulla definizione e sulla modifica di script in AWS Glue, consulta la pagina [AWS Glue guida alla programmazione](edit-script.md).
## Librerie o file aggiuntivi
Se lo script richiede librerie o file aggiuntivi, puoi specificarli come segue:
**Percorso della libreria Python**
Percorsi Amazon Simple Storage Service (Amazon S3) separati da virgole per le librerie Python richieste dallo script.
È possibile utilizzare solo librerie Python pure. Le librerie che si basano sulle estensioni C, come la libreria di analisi dati Python pandas, non sono ancora supportate.
**Percorso dei vasi dipendenti**
Percorsi Amazon S3 separati da virgole dei file JAR richiesti dallo script.
Al momento possono essere utilizzate solo le librerie pure Java o Scala (2.11).
**Percorso dei file di riferimento**
Percorsi Amazon S3 separati da virgole di file aggiuntivi (ad esempio i file di configurazione) richiesti dallo script.
# Processi (legacy)
Uno script contiene il codice che estrae, trasforma e carica il lavoro (ETL). Puoi fornire uno script personalizzato oppure AWS Glue può generare uno script seguendo le tue indicazioni. Per informazioni su come creare gli script, consulta [Fornire i propri script personalizzati](console-custom-created.md).
Puoi modificare uno script nella console AWS Glue. Quando modifichi uno script, puoi aggiungere origini, destinazioni e trasformazioni.
**Per modificare uno script**
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/). Selezionare **Processi** scheda.
1. Scegli un processo nell'elenco, quindi **Action** (Operazione), **Edit script** (Modifica script) per aprire l'editor di script.
Puoi inoltre accedere all'editor di script dalla pagina dei dettagli del processo. Scegli la scheda **Script**, quindi scegli **Edit script (Modifica script)**.
## Editor di script
L'editor di script AWS Glue permette di inserire, modificare ed eliminare origini, destinazioni e trasformazioni nello script. L'editor di script visualizza sia lo script sia un diagramma per aiutarti a visualizzare il flusso di dati.
Per creare un diagramma per lo script, scegli **Generate diagram (Genera diagramma)**. AWS Glue usa righe di annotazione nello script che iniziano con **\$1 \$1** per visualizzare il diagramma. Per rappresentare correttamente lo script nel diagramma, è necessario mantenere sincronizzati i parametri nelle annotazioni e i parametri nel codice Apache Spark.
L'editor di script ti consente di aggiungere modelli di codice ovunque il cursore sia posizionato nello script. Nella parte superiore dell'editor, sceglie tra le seguenti opzioni:
+ Per aggiungere una tabella di origine allo script, scegli **Source** (Origine).
+ Per aggiungere una tabella di destinazione allo script, scegli **Target** (Destinazione).
+ Per aggiungere una posizione di destinazione allo script, scegli **Target location** (Posizione di destinazione).
+ Per aggiungere una trasformazione allo script, scegli **Transform** (Trasformazione). Per informazioni sulle funzioni richiamate nel tuo script, consulta [Programma gli script ETL di AWS Glue in PySpark](aws-glue-programming-python.md).
+ Per aggiungere una trasformazione Spigot allo script, scegli **Spigot**.
Nel codice inserito, modifica i `parameters` nelle annotazioni e nel codice Apache Spark. Ad esempio, se aggiungi una trasformazione **Spigot**, verifica che `path` sia sostituito sia nella riga di annotazione `@args` sia nella riga di codice `output`.
La scheda **Logs** (Log) mostra i log che sono associati al tuo processo durante l'esecuzione. Vengono visualizzate le 1.000 righe più recenti.
La scheda **Schema** mostra lo schema delle origini e delle destinazioni selezionate, quando disponibili nel catalogo dati.
# Monitoraggio dei dati elaborati mediante segnalibri di processo
AWS Glue monitora i dati già elaborati durante una precedente esecuzione di un processo ETL conservando le informazioni sullo stato dall'esecuzione del processo. Questa informazione sullo stato persistente è chiamato *segnalibro di processo*. I segnalibri del processo aiutano AWS Glue a mantenere le informazioni sullo stato e prevenire la rielaborazione dei dati precedenti. Con i segnalibri del processo, è possibile elaborare nuovi dati quando vengono rieseguiti su un intervallo pianificato. Un segnalibro di un processo è costituito dagli stati dei vari elementi dei processi, come le origini, le trasformazioni e le destinazioni. Ad esempio, il processo ETL potrebbe leggere nuove partizioni in un file Amazon S3. AWS Glue tiene traccia delle partizioni che sono state elaborate correttamente dal processo al fine di evitare elaborazioni ripetute o dati duplicati nel datastore di destinazione del processo.
I segnalibri di processo sono implementati per le origini dati JDBC, la trasformazione Relationalize e alcune origini Amazon Simple Storage Service (Amazon S3). La tabella seguente elenca i formati di origine Amazon S3 supportati da AWS Glue per i segnalibri del processo.
| Versione AWS Glue | Formati Amazon S3 di origine |
| --- | --- |
| Versione 0.9 | JSON, CSV, Apache Avro, XML |
| Versione 1.0 e successive. | JSON, CSV, Apache Avro, XML, Parquet, ORC |
Per ulteriori informazioni sulle versioni AWS Glue, consulta [Definire le proprietà di processo per i processi Spark](add-job.md#create-job).
La funzionalità dei segnalibri di lavoro ha funzionalità aggiuntive quando si accede tramite AWS Glue script. Quando si sfoglia lo script generato, è possibile visualizzare contesti di trasformazione correlati a questa funzionalità. Per ulteriori informazioni, consulta [Utilizzo di segnalibri di processo](programming-etl-connect-bookmarks.md).
**Topics**
+ [Utilizzo di segnalibri di processo in AWS Glue](#monitor-continuations-implement)
+ [Dettagli operativi della funzione dei segnalibri di processo](#monitor-continuations-script)
## Utilizzo di segnalibri di processo in AWS Glue
L'opzione di segnalibro di processo viene passata come parametro all'avvio del processo. La tabella seguente descrive le opzioni per impostare i segnalibri di processo nella console AWS Glue.
****
| Segnalibro Job | Description |
| --- | --- |
| Attiva | Provoca l'aggiornamento dello stato del processo dopo un'esecuzione per tenere traccia dei dati elaborati in precedenza. Se il processo ha un'origine con un supporto segnalibro del processo, questo tiene traccia dei dati elaborati e, quando un processo viene eseguito, elabora i nuovi dati a partire dall'ultimo punto di controllo. |
| Disabilita | I segnalibri del processo non vengono utilizzati e il processo elabora sempre l'intero set di dati. L'utente è responsabile della gestione dell'output delle esecuzioni di job precedenti. Questa è l’impostazione predefinita. |
| Metti in pausa | Elabora i dati incrementali dall'ultima esecuzione riuscita o i dati nell'intervallo identificato dalle seguenti opzioni secondarie, senza aggiornare lo stato dell'ultimo segnalibro. L'utente è responsabile della gestione dell'output delle esecuzioni di job precedenti. Le due opzioni secondarie sono: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitor-continuations.html) Lo stato dei segnalibri di processo non viene aggiornato quando viene specificato questo set di opzioni. Le opzioni secondarie sono facoltative, tuttavia se utilizzate, entrambe le opzioni secondarie devono essere specificate. |
Per informazioni dettagliate sui parametri passati a un processo nella riga di comando e, in particolare, sui segnalibri di lavoro, consulta [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md).
Per le origini di input Amazon S3, i segnalibri del processo AWS Glue controllano l'ora dell'ultima modifica degli oggetti per individuare gli oggetti da rielaborare. Se i dati dell'origine di input sono stati modificati dall'ultima esecuzione del processo, i file vengono rielaborati alla nuova esecuzione del processo.
Per le origini JDBC, si applicano le seguenti regole:
+ Per ogni tabella, AWS Glue utilizza una o più colonne come chiavi di segnalibro per determinare i dati nuovi ed elaborati. Le chiavi dei segnalibri si combinano per formare un'unica chiave composta.
+ Per impostazione predefinita, AWS Glue utilizza la chiave primaria come chiave di segnalibro, a condizione che sia in ordine sequenziale (senza spazi vuoti) crescente o decrescente.
+ È possibile specificare le colonne da utilizzare come chiavi di segnalibro nello script AWS Glue . Per ulteriori informazioni sull'utilizzo dei segnalibri Job negli AWS Glue script, vedere. [Utilizzo di segnalibri di processo](programming-etl-connect-bookmarks.md)
+ AWS Glue non supporta l'utilizzo di colonne che fanno distinzione tra maiuscole e minuscole come chiavi di segnalibro del processo.
È possibile ripristinare i segnalibri di processo per i processi ETL di AWS Glue Spark a qualsiasi esecuzione precedente del processo. È possibile supportare meglio gli scenari di recupero dei dati ripristinando i segnalibri di lavoro a qualsiasi esecuzione di lavoro precedente, con conseguente esecuzione del lavoro di rielaborazione dei dati solo relativi all'esecuzione del lavoro con segnalibro.
Se hai intenzione di rielaborare tutti i dati utilizzando lo stesso processo, reimposta il segnalibro del processo. Per reimpostare lo stato del segnalibro del processo, utilizza la console AWS Glue, l'operazione API [ResetJobBookmark azione (Python: reset\$1job\$1bookmark)](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-ResetJobBookmark) o la AWS CLI. Ad esempio, inserisci il seguente comando utilizzando AWS CLI:
```
aws glue reset-job-bookmark --job-name my-job-name
```
Quando si riavvolge o si reimposta un segnalibro, AWS Glue non pulisce i file di destinazione, perché potrebbero esserci più destinazioni e le destinazioni non sono monitorate con i segnalibri di processo. Solo i file di origine vengono tracciati con i segnalibri di processo. È possibile creare diverse destinazioni dell'output durante il riavvolgimento e la rielaborazione dei file di origine per evitare la duplicazione dei dati nell'output.
AWS Glue tiene traccia dei segnalibri dei processi per ogni processo. All'eliminazione del processo, seguirà l'eliminazione del segnalibro di processo.
In alcuni casi, potresti aver abilitato i segnalibri del processo AWS Glue, ma il processo ETL rielabora i dati già elaborati in una esecuzione precedente. Per ulteriori informazioni sulla risoluzione delle cause comuni di questo errore, consulta [Risoluzione degli errori di configurazione comuni di Glue](glue-troubleshooting-errors.md).
## Dettagli operativi della funzione dei segnalibri di processo
Questa sezione descrive ulteriori dettagli operativi utilizzando i segnalibri del processo.
I segnalibri del processo archiviano gli stati per un processo. Ogni istanza dello stato viene contrassegnata da un nome processo e da un numero di versione. Quando uno script richiama `job.init`, ne recupera lo stato e ottiene sempre la versione più recente. Uno stato contiene più elementi dello stato, specifici per ogni origine, trasformazione e istanza sink nello script. Gli elementi dello stato sono identificati da un contesto di trasformazione collegato all'elemento corrispondente (origine, trasformazione o sink) nello script. Gli elementi dello stato vengono salvati in modo atomico quando `job.commit` viene richiamato dallo script dell'utente. Lo script ottiene dagli argomenti il nome del processo e l'opzione di controllo per i segnalibri del processo.
Gli elementi dello stato nel segnalibro del processo sono origine, trasformazione oppure dati specifici del sink. Ad esempio, supponiamo che si desideri leggere i dati incrementali da una posizione Amazon S3 costantemente scritta da un processo upstream o da un processo. In questo caso, lo script deve determinare quanto è stato elaborato fino a ora. L'implementazione del segnalibro del processo per l'origine Amazon S3 salva le informazioni in modo che, quando il processo viene eseguito nuovamente, è possibile filtrare solo i nuovi oggetti utilizzando le informazioni salvate e ricalcolare lo stato per l'esecuzione successiva del processo. Un timestamp viene utilizzato per filtrare i nuovi file.
In aggiunta agli elementi dello stato, i segnalibri del processo dispongono di un *numero di esecuzione*, un *numero di tentativo* e un *numero di versione*. Il numero di esecuzione monitora l'esecuzione del processo e il numero di tentativo registra i tentativi di esecuzione di un processo. Il numero di esecuzione di un processo è un numero che aumenta in maniera monotona e che subisce incrementi a ogni esecuzione riuscita. Il numero di tentativi monitora i tentativi per ogni esecuzione e viene incrementato solo in caso di un'esecuzione dopo un tentativo non riuscito. Il numero di versione aumenta in maniera monotona e monitora gli aggiornamenti a un segnalibro del processo.
Nel database dei AWS Glue servizi, gli stati dei segnalibri per tutte le trasformazioni vengono memorizzati insieme come coppie chiave-valore:
```
{
"job_name" : ...,
"run_id": ...,
"run_number": ..,
"attempt_number": ...
"states": {
"transformation_ctx1" : {
bookmark_state1
},
"transformation_ctx2" : {
bookmark_state2
}
}
}
```
**Best practice**
Di seguito sono indicate le best practice per l'utilizzo dei segnalibri di processo.
+ *Non modificare la proprietà dell'origine dati con il segnalibro abilitato*. Ad esempio, esiste un datasource0 che punta a un percorso di input di Amazon S3 A e il lavoro è stato letto da un'origine che è in esecuzione per diversi round con il segnalibro abilitato. Se modifichi il percorso di input di datasource0 nel percorso Amazon S3 B senza modificare il`transformation_ctx`, il AWS Glue job utilizzerà il vecchio stato del segnalibro memorizzato. Ciò comporterà la mancanza o il salto di file nel percorso di input B, come si suppone AWS Glue che tali file siano stati elaborati in esecuzioni precedenti.
+ *Utilizzare una tabella di catalogo con segnalibri per una migliore gestione delle partizioni*. I segnalibri funzionano sia per le origini dati del Catalogo dati che per le opzioni. Tuttavia, è difficile creare remove/add nuove partizioni con l'approccio from options. L'utilizzo di una tabella di catalogo con crawler può fornire una migliore automazione per tracciare le [partizioni](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition) appena aggiunte e ti offre la flessibilità necessaria per selezionare partizioni particolari con [Predicato pushdown](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html).
+ *Utilizzo dell'[elenco di file AWS Glue Amazon S3](https://aws.amazon.com/premiumsupport/knowledge-center/glue-oom-java-heap-space-error/) per set di dati di grandi dimensioni*. Un segnalibro elenca tutti i file sotto ogni partizione di input e esegue il filering, quindi se ci sono troppi file sotto una singola partizione il segnalibro può essere eseguito nel driver OOM. Usa il lister di file AWS Glue Amazon S3 per evitare di elencare tutti i file in memoria contemporaneamente.
# Memorizzazione dei dati shuffle di Spark
Lo shuffle rappresenta un passaggio importante in un processo Spark quando i dati vengono riorganizzati tra le partizioni. È necessario perché trasformazioni estese, come `join`, ` groupByKey`, `reduceByKey` e `repartition`, hanno bisogno di informazioni da altre partizioni per completare l'elaborazione. Spark raccoglie i dati richiesti da ciascuna partizione e li combina in una nuova partizione. Durante uno shuffle, i dati vengono scritti su disco e trasferiti attraverso la rete. Di conseguenza, l'operazione di shuffle è legata alla capacità del disco locale. Spark genera un errore `No space left on device` o ` MetadataFetchFailedException` quando sull'executor non è rimasto sufficiente spazio su disco e non vi è un ripristino.
**Nota**
AWS Glue Il plug-in Spark shuffle con Amazon S3 è supportato solo per i lavori ETL. AWS Glue
**Soluzione**
Con AWS Glue, è ora possibile usare Amazon S3 per archiviare i dati shuffle Spark. Amazon S3 è un servizio di archiviazione di oggetti che offre scalabilità, disponibilità dei dati, sicurezza e prestazioni tra le migliori del settore. Questa soluzione disaggrega calcolo e storage per i processi Spark e offre elasticità completa e storage per lo shuffle a basso costo, consentendo di eseguire in modo affidabile i carichi di lavoro con shuffle intensivo.
![\[Spark workflow showing Map and Reduce stages using Amazon S3 for shuffle data storage.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/gs-s3-shuffle-diagram.png)
Stiamo introducendo un nuovo plug-in di archiviazione cloud shuffle per Apache Spark per utilizzare Amazon S3. Puoi attivare lo shuffle Amazon S3 per eseguire i processi AWS Glue in modo affidabile senza errori se sono legati alla capacità del disco locale per operazioni di shuffle di grandi dimensioni. In alcuni casi, lo shuffle su Amazon S3 è leggermente più lento del disco locale (o EBS) se si dispone di un numero elevato di piccole partizioni o file shuffle scritti su Amazon S3.
## Prerequisiti per l'utilizzo del plug-in Cloud Shuffle Storage
Per utilizzare il Cloud Shuffle Storage Plugin con i job AWS Glue ETL, è necessario quanto segue:
+ Un bucket Amazon S3 situato nella stessa regione in cui viene eseguito il processo, per archiviare i dati intermedi e i dati riversati. Il prefisso Amazon S3 dell'archiviazione con shuffle può essere specificato con `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket/prefix/`, come nell'esempio seguente:
```
--conf spark.shuffle.glue.s3ShuffleBucket=s3://glue-shuffle-123456789-us-east-1/glue-shuffle-data/
```
+ Imposta le policy del ciclo di vita dell'archiviazione di Amazon S3 sul *prefisso* (come `glue-shuffle-data`), poiché lo shuffle manager non pulisce i file al termine del processo. Lo shuffle intermedio e i dati riversati devono essere eliminati al termine di un processo. Gli utenti possono impostare policy del ciclo di vita breve sul prefisso. Le istruzioni per configurare il ciclo di vita per Amazon S3 sono disponibili nella sezione [Setting lifecycle configuration on a bucket](https://docs.aws.amazon.com//AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html) nella Guida per l'utente di Amazon Simple Storage Service.
## Utilizzo di AWS Glue Spark shuffle manager dalla console AWS
Per configurare AWS Glue Spark shuffle manager utilizzando la AWS Glue console o AWS Glue Studio durante la configurazione di un job: scegli il parametro **-- write-shuffle-files-to -s3 job per attivare Amazon S3** shuffling per il job.
![\[Job parameters interface showing --write-shuffle-files- parameter and option to add more.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/gs-s3-shuffle.png)
## Utilizzo del plug-in shuffle di AWS Glue Spark
I seguenti parametri di processo attivano e regolano AWS Glue shuffle manager. Questi parametri sono flag, quindi i valori forniti non vengono considerati.
+ `--write-shuffle-files-to-s3`: il flag principale, che abilita lo shuffle manager di AWS Glue Spark all'utilizzo dei bucket Amazon S3 per scrivere e leggere i dati shuffle. Quando il flag non è specificato, lo shuffle manager non viene utilizzato.
+ `--write-shuffle-spills-to-s3`: (supportato solo in AWS Glue versione 2.0). Un flag facoltativo che consente di scaricare i file riversati nei bucket Amazon S3, fornendo ulteriore resilienza al processo Spark. Questo è necessario solo per carichi di lavoro di grandi dimensioni che riversano molti dati sul disco. Quando il flag non è specificato, non viene scritto alcun file riversato intermedio.
+ ` --conf spark.shuffle.glue.s3ShuffleBucket=s3://` — Un altro flag opzionale che specifica il bucket Amazon S3 in cui vengono scritti i file shuffle. Per impostazione `--TempDir` predefinita, /shuffle-data. AWS Glue 3.0\$1 supporta la scrittura di file shuffle su più bucket specificando i bucket con un delimitatore di virgola, come in. `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket-1/prefix,s3://shuffle-bucket-2/prefix/` L'utilizzo di più bucket migliora le prestazioni.
Per abilitare la crittografia a riposo per i dati shuffle, fornisci le impostazioni di configurazione della sicurezza. Per ulteriori informazioni sulle configurazioni di sicurezza, consulta [Configurazione della crittografia in AWS Glue](set-up-encryption.md). AWS Glue supporta tutte le altre configurazioni relative ai dati shuffle fornite da Spark.
**File binari software per il plug-in di archiviazione cloud shuffle**
Puoi anche scaricare i file binari software del plug-in di archiviazione cloud shuffle per Apache Spark con la licenza Apache 2.0 ed eseguirli in qualsiasi ambiente Spark. Il nuovo plug-in include il supporto per Amazon S3 e può anche essere facilmente configurato per utilizzare altre forme di archiviazione cloud come [Google Cloud Storage e Microsoft Azure Blob Storage](https://github.com/aws-samples/aws-glue-samples/blob/master/docs/cloud-shuffle-plugin/README.md). out-of-the Per ulteriori informazioni, consulta [Plug-in di archiviazione cloud shuffle per Apache Spark](https://docs.aws.amazon.com/glue/latest/dg/cloud-shuffle-storage-plugin.html).
**Note e limitazioni**
Di seguito sono riportate note o limitazioni per AWS Glue shuffle manager:
+ AWS Glue shuffle manager non elimina automaticamente i file di dati shuffle (temporanei) archiviati nel bucket Amazon S3 dopo il completamento di un processo. Per garantire la protezione dei dati, segui le istruzioni riportate nella sezione [Prerequisiti per l'utilizzo del plug-in Cloud Shuffle Storage](#monitor-spark-shuffle-manager-prereqs) prima di abilitare il plug-in Cloud Shuffle Storage.
+ È possibile usare questa funzionalità se i dati sono asimmetrici.
# Plug-in di archiviazione cloud shuffle per Apache Spark
Il plug-in di archiviazione cloud shuffle è un plug-in Apache Spark compatibile con l'[API `ShuffleDataIO`](https://github.com/apache/spark/blob/master/core/src/main/java/org/apache/spark/shuffle/api/ShuffleDataIO.java) che consente di archiviare dati shuffle su sistemi di archiviazione cloud (come Amazon S3). Ti aiuta a integrare o sostituire la capacità di archiviazione su disco locale per operazioni shuffle di grandi dimensioni, generalmente innescate da trasformazioni come `groupByKey` e `repartition` nelle applicazioni Spark `join``reduceByKey`, riducendo così gli errori comuni o la price/performance dislocazione dei processi e delle pipeline di analisi dei dati senza server.
**AWS Glue**
Le versioni 3.0 e 4.0 di AWS Glue includono il plug-in preinstallato e pronto per abilitare lo shuffling su Amazon S3 senza passaggi aggiuntivi. Per ulteriori informazioni, consulta [Plug-in shuffle di AWS Glue Spark con Amazon S3](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-shuffle-manager.html) per abilitare la funzionalità per le tue applicazioni Spark.
**Altri ambienti Spark**
Il plug-in richiede che in altri ambienti Spark siano impostate le seguenti configurazioni Spark:
+ `--conf spark.shuffle.sort.io.plugin.class=com.amazonaws.spark.shuffle.io.cloud.ChopperPlugin`: indica a Spark di utilizzare questo plug-in per Shuffle IO.
+ `--conf spark.shuffle.storage.path=s3://bucket-name/shuffle-file-dir`: il percorso in cui verranno archiviati i file shuffle.
**Nota**
Il plug-in sovrascrive una classe principale di Spark. Di conseguenza, il jar del plug-in deve essere caricato prima dei jar di Spark. Ciò è possibile utilizzando `userClassPathFirst` in ambienti YARN on-premise se il plug-in viene utilizzato all'esterno di AWS Glue.
## Creazione di bundle per il plug-in con le applicazioni Spark
È possibile raggruppare il plug-in con le applicazioni Spark e le distribuzioni Spark (versioni 3.1 e successive) aggiungendo la dipendenza del plug-in nel file Maven`pom.xml` mentre si sviluppano le applicazioni Spark in locale. Per ulteriori informazioni sulle versioni del plug-in e di Spark, consulta [Versioni del plug-in](#cloud-shuffle-storage-plugin-versions).
```
...
aws-glue-etl-artifacts
https://aws-glue-etl-artifacts.s3.amazonaws.com/release/
...
com.amazonaws
chopper-plugin
3.1-amzn-LATEST
```
In alternativa, puoi scaricare i file binari direttamente dagli artefatti di AWS Glue Maven e includerli nell'applicazione Spark come segue.
```
#!/bin/bash
sudo wget -v https://aws-glue-etl-artifacts.s3.amazonaws.com/release/com/amazonaws/chopper-plugin/3.1-amzn-LATEST/chopper-plugin-3.1-amzn-LATEST.jar -P /usr/lib/spark/jars/
```
Esempio spark-submit
```
spark-submit --deploy-mode cluster \
--conf spark.shuffle.storage.s3.path=s3:/// \
--conf spark.driver.extraClassPath= \
--conf spark.executor.extraClassPath= \
--class s3:/// \
```
## Configurazioni facoltative
Questi sono i valori delle configurazioni facoltative che controllano il comportamento dello shuffle di Amazon S3.
+ `spark.shuffle.storage.s3.enableServerSideEncryption`: Enable/disable S3 SSE per shuffle e spill file. Il valore predefinito è `true`.
+ `spark.shuffle.storage.s3.serverSideEncryption.algorithm`: l'algoritmo SSE da utilizzare. Il valore predefinito è `AES256`.
+ `spark.shuffle.storage.s3.serverSideEncryption.kms.key`: l'ARN della chiave KMS quando è abilitato SSE aws:kms.
Oltre a queste configurazioni, potrebbe essere necessario impostarne altre come `spark.hadoop.fs.s3.enableServerSideEncryption` e **configurazioni aggiuntive specifiche dell'ambiente** per garantire l'applicazione della crittografia appropriata per il caso d'uso.
## Versioni del plug-in
Questo plugin è supportato per le versioni Spark associate a ciascuna versione. AWS Glue La tabella seguente mostra la AWS Glue versione, la versione Spark e la versione del plug-in associata con la posizione Amazon S3 per il file binario del software del plug-in.
| Versione AWS Glue | Versione di Spark | Versione del plug-in | Posizione di Amazon S3. |
| --- | --- | --- | --- |
| 3.0 | 3.1 | 3.1-amzn-LATEST | s3:///-Plugin-3.1-amzn-latest.jar aws-glue-etl-artifacts release/com/amazonaws/chopper-plugin/3.1-amzn-0/chopper |
| 4.0 | 3.3 | 3.3-amzn-LATEST | s3://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.3-amzn-0/chopper-Plugin-3.3-AMZN-latest.jar |
## Licenza
Il software del plug-in è concesso in licenza ai sensi della licenza Apache-2.0.
# Monitoraggio dei processi Spark AWS Glue
**Topics**
+ [Spark Metrics disponibile in AWS Glue Studio](#console-jobs-details-metrics-spark)
+ [Monitoraggio dei processi tramite l'interfaccia utente Web di Apache Spark](monitor-spark-ui.md)
+ [Monitoraggio con AWS Glue Job Run Insights](monitor-job-insights.md)
+ [Monitoraggio con Amazon CloudWatch](monitor-cloudwatch.md)
+ [Monitoraggio e debug dei processi](monitor-profile-glue-job-cloudwatch-metrics.md)
## Spark Metrics disponibile in AWS Glue Studio
La scheda **Metrics (Parametri)** mostra i parametri raccolti quando un processo viene eseguito ed è attivata la profilatura. Nei processi Spark vengono visualizzati i grafici seguenti:
+ Spostamento di dati ETL
+ Profilo di memoria: driver ed executor
Scegli **View additional metrics (Visualizza parametri aggiuntivi)** per visualizzare i grafici relativi agli elementi seguenti:
+ Spostamento di dati ETL
+ Profilo di memoria: driver ed executor
+ Distribuzione casuale dei dati tra executor
+ Carico CPU: driver ed executor
+ Esecuzione del processo: executor attivi, fasi completate e numero massimo di executor necessari
I dati di questi grafici vengono inseriti nelle CloudWatch metriche se il job è configurato per raccogliere metriche. Per ulteriori informazioni su come abilitare i parametri e interpretare i grafici, consulta [Monitoraggio e debug dei processi](monitor-profile-glue-job-cloudwatch-metrics.md).
**Example Grafico relativo allo spostamento di dati ETL**
Il grafico relativo allo spostamento di dati ETL mostra i parametri seguenti:
+ Numero di byte letti da Amazon S3 da tutti gli executor: [`glue.ALL.s3.filesystem.read_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes)
+ Numero di byte scritti in Amazon S3 da tutti gli executor: [`glue.ALL.s3.filesystem.write_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes)
![\[Grafico relativo allo spostamento di dati ETL nella scheda Metrics (Parametri) della console AWS Glue.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/job_detailed_etl.png)
**Example Grafico relativo al profilo di memoria**
Il grafico relativo al profilo di memoria mostra i parametri seguenti:
+ Frazione di memoria usata dall'heap JVM per questo driver (dimensione: 0-1) dal driver, da un executor identificato da *executorId* o da tutti gli executor—
+ [`glue.driver.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage)
+ [`glue.executorId.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.usage)
+ [`glue.ALL.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage)
![\[Grafico relativo al profilo di memoria nella scheda Metrics (Parametri) della console AWS Glue.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/job_detailed_mem.png)
**Example Grafico relativo alla distribuzione casuale dei dati tra executor**
Il grafico relativo alla distribuzione casuale dei dati tra executor mostra i parametri seguenti:
+ Numero di byte letti da tutti gli executor per distribuire i dati in modo casuale: [`glue.driver.aggregate.shuffleLocalBytesRead`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead)
+ Numero di byte scritti da tutti gli executor per distribuire i dati in modo casuale: [`glue.driver.aggregate.shuffleBytesWritten`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten)
![\[Grafico relativo alla distribuzione casuale dei dati tra executor nella scheda Metrics (Parametri) della console AWS Glue.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/job_detailed_data.png)
**Example Grafico relativo al carico CPU**
Il grafico relativo al carico CPU mostra i parametri seguenti:
+ Frazione del carico di sistema della CPU usata (dimensione: 0-1) dal driver, da un executor identificato da *executorId* o da tutti gli executor:
+ [`glue.driver.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.system.cpuSystemLoad)
+ [`glue.executorId.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.system.cpuSystemLoad)
+ [`glue.ALL.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.system.cpuSystemLoad)
![\[Grafico relativo al carico CPU nella scheda Metrics (Parametri) della console AWS Glue.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/job_detailed_cpu.png)
**Example Grafico relativo all'esecuzione del processo**
Il grafico relativo all'esecuzione del processo mostra i parametri seguenti:
+ Numero di executor attivamente in esecuzione: [`glue.driver.ExecutorAllocationManager.executors.numberAllExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors)
+ Numero di fasi completate: [`glue.aggregate.numCompletedStages`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages)
+ Numero massimo di executor necessari: [`glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors)
![\[Grafico relativo all'esecuzione del processo nella scheda Metrics (Parametri) della console AWS Glue.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/job_detailed_exec.png)
# Monitoraggio dei processi tramite l'interfaccia utente Web di Apache Spark
Puoi utilizzare l'interfaccia utente Web di Apache Spark per monitorare ed eseguire il debug dei processi ETL AWS Glue in esecuzione sul sistema di processi AWS Glue e anche delle applicazioni Spark in esecuzione sugli endpoint di sviluppo AWS Glue. L'interfaccia utente di Spark consente di controllare quanto segue per ogni processo:
+ Tempistica eventi di ogni fase Spark
+ Un grafo aciclico orientato (DAG) del processo
+ Piani fisici e logici per le query SparkSQL
+ Le variabili ambientali Spark sottostanti per ogni processo
Per ulteriori informazioni sull'utilizzo dell'interfaccia utente Web di Spark, consulta l'[interfaccia utente Web](https://spark.apache.org/docs/3.3.0/web-ui.html) nella documentazione di Spark. Per indicazioni su come interpretare i risultati dell'interfaccia utente di Spark per migliorare le prestazioni del tuo lavoro, consulta le [migliori pratiche per l'ottimizzazione delle prestazioni per i lavori di Apache Spark in AWS Glue Prescriptive](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/introduction.html) Guidance. AWS
Puoi vedere l'interfaccia utente di Spark nella console. AWS Glue È disponibile quando un AWS Glue job viene eseguito su versioni AWS Glue 3.0 o successive con registri generati nel formato Standard (anziché legacy), che è l'impostazione predefinita per i lavori più recenti. Se disponi di file di registro di dimensioni superiori a 0,5 GB, puoi abilitare il supporto roll-log per i job run su versioni AWS Glue 4.0 o successive per semplificare l'archiviazione, l'analisi e la risoluzione dei problemi dei log.
Puoi abilitare l'interfaccia utente di Spark utilizzando la AWS Glue console o AWS Command Line Interface ()AWS CLI. Quando abiliti l'interfaccia utente di Spark, i processi ETL AWS Glue e le applicazioni Spark su endpoint di sviluppo AWS Glue possono eseguire il backup dei log degli eventi Spark in un percorso specificato in Amazon Simple Storage Service (Amazon S3). Puoi utilizzare i log degli eventi sottoposti a backup in Amazon S3 con l'interfaccia utente di Spark sia in tempo reale, ovvero durante l'esecuzione del processo, sia al termine dello stesso. Sebbene i log rimangano in Amazon S3, l'interfaccia utente Spark nella console può AWS Glue visualizzarli.
## Permissions
Per utilizzare l'interfaccia utente Spark nella AWS Glue console, puoi utilizzare `UseGlueStudio` o aggiungere tutti i singoli servizi. APIs Tutti APIs sono necessari per utilizzare completamente l'interfaccia utente di Spark, tuttavia gli utenti possono accedere alle funzionalità di SparkUI aggiungendo il relativo servizio APIs nell'autorizzazione IAM per un accesso granulare.
`RequestLogParsing` è la più importante in quanto esegue l'analisi dei log. I restanti servono per leggere APIs i rispettivi dati analizzati. Ad esempio, `GetStages` fornisce l'accesso ai dati relativi a tutte le fasi di un processo Spark.
L'elenco dei servizi dell'interfaccia utente Spark APIs mappati è riportato di `UseGlueStudio` seguito nella policy di esempio. La policy riportata di seguito fornisce accesso per utilizzare solo le funzionalità dell'interfaccia utente di Spark. Per aggiungere altre autorizzazioni come Amazon S3 e IAM, [consulta Creazione di politiche IAM personalizzate](https://docs.aws.amazon.com/glue/latest/dg/getting-started-min-privs.html#getting-started-all-gs-privs.html) per. AWS Glue Studio
L'elenco dei servizi di interfaccia utente Spark APIs mappati `UseGlueStudio` è riportato di seguito nella policy di esempio. Quando si utiliza un'API del servizio Spark UI, usare il seguente namespace: `glue:`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowGlueStudioSparkUI",
"Effect": "Allow",
"Action": [
"glue:RequestLogParsing",
"glue:GetLogParsingStatus",
"glue:GetEnvironment",
"glue:GetJobs",
"glue:GetJob",
"glue:GetStage",
"glue:GetStages",
"glue:GetStageFiles",
"glue:BatchGetStageFiles",
"glue:GetStageAttempt",
"glue:GetStageAttemptTaskList",
"glue:GetStageAttemptTaskSummary",
"glue:GetExecutors",
"glue:GetExecutorsThreads",
"glue:GetStorage",
"glue:GetStorageUnit",
"glue:GetQueries",
"glue:GetQuery"
],
"Resource": [
"*"
]
}
]
}
```
------
## Limitazioni
+ L'interfaccia utente di Spark nella AWS Glue console non è disponibile per le esecuzioni di job avvenute prima del 20 novembre 2023 perché sono nel formato di registro precedente.
+ L'interfaccia utente di Spark nella AWS Glue console supporta i rolling log per la AWS Glue versione 4.0, come quelli generati di default nei job di streaming. La somma massima di tutti i file di eventi dei log in sequenza è di 2 GB. Per i AWS Glue lavori senza supporto per i rolllog, la dimensione massima del file degli eventi di registro supportata per SparkUI è 0,5 GB.
+ L'interfaccia utente di Spark serverless non è disponibile per i log degli eventi Spark archiviati in un bucket Amazon S3 a cui è possibile accedere solo dal proprio VPC.
## Esempio: interfaccia utente Web di Apache Spark
Questo esempio illustra come utilizzare l'interfaccia utente di Spark per comprendere le prestazioni del processo. Gli screenshot mostrano l'interfaccia utente Web di Spark fornita da un server della cronologia Spark autogestito. L'interfaccia utente Spark nella AWS Glue console offre visualizzazioni simili. Per ulteriori informazioni sull'utilizzo dell'interfaccia utente Web di Spark, consulta l'[interfaccia utente Web](https://spark.apache.org/docs/3.3.0/web-ui.html) nella documentazione di Spark.
Di seguito è riportato un esempio di un'applicazione Spark che legge da due origini dati, esegue una trasformazione join e la scrive in Amazon S3 nel formato Parquet.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from pyspark.sql.functions import count, when, expr, col, sum, isnull
from pyspark.sql.functions import countDistinct
from awsglue.dynamicframe import DynamicFrame
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'])
df_persons = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/persons.json")
df_memberships = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/memberships.json")
df_joined = df_persons.join(df_memberships, df_persons.id == df_memberships.person_id, 'fullouter')
df_joined.write.parquet("s3://aws-glue-demo-sparkui/output/")
job.commit()
```
La seguente visualizzazione DAG mostra le diverse fasi in questo processo Spark.
![\[Screenshot dell'interfaccia utente di Spark che mostra due fasi completate del processo 0.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/spark-ui1.png)
La seguente tempistica eventi per un processo mostra l'avvio, l'esecuzione e l'arresto di diversi executor Spark.
![\[Screenshot dell'interfaccia utente di Spark che mostra le fasi completate, non riuscite e attive di diversi executor Spark.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/spark-ui2.png)
La schermata seguente mostra i dettagli dei piani di query SparkSQL:
+ Piano logico esaminato
+ Piano logico analizzato
+ Piano logico ottimizzato
+ Piano fisico per l'esecuzione
![\[Piani di query SparkSQL: piano logico esaminato, analizzato e ottimizzato e piani fisici per l'esecuzione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/spark-ui3.png)
**Topics**
+ [Permissions](#monitor-spark-ui-limitations-permissions)
+ [Limitazioni](#monitor-spark-ui-limitations)
+ [Esempio: interfaccia utente Web di Apache Spark](#monitor-spark-ui-limitations-example)
+ [Abilitazione dell'interfaccia utente Web di Apache Spark per processi AWS Glue](monitor-spark-ui-jobs.md)
+ [Avvio del server della cronologia di Spark](monitor-spark-ui-history.md)
# Abilitazione dell'interfaccia utente Web di Apache Spark per processi AWS Glue
Puoi utilizzare l'interfaccia utente Web di Apache Spark per monitorare ed eseguire il debug dei processi ETL AWS Glue in esecuzione sul sistema di processi AWS Glue. Puoi configurare l'interfaccia utente di Spark tramite la console AWS Glue o AWS Command Line Interface (AWS CLI).
Ogni 30 secondi, AWS Glue esegue il backup dei log degli eventi Spark nel percorso Amazon S3 specificato.
**Topics**
+ [Configurazione dell'interfaccia utente di Spark (console)](#monitor-spark-ui-jobs-console)
+ [Configurazione dell'interfaccia utente di Spark (AWS CLI)](#monitor-spark-ui-jobs-cli)
+ [Configurazione dell'interfaccia utente di Spark per sessioni che utilizzano notebook](#monitor-spark-ui-sessions)
+ [Abilitare log in sequenza](#monitor-spark-ui-rolling-logs)
## Configurazione dell'interfaccia utente di Spark (console)
Segui queste fasi per configurare l'interfaccia utente di Spark mediante la Console di gestione AWS. Quando si crea un AWS Glue lavoro, l'interfaccia utente di Spark è abilitata per impostazione predefinita.
**Per attivare l'interfaccia utente di Spark durante la creazione o la modifica di un processo**
1. Accedi 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 riquadro di navigazione scegliere **Jobs (Processi)**.
1. Scegli **Aggiungi processo** o selezionane uno esistente.
1. In **Dettagli processo**, apri le **Proprietà avanzate**.
1. Nella scheda **Interfaccia utente Spark**, scegli **Scrivi i log dell'interfaccia utente di Spark su Amazon S3**.
1. Specifica un percorso Amazon S3 per archiviare i log di eventi Spark per il processo. Tieni presente che, se utilizzi una configurazione di sicurezza nel processo, la crittografia verrà applicata anche al file di log dell'interfaccia utente di Spark. Per ulteriori informazioni, consulta [Crittografia dei dati scritti da AWS Glue](encryption-security-configuration.md).
1. Nella sezione **Configurazione della registrazione e del monitoraggio dell'interfaccia utente di Spark**:
+ Seleziona **Standard** se stai generando log da visualizzare nella AWS Glue console.
+ Seleziona **Legacy** se stai generando i log da visualizzare su un server della cronologia di Spark.
+ Puoi anche decidere di generarli entrambi.
## Configurazione dell'interfaccia utente di Spark (AWS CLI)
Per generare log da visualizzare con l'interfaccia utente Spark, nella AWS Glue console, usa AWS CLI per passare i seguenti parametri di lavoro ai AWS Glue job. Per ulteriori informazioni, consulta [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md).
```
'--enable-spark-ui': 'true',
'--spark-event-logs-path': 's3://s3-event-log-path'
```
Per distribuire i log nelle rispettive posizioni precedenti, imposta il parametro `--enable-spark-ui-legacy-path` su `"true"`. Se non desideri generare log in entrambi i formati, rimuovi il parametro `--enable-spark-ui`.
## Configurazione dell'interfaccia utente di Spark per sessioni che utilizzano notebook
**avvertimento**
AWS Glue le sessioni interattive attualmente non supportano l'interfaccia utente Spark nella console. Configura un server della cronologia di Spark.
Se usi AWS Glue notebook, configura la configurazione di SparkUI prima di iniziare la sessione. A tale scopo, utilizza il magic per celle `%%configure`:
```
%%configure { “--enable-spark-ui”: “true”, “--spark-event-logs-path”: “s3://path” }
```
## Abilitare log in sequenza
L'abilitazione dei file di eventi SparkUI e Rolling Log per i job offre diversi vantaggi: AWS Glue
+ Rolling Log Event Files: con i file di eventi Rolling Log abilitati, AWS Glue genera file di log separati per ogni fase dell'esecuzione del lavoro, semplificando l'identificazione e la risoluzione dei problemi specifici di una particolare fase o trasformazione.
+ Migliore gestione dei log: i file di eventi dei log in sequenza aiutano a gestire i file di log in modo più efficiente. Invece di avere un unico file di log potenzialmente di grandi dimensioni, i log vengono suddivisi in file più piccoli e più gestibili in base alle fasi di esecuzione del processo. Questo può semplificare l'archiviazione, l'analisi e la risoluzione dei problemi dei log.
+ Migliore tolleranza agli errori: se un AWS Glue job fallisce o viene interrotto, i file degli eventi del rolling log possono fornire informazioni preziose sull'ultima fase riuscita, facilitando la ripresa del lavoro da quel punto piuttosto che ricominciare da zero.
+ Ottimizzazione dei costi: abilitando i file di eventi dei log in sequenza, è possibile risparmiare sui costi di archiviazione associati ai file di log. Invece di archiviare un singolo file di log potenzialmente di grandi dimensioni, vengono archiviati file di log più piccoli e più gestibili, il che può essere più conveniente, soprattutto per processi complessi o di lunga durata.
In un nuovo ambiente, gli utenti possono abilitare esplicitamente i log in sequenza tramite:
```
'—conf': 'spark.eventLog.rolling.enabled=true'
```
or
```
'—conf': 'spark.eventLog.rolling.enabled=true —conf
spark.eventLog.rolling.maxFileSize=128m'
```
Quando i log in sequenza sono attivati, `spark.eventLog.rolling.maxFileSize` specifica la dimensione massima del file di log degli eventi prima che venga eseguito il rollover. Se non specificato, il valore predefinito di questo parametro facoltativo è 128 MB. Il minimo è 10 MB.
La somma massima di tutti i file di eventi dei log in sequenza è di 2 GB. Per i AWS Glue lavori senza supporto per i rolllog, la dimensione massima del file degli eventi di registro supportata per SparkUI è 0,5 GB.
Puoi disattivare i log in sequenza per un processo di streaming inserendo una configurazione aggiuntiva. Tieni presente che la manutenzione di file di log molto grandi può essere costosa.
Per disattivare i log in sequenza, fornisci la seguente configurazione:
```
'--spark-ui-event-logs-path': 'true',
'--conf': 'spark.eventLog.rolling.enabled=false'
```
# Avvio del server della cronologia di Spark
Puoi utilizzare un server della cronologia Spark per visualizzare i log di Spark sull'infrastruttura. Puoi vedere le stesse visualizzazioni nella AWS Glue console per i AWS Glue job run su versioni AWS Glue 4.0 o successive con i log generati nel formato Standard (anziché legacy). Per ulteriori informazioni, consulta [Monitoraggio dei processi tramite l'interfaccia utente Web di Apache Spark](monitor-spark-ui.md).
Puoi avviare il server di cronologia Spark utilizzando un AWS CloudFormation modello che ospita il server su un'istanza EC2 o avviarlo localmente utilizzando Docker.
**Topics**
+ [Avvio del server di cronologia Spark e visualizzazione dell'interfaccia utente Spark utilizzando AWS CloudFormation](#monitor-spark-ui-history-cfn)
+ [Avvio del server della cronologia Spark e visualizzazione dell'interfaccia utente di Spark mediante Docker](#monitor-spark-ui-history-local)
## Avvio del server di cronologia Spark e visualizzazione dell'interfaccia utente Spark utilizzando AWS CloudFormation
Puoi utilizzare un AWS CloudFormation modello per avviare il server di cronologia Apache Spark e visualizzare l'interfaccia utente web di Spark. Questi modelli sono esempi che è necessario modificare per soddisfare i requisiti.
**Per avviare il server di cronologia Spark e visualizzare l'interfaccia utente Spark utilizzando CloudFormation**
1. Scegli uno dei pulsanti **Launch Stack (Avvia stack)** nella tabella seguente. Questo avvia lo stack sulla console. CloudFormation
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitor-spark-ui-history.html)
1. Nella pagina **Specify template (Specifica modello)**, scegli **Next (Avanti)**.
1. Nella pagina **Specify stack details (Specifica dettagli stack)**, immetti **Stack name (Nome stack)**. Inserisci informazioni aggiuntive sotto **Parameters (Parametri)**.
1.
**Configurazione dell'interfaccia utente di Spark**
Inserisci le informazioni che seguono:
+ **Intervallo di indirizzi IP**: l'intervallo di indirizzi IP che può essere utilizzato per visualizzare l'interfaccia utente di Spark. Se desideri limitare l'accesso da un intervallo di indirizzi IP specifico, devi utilizzare un valore personalizzato.
+ **Porta del server di cronologia**: la porta per l'interfaccia utente di Spark. Puoi usare il valore predefinito.
+ **Directory del log di eventi**: scegli la posizione in cui sono archiviati i log di eventi Spark dagli endpoint di sviluppo o dal processo AWS Glue. È necessario utilizzare **s3a://** per lo schema di percorso dei log di eventi.
+ **Posizione del pacchetto Spark**: puoi usare il valore di default.
+ **Keystore path: percorso** SSL/TLS keystore per HTTPS. Se desideri utilizzare un file keystore personalizzato, puoi specificare il percorso S3 `s3://path_to_your_keystore_file` qui. Se lasci questo parametro vuoto, viene generato e utilizzato un keystore basato su certificato autofirmato.
+ **Keystore password (Password keystore)**: inserisci una password del keystore SSL/TLS per HTTPS.
1.
**Configurazione di un'istanza EC2**
Inserisci le informazioni che seguono:
+ **Tipo di istanza**: il tipo di istanza Amazon EC2 che ospita il server della cronologia di Spark. Poiché questo modello avvia un'istanza Amazon EC2 nel tuo account, il costo di Amazon EC2 verrà addebitato separatamente nel tuo account.
+ **ID AMI più recente**: l'ID AMI di Amazon Linux 2 per l'istanza del server della cronologia di Spark. Puoi usare il valore predefinito.
+ **ID VPC**: l'ID del cloud privato virtuale (VPC) per l'istanza del server della cronologia di Spark. Puoi utilizzare uno qualsiasi dei file VPCs disponibili nel tuo account L'utilizzo di un VPC predefinito con un [ACL di rete predefinito non è consigliato](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html#default-network-acl). Per ulteriori informazioni, consulta [VPC predefinito e sottoreti predefinite](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html) e [Creazione di un VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC) nella *Guida per l'utente di Amazon VPC*.
+ **ID sottorete**: l'ID dell'istanza del server della cronologia di Spark. Puoi utilizzare una qualsiasi delle sottoreti nel VPC. Devi essere in grado di raggiungere la rete dal client alla sottorete. Se desideri accedere tramite Internet, devi utilizzare una sottorete pubblica che dispone dell'Internet gateway nella tabella di routing.
1. Scegli **Next (Successivo)**.
1. **Nella pagina **Configura le opzioni dello stack**, per utilizzare le credenziali utente correnti per determinare come CloudFormation creare, modificare o eliminare le risorse nello stack, scegli Avanti.** Inoltre, nella sezione **Autorizzazioni**, è possibile specificare un ruolo da utilizzare al posto delle autorizzazioni utente correnti, dopodiché occorre scegliere **Successivo**.
1. Nella pagina **Review (Revisione)**, rivedi il modello.
**Seleziona **Riconosco che CloudFormation potrebbe creare risorse IAM**, quindi scegli Create stack.**
1. Attendi la creazione dello stack.
1. Apri la scheda **Outputs (Output)**.
1. Copia l'URL di **SparkUiPublicUrl**se stai usando una sottorete pubblica.
1. Copia l'URL di **SparkUiPrivateUrl**se stai usando una sottorete privata.
1. Apri un browser Web e incolla l'URL. Ciò consente di accedere al server tramite HTTPS sulla porta specificata. Il tuo browser potrebbe non riconoscere il certificato del server. Se ciò accade, ignora la protezione e procedi comunque.
## Avvio del server della cronologia Spark e visualizzazione dell'interfaccia utente di Spark mediante Docker
Se preferisci l'accesso locale (non mantenere un'istanza EC2 per il server della cronologia Apache Spark), puoi anche utilizzare Docker per avviare il server della cronologia Apache Spark e visualizzare l'interfaccia utente di Spark in locale. Questo Dockerfile è un esempio che devi modificare per soddisfare i tuoi requisiti.
**Prerequisiti**
Per informazioni su come installare Docker sul laptop, vedi la [community di Docker Engine](https://docs.docker.com/install/).
**Per avviare il server della cronologia Spark e visualizzare l'interfaccia utente di Spark in locale utilizzando Docker**
1. Scarica file da GitHub.
Scarica il Dockerfile e `pom.xml` dagli [esempi di codice di AWS Glue](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/Spark_UI/).
1. Stabilisci se desideri utilizzare le credenziali utente o le credenziali dell'utente federato per accedere a AWS.
+ Per utilizzare le credenziali utente correnti per l'accesso AWS, recuperate i valori da utilizzare per ` AWS_ACCESS_KEY_ID` e `AWS_SECRET_ACCESS_KEY` nel `docker run` comando. Per ulteriori informazioni, consulta [Gestione delle chiavi di accesso per gli utenti IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html) nella *Guida per l’utente di IAM *.
+ Per utilizzare gli utenti federati SAML 2.0 per l'accesso AWS, ottieni i valori per` AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` e. ` AWS_SESSION_TOKEN` Per ulteriori informazioni, consulta la sezione relativa alla [richiesta di credenziali di sicurezza provvisorie](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)
1. Determina la posizione della directory del log di eventi da utilizzare nel comando `docker run`.
1. Crea l'immagine Docker utilizzando i file nella directory locale, utilizzando il nome ` glue/sparkui` e il tag `latest`.
```
$ docker build -t glue/sparkui:latest .
```
1. Crea e avvia il container docker.
Nei comandi seguenti, utilizza i valori ottenuti in precedenza nei passaggi 2 e 3.
1. Per creare il container docker utilizzando le credenziali utente, utilizza un comando simile al seguente
```
docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog
-Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY"
-p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer"
```
1. Per creare il container docker utilizzando credenziali temporanee, utilizzare ` org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider` come provider e fornisci i valori delle credenziali ottenuti nel passaggio 2. Per ulteriori informazioni, consulta [Using Session Credentials with Temporary AWSCredentials Provider](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html#Using_Session_Credentials_with_TemporaryAWSCredentialsProvider) nella documentazione *Hadoop: Integration with Amazon Web Services*.
```
docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog
-Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY
-Dspark.hadoop.fs.s3a.session.token=AWS_SESSION_TOKEN
-Dspark.hadoop.fs.s3a.aws.credentials.provider=org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider"
-p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer"
```
**Nota**
Questi parametri di configurazione provengono dal [Modulo Hadoop-AWS](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html). Potrebbe essere necessario aggiungere una configurazione specifica in base al proprio caso d'uso. Ad esempio: gli utenti in regioni isolate dovranno configurare il ` spark.hadoop.fs.s3a.endpoint`.
1. Apri `http://localhost:18080` nel browser per visualizzare l'interfaccia utente di Spark in locale.
# Monitoraggio con AWS Glue Job Run Insights
AWS Glue job run insights è una funzionalità AWS Glue che semplifica il debug e l'ottimizzazione dei job. AWS Glue AWS Glue fornisce l'[interfaccia utente di Spark](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui.html) e [CloudWatch registri e](https://docs.aws.amazon.com/glue/latest/dg/monitor-cloudwatch.html) metriche per il monitoraggio dei lavori. AWS Glue Con questa funzionalità, ottieni queste informazioni sull'esecuzione del tuo AWS Glue lavoro:
+ Numero di riga dello script di AWS Glue lavoro che ha avuto un errore.
+ Azione Spark eseguita per l’ultima volta nel piano di query di Spark poco prima dell’errore del processo.
+ Eventi di eccezione Spark correlati all’errore riscontrato in un flusso di log in ordine cronologico.
+ Analisi della causa principale e azione consigliata (come l’ottimizzazione dello script) per risolvere il problema.
+ Eventi Spark comuni (messaggi log relativi a un’azione Spark) con un’azione consigliata che affronta la causa principale.
Tutte queste informazioni sono disponibili utilizzando due nuovi flussi di log nei CloudWatch log dei lavori. AWS Glue
## Requisiti
La funzionalità AWS Glue job run insights è disponibile per AWS Glue le versioni 2.0 e successive. Puoi seguire la [guida alla migrazione](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html) per i lavori esistenti per aggiornarli da AWS Glue versioni precedenti.
## Abilitare Job Run Insights per un job AWS Glue ETL
Puoi abilitare Job Run Insights tramite AWS Glue Studio o la CLI.
### AWS Glue Studio
Quando si crea un lavoro tramite AWS Glue Studio, è possibile abilitare o disabilitare Job Run Insights nella scheda **Job Details**. Controlla che la casella **Generate job insights (Genera informazioni sul lavoro)** sia selezionata.
![\[Abilitazione di informazioni dell'esecuzione del processo in AWS Glue Studio.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-job-run-insights-1.png)
### Riga di comando
Se si crea un processo tramite CLI, è possibile avviare un processo con un singolo nuovo [parametro del processo](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html): `--enable-job-insights = true`.
Per impostazione predefinita, i flussi di log di informazioni dell'esecuzione del processo vengono creati nello stesso gruppo di log predefinito utilizzato da [Registrazione continua AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html), cioè `/aws-glue/jobs/logs-v2/`. È possibile impostare il nome del gruppo di log personalizzato, i filtri di log e le configurazioni del gruppo di log utilizzando lo stesso set di argomenti per la registrazione continua. Per ulteriori informazioni, consulta [Abilitazione della registrazione continua per i AWS Glue lavori](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html).
## Accesso al job run insights registra i flussi in CloudWatch
Con la funzione di informazioni dell'esecuzione del processo abilitata, potrebbero esserci due flussi di log creati quando un processo non riesce. Quando un processo termina correttamente, nessuno dei flussi viene generato.
1. *Flusso di log analisi delle eccezioni*: `-job-insights-rca-driver`. Questo flusso fornisce quanto segue:
+ Numero di riga dello script di AWS Glue lavoro che ha causato l'errore.
+ Azione Spark eseguita per ultima nel piano di query Spark (DAG).
+ Eventi brevi in ordine cronologico dal driver e dagli esecutori Spark correlati all'eccezione. Se necessario, è possibile trovare dettagli come i messaggi di errore completi, l'attività Spark non riuscita e il relativo ID esecutori che consentono di concentrarsi sul flusso di log dell'esecutore specifico per un'indagine più approfondita.
1. *Flusso di informazioni basato su regole*:
+ Analisi della causa principale e consigli su come correggere gli errori (ad esempio l'utilizzo di un parametro di lavoro specifico per ottimizzare le prestazioni).
+ Eventi Spark rilevanti come base per l'analisi della causa principale e un'azione consigliata.
**Nota**
Il primo flusso esiste solo se sono disponibili eventi di eccezione Spark per un'esecuzione del processo non riuscita e il secondo stream esisterà solo se sono disponibili informazioni per l'esecuzione del processo non riuscita. Ad esempio, se il processo termina correttamente, nessuno dei flussi verrà generato. Se il processo fallisce ma non esiste una regola definita dal servizio che può corrispondere allo scenario di errore, verrà generato solo il primo flusso.
Se il job viene creato da AWS Glue Studio, i link agli stream precedenti sono disponibili anche nella scheda dei dettagli del job run (Job run insights) come «Log di errore concisi e consolidati» e «Analisi e guida agli errori».
![\[La pagina Dettagli dell'esecuzione del processo che include collegamenti ai flussi di log.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-job-run-insights-2.png)
## Esempio di Job Run Insights AWS Glue
In questa sezione, presentiamo un esempio di come la funzione Informazioni dell'esecuzione del processo può essere d'aiuto nella risoluzione di un problema nel processo non riuscito. In questo esempio, un utente ha dimenticato di importare il modulo richiesto (tensorflow) in un AWS Glue job per analizzare e creare un modello di machine learning sui propri dati.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
from pyspark.sql.types import *
from pyspark.sql.functions import udf,col
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
data_set_1 = [1, 2, 3, 4]
data_set_2 = [5, 6, 7, 8]
scoresDf = spark.createDataFrame(data_set_1, IntegerType())
def data_multiplier_func(factor, data_vector):
import tensorflow as tf
with tf.compat.v1.Session() as sess:
x1 = tf.constant(factor)
x2 = tf.constant(data_vector)
result = tf.multiply(x1, x2)
return sess.run(result).tolist()
data_multiplier_udf = udf(lambda x:data_multiplier_func(x, data_set_2), ArrayType(IntegerType(),False))
factoredDf = scoresDf.withColumn("final_value", data_multiplier_udf(col("value")))
print(factoredDf.collect())
```
Senza la funzione di Informazioni dell'esecuzione del processo, data la non riuscita del processo, viene visualizzato solo questo messaggio generato da Spark:
`An error occurred while calling o111.collectToPython. Traceback (most recent call last):`
Il messaggio è ambiguo e limita l'esperienza di debug. In questo caso, questa funzionalità fornisce informazioni aggiuntive in due flussi di log: CloudWatch
1. Il flusso di log `job-insights-rca-driver`:
+ *Eventi eccezioni*: questo flusso di log fornisce gli eventi di eccezione Spark relativi all'errore raccolto dal driver Spark e dai diversi lavoratori distribuiti. Questi eventi ti aiutano a comprendere la propagazione ordinata nel tempo dell'eccezione man mano che il codice difettoso viene eseguito tra le attività, gli esecutori e le fasi di Spark distribuite tra i worker. AWS Glue
+ *Numeri riga*: questo flusso di log identifica la riga 21, che ha eseguito la chiamata per importare il modulo Python mancante che ha causato l'errore; identifica anche la riga 24, la chiamata all'azione Spark `collect()`, come ultima riga eseguita nello script.
![\[Il flusso di log. job-insights-rca-driver\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-job-run-insights-3.png)
1. Il flusso di log `job-insights-rule-driver`:
+ *Causa principale e raccomandazione*: oltre al numero di riga e al numero dell'ultima riga eseguita per l'errore nello script, questo flusso di log mostra l'analisi della causa principale e la raccomandazione per seguire il AWS Glue documento e impostare i parametri di lavoro necessari per utilizzare un modulo Python aggiuntivo nel lavoro. AWS Glue
+ *Evento base*: questo flusso di log mostra anche l'evento di eccezione Spark che è stato valutato con la regola definita dal servizio per dedurre la causa principale e fornire una raccomandazione.
![\[Il flusso di job-insights-rule-driver log.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-job-run-insights-4.png)
# Monitoraggio con Amazon CloudWatch
Puoi monitorare AWS Glue utilizzando Amazon CloudWatch, che raccoglie ed elabora i dati grezzi AWS Glue trasformandoli in metriche leggibili. near-real-time Queste statistiche vengono registrate per un periodo di due settimane, per permettere l'accesso alle informazioni storiche e offrire una prospettiva migliore sulle prestazioni del servizio o dell'applicazione Web. Per impostazione predefinita, i dati AWS Glue delle metriche vengono inviati automaticamente a. CloudWatch Per ulteriori informazioni, consulta [What Is Amazon CloudWatch?](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatch.html) nella *Amazon CloudWatch User Guide*, e[AWS Glue metriche](monitoring-awsglue-with-cloudwatch-metrics.md#awsglue-metrics).
**Registrazione continua**
AWS Glue supporta anche la registrazione continua in tempo reale per i processi AWS Glue. Quando la registrazione continua è abilitata per un lavoro, puoi visualizzare i log in tempo reale sulla AWS Glue console o sulla dashboard della CloudWatch console. Per ulteriori informazioni, consulta [Registrazione dei lavori AWS Glue](monitor-continuous-logging.md).
**Parametri di osservabilità**
Quando le **metriche di osservabilità del Job** sono abilitate, vengono generate Amazon CloudWatch metriche aggiuntive quando il lavoro viene eseguito. Utilizza i parametri AWS Glue di osservabilità per generare approfondimenti su ciò che accade all'interno di AWS Glue e migliorare la classificazione e l'analisi dei problemi.
**Topics**
+ [Monitoraggio AWS Glue tramite CloudWatch parametri Amazon](monitoring-awsglue-with-cloudwatch-metrics.md)
+ [Configurazione degli CloudWatch allarmi Amazon sui profili AWS Glue professionali](monitor-profile-glue-job-cloudwatch-alarms.md)
+ [Registrazione dei lavori AWS Glue](monitor-continuous-logging.md)
+ [Monitoraggio con parametri AWS Glue di osservabilità](monitor-observability.md)
# Monitoraggio AWS Glue tramite CloudWatch parametri Amazon
Puoi creare il profilo delle attività AWS Glue e monitorarle utilizzando il profiler dei processi AWS Glue. Raccoglie ed elabora i dati grezzi dei AWS Glue lavori in metriche leggibili e quasi in tempo reale archiviate in Amazon. CloudWatch Queste statistiche vengono conservate e aggregate in CloudWatch modo da poter accedere alle informazioni storiche per una migliore prospettiva sulle prestazioni dell'applicazione.
**Nota**
È possibile che vengano addebitati costi aggiuntivi quando si abilitano le metriche relative ai lavori e CloudWatch si creano metriche personalizzate. Per ulteriori informazioni, consulta i [ CloudWatch prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/).
## Panoramica dei parametri AWS Glue
Quando interagisci conAWS Glue, invia le metriche a. CloudWatch Puoi visualizzare queste metriche utilizzando la AWS Glue console (il metodo preferito), la dashboard della CloudWatch console o AWS Command Line Interface (AWS CLI).
**Per visualizzare i parametri usando il pannello di controllo della console AWS Glue**
Puoi visualizzare grafici dettagliati o di riepilogo dei parametri per un processo oppure grafici dettagliati per un'esecuzione di un processo.
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 riquadro di navigazione, scegli **Monitoraggio dell'esecuzione del processo**.
1. In **Esecuzioni del processo**, scegli **Operazioni** per interrompere un processo attualmente in esecuzione, visualizzare un processo o riavvolgerne il segnalibro.
1. Seleziona un processo, quindi scegli **Visualizza dettagli di esecuzione** per visualizzare informazioni aggiuntive sull'esecuzione del processo.
**Per visualizzare le metriche utilizzando la dashboard della CloudWatch console**
I parametri vengono raggruppati prima in base allo spazio dei nomi del servizio e successivamente in base alle diverse combinazioni di dimensioni all'interno di ogni spazio dei nomi.
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel riquadro di navigazione, seleziona **Parametri**.
1. Selezionare lo spazio dei nomi **Glue**.
**Per visualizzare le metriche utilizzando il AWS CLI**
+ Al prompt dei comandi utilizza il comando seguente.
```
1. aws cloudwatch list-metrics --namespace Glue
```
AWS Glueriporta le metriche CloudWatch ogni 30 secondi e i dashboard delle CloudWatch metriche sono configurate per visualizzarle ogni minuto. I parametri AWS Glue rappresentano i valori delta rispetto ai valori segnalati in precedenza. Se appropriato, i pannelli di controllo dei parametri aggregano (sommano) i valori inviati ogni 30 secondi per ottenere un valore per l'intero ultimo minuto.
### AWS Glue comportamento delle metriche per i lavori Spark
I parametri di AWS Glue vengono abilitati al momento dell'inizializzazione di un `GlueContext` in uno script e vengono in genere aggiornati solo al termine di un'attività di Apache Spark. Rappresentano i valori aggregati per tutte le attività di Spark completate fino al momento attuale.
Tuttavia, le metriche Spark che vengono AWS Glue trasmesse a CloudWatch sono generalmente valori assoluti che rappresentano lo stato attuale nel momento in cui vengono segnalate. AWS Glueli riporta CloudWatch ogni 30 secondi e i dashboard delle metriche generalmente mostrano la media dei punti dati ricevuti nell'ultimo minuto.
I nomi dei parametri AWS Glue sono tutti preceduti da uno dei seguenti tipi di prefisso:
+ `glue.driver.`: i parametri i cui nomi iniziano con questo prefisso rappresentano parametri AWS Glue aggregati da tutti gli executor nel driver Spark oppure parametri Spark corrispondenti al driver Spark.
+ `glue.`*executorId*`.`: *executorId* è il numero di un executor Spark specifico. Corrisponde agli executor elencati nei log.
+ `glue.ALL.`: i parametri i cui nomi iniziano con questo prefisso aggregano i valori di tutti gli executor Spark.
## AWS Glue metriche
AWS Glue profila e invia le seguenti metriche CloudWatch ogni 30 secondi e la AWS Glue Metrics Dashboard le riporta una volta al minuto:
| Metrica | Description |
| --- | --- |
| `glue.driver.aggregate.bytesRead` | Il numero di byte letti da tutte le origini dati da tutti i processi Spark completati in esecuzione in tutti gli executor. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: byte Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Questo parametro può essere utilizzato come il parametro `glue.ALL.s3.filesystem.read_bytes`, con la differenza che questo viene aggiornato alla fine di un processo Spark e acquisisce anche origini dati non S3. |
| `glue.driver.aggregate.elapsedTime` | Il tempo di ETL trascorso in millisecondi (non include i tempi di bootstrap del processo). Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: millisecondi Può essere utilizzato per determinare il tempo medio di esecuzione di un processo. Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.numCompletedStages` | Il numero di fasi completate nel processo. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.numCompletedTasks` | Il numero di attività completate nel processo. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.numFailedTasks` | Il numero di processi non riusciti. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) I dati possono essere utilizzati per impostare allarmi per errori maggiori che potrebbero suggerire anomalie nei dati, nel cluster o negli script. |
| `glue.driver.aggregate.numKilledTasks` | Il numero di attività interrotte. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.recordsRead` | Il numero di record letti da tutte le origini dati da tutti i processi Spark completati in esecuzione in tutti gli executor. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Questo parametro può essere utilizzato come il parametro `glue.ALL.s3.filesystem.read_bytes`, con la differenza che questo viene aggiornato alla fine di un processo Spark. |
| `glue.driver.aggregate.shuffleBytesWritten` | Il numero di byte scritti da tutti gli executor per mescolare i dati tra di loro rispetto al report precedente (aggregato dal AWS Glue Metrics Dashboard come numero di byte scritti a questo scopo nel minuto precedente). Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: byte Può essere utilizzato per monitorare: la distribuzione casuale dei dati nei processi (join di grandi dimensioni, groupBy, repartition, coalesce). Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.aggregate.shuffleLocalBytesRead` | Il numero di byte letti da tutti gli executor per mescolare i dati tra di loro rispetto al report precedente (aggregato dal AWS Glue Metrics Dashboard come numero di byte letti a tale scopo nel minuto precedente). Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella AWS Glue Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione. Unità: byte Può essere utilizzato per monitorare: la distribuzione casuale dei dati nei processi (join di grandi dimensioni, groupBy, repartition, coalesce). Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.BlockManager.disk.diskSpaceUsed_MB` | Numero di megabyte di spazio su disco utilizzati in tutti gli executor. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (gauge). Statistiche valide: Average (Media). Si tratta di un parametro Spark, riportato come valore assoluto. Unità: megabyte Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.ExecutorAllocationManager.executors.numberAllExecutors` | Numero di executor di processo attivi. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (gauge). Statistiche valide: Average (Media). Si tratta di un parametro Spark, riportato come valore assoluto. Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors` | Il numero massimo di executor di processo (attivi e in sospeso) necessari per soddisfare il carico corrente. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (gauge). Statistiche valide: Maximum (Massimo). Si tratta di un parametro Spark, riportato come valore assoluto. Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.jvm.heap.usage` `glue.`*executorId*`.jvm.heap.usage` `glue.ALL.jvm.heap.usage` | Frazione di memoria usata dall'heap JVM per questo driver (dimensione: 0-1) per driver, executor identificato da executorId o TUTTI gli executor. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (gauge). Statistiche valide: Average (Media). Si tratta di un parametro Spark, riportato come valore assoluto. Unità: percentuale Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.jvm.heap.used` `glue.`*executorId*`.jvm.heap.used` `glue.ALL.jvm.heap.used` | Il numero di byte di memoria utilizzati dall'heap JVM per il driver, l'executor identificato da *executorId* o TUTTI gli executor. Dimensioni valide: `JobName` (il nome del AWS Glue Job), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (gauge). Statistiche valide: Average (Media). Si tratta di un parametro Spark, riportato come valore assoluto. Unità: byte Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.s3.filesystem.read_bytes` `glue.`*executorId*`.s3.filesystem.read_bytes` `glue.ALL.s3.filesystem.read_bytes` | Il numero di byte letti da Amazon S3 dal driver, da un executor identificato da *ExecutorID* o da ALL executor rispetto al report precedente (aggregato dal Metrics Dashboard come il numero di byte letti AWS Glue nel minuto precedente). Dimensioni valide: `JobName`, `JobRunId` e `Type` (valutazione). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione AWS Glue . L'area sotto la curva nella AWS Glue Metrics Dashboard può essere utilizzata per confrontare visivamente i byte letti da due diverse esecuzioni di lavoro. Unità: byte. Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) I dati risultanti possono essere utilizzati per: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.s3.filesystem.write_bytes` `glue.`*executorId*`.s3.filesystem.write_bytes` `glue.ALL.s3.filesystem.write_bytes` | Il numero di byte scritti su Amazon S3 dal driver, da un executor identificato da *ExecutorID* o da ALL executor a partire dal report precedente (aggregato dal Metrics Dashboard come il numero di byte scritti AWS Glue nel minuto precedente). Dimensioni valide: `JobName`, `JobRunId` e `Type` (valutazione). Statistiche valide: SUM (Somma). Questa metrica è un valore delta dell'ultimo valore riportato, quindi nella Metrics Dashboard viene utilizzata una statistica SUM per l'aggregazione AWS Glue . L'area sotto la curva nella AWS Glue Metrics Dashboard può essere utilizzata per confrontare visivamente i byte scritti da due diverse esecuzioni di job. Unità: byte Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.streaming.numRecords` | Numero di record ricevuti in un micro-batch. Questa metrica è disponibile solo per i lavori di AWS Glue streaming con la AWS Glue versione 2.0 e successive. Dimensioni valide: `JobName` (il nome del AWS Glue lavoro), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Valid Statistics: Sum (Somma), Maximum (Massimo), Minimum (Minimo), Average (Media), Percentile (Percentuale) Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.streaming.batchProcessingTimeInMs` | Il tempo necessario per elaborare i batch in millisecondi. Questa metrica è disponibile solo per i lavori di AWS Glue streaming con la AWS Glue versione 2.0 e successive. Dimensioni valide: `JobName` (il nome del AWS Glue lavoro), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (count). Valid Statistics: Sum (Somma), Maximum (Massimo), Minimum (Minimo), Average (Media), Percentile (Percentuale) Unità: numero Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
| `glue.driver.system.cpuSystemLoad` `glue.`*executorId*`.system.cpuSystemLoad` `glue.ALL.system.cpuSystemLoad` | Frazione del carico di sistema della CPU usata (dimensione: 0-1) dal driver, da un executor identificato da *executorId* o da tutti gli executor. Dimensioni valide: `JobName` (il nome del AWS Glue lavoro), `JobRunId` (l' JobRun ID. or`ALL`) e `Type` (gauge). Statistiche valide: Average (Media). Questo parametro è riportato come valore assoluto. Unità: percentuale Può essere utilizzato per monitorare: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) Alcuni modi per utilizzare i dati: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) |
## Dimensioni per le metriche AWS Glue
AWS Glue le metriche utilizzano lo spazio dei AWS Glue nomi e forniscono metriche per le seguenti dimensioni:
| Dimensione | Description |
| --- | --- |
| `JobName` | Questa dimensione filtra le metriche di tutte le esecuzioni di un processo specifico. AWS Glue |
| `JobRunId` | Questa dimensione filtra le metriche di un AWS Glue lavoro specifico eseguito da un JobRun ID o. `ALL` |
| `Type` | Questa dimensione filtra i parametri in base a `count` (numero aggregato) o `gauge` (valore in un determinato momento). |
Per ulteriori informazioni, consulta la [Amazon CloudWatch User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).
# Configurazione degli CloudWatch allarmi Amazon sui profili AWS Glue professionali
AWS Gluele metriche sono disponibili anche in Amazon CloudWatch. È possibile configurare allarmi per qualsiasi parametro AWS Glue per i processi pianificati.
Di seguito sono illustrati alcuni scenari comuni per l'impostazione degli allarmi:
+ Processi che stanno per esaurire la memoria: è possibile impostare un allarme quando l'utilizzo della memoria supera la media normale per il driver o un executor per un processo AWS Glue.
+ Calo degli executor: è possibile impostare un allarme quando il numero di executor scende sotto una determinata soglia per un intervallo di tempo lungo in un processo AWS Glue.
+ Backlog o rielaborazione dei dati: confronta le metriche dei singoli lavori in un flusso di lavoro utilizzando un'espressione matematica. CloudWatch È quindi possibile attivare un allarme in base al valore dell'espressione risultante (ad esempio il rapporto tra byte scritti da un processo e byte letti dal processo seguente).
Per istruzioni dettagliate sull'impostazione degli allarmi, consulta [Creare o modificare un CloudWatch allarme](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html) nella *[Guida per l'utente di Amazon CloudWatch Events](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/)*.
Per l'utilizzo di scenari di monitoraggio e debug, consulta. CloudWatch [Monitoraggio e debug dei processi](monitor-profile-glue-job-cloudwatch-metrics.md)
# Registrazione dei lavori AWS Glue
Nella AWS Glue versione 5.0, tutti i lavori dispongono di funzionalità di registrazione in tempo reale. È inoltre possibile specificare le opzioni di configurazione personalizzate per personalizzare il comportamento di log. Queste opzioni includono l'impostazione del nome del gruppo di Amazon CloudWatch log, del prefisso del flusso di Amazon CloudWatch log (che precederà l'ID e l'ID del AWS Glue job run) e driver/executor il modello di conversione dei log per i messaggi di log. Queste configurazioni consentono di aggregare i log in gruppi di log Amazon CloudWatch personalizzati con politiche di scadenza diverse. Inoltre, è possibile analizzare i log in modo più efficace utilizzando prefissi e modelli di conversione personalizzati per i flussi di log. Questo livello di personalizzazione consente di ottimizzare la gestione e l'analisi dei log in base ai requisiti specifici.
## Comportamento di registrazione nella versione 5.0 AWS Glue
Per impostazione predefinita, i log di sistema, i log dei daemon Spark e i log dei AWS Glue logger degli utenti vengono scritti nel gruppo di log in. `/aws-glue/jobs/error` Amazon CloudWatch D'altra parte, i log degli utenti stdout (standard output) e stderr (standard error) vengono scritti nel gruppo di log `/aws-glue/jobs/output` per impostazione predefinita.
## Registrazione personalizzata
È possibile personalizzare i prefissi predefiniti del gruppo di log e del flusso di log utilizzando i seguenti argomenti di lavoro:
+ `--custom-logGroup-prefix`: consente di specificare un prefisso personalizzato per i gruppi di log `/aws-glue/jobs/error` e `/aws-glue/jobs/output`. Se si fornisce un prefisso personalizzato, i nomi dei gruppi di log avranno il seguente formato:
+ `/aws-glue/jobs/error` sarà `/error`
+ `/aws-glue/jobs/output ` sarà `/output`
+ `--custom-logStream-prefix`: consente di specificare un prefisso personalizzato per i nomi dei flussi di log all'interno dei gruppi di log. Se si fornisce un prefisso personalizzato, i nomi dei flussi di log avranno il seguente formato:
+ `jobrunid-driver` sarà `-driver`
+ `jobrunid-executorNum` sarà `-executorNum`
Regole e limitazioni di convalida per i prefissi personalizzati:
+ L'intero nome del flusso di log deve contenere da 1 a 512 caratteri.
+ Il prefisso personalizzato stesso è limitato a 400 caratteri.
+ Il prefisso personalizzato deve corrispondere al modello di espressione regolare “[^: \$1] \$1” (i caratteri speciali consentiti sono “\$1”, “-” e “/”).
## Registrazione di messaggi specifici di applicazioni tramite logger di script personalizzato
È possibile utilizzare il AWS Glue logger per registrare tutti i messaggi specifici dell'applicazione nello script che vengono inviati in tempo reale al flusso di registro del driver.
Il seguente esempio mostra uno script Python.
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
logger = glueContext.get_logger()
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
```
Il seguente esempio mostra uno script Scala.
```
import com.amazonaws.services.glue.log.GlueLogger
object GlueApp {
def main(sysArgs: Array[String]) {
val logger = new GlueLogger
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
}
}
```
## Abilitazione della barra di avanzamento per visualizzare l'avanzamento del processo
AWS Glue fornisce una barra di avanzamento in tempo reale sotto il flusso di `JOB_RUN_ID-progress-bar` log per controllare AWS Glue lo stato di esecuzione del lavoro. Al momento, supporta solo i processi che inizializzano `glueContext`. Se esegui un processo Spark puro senza inizializzarlo`glueContext`, la barra di AWS Glue avanzamento non viene visualizzata.
La barra di avanzamento mostra il seguente aggiornamento dell'avanzamento ogni 5 secondi.
```
Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage]
```
## Configurazione di sicurezza con registrazione Amazon CloudWatch
Quando una configurazione di sicurezza è abilitata per Amazon CloudWatch i log, AWS Glue crea gruppi di log con modelli di denominazione specifici che incorporano il nome della configurazione di sicurezza.
### Denominazione dei gruppi di log con configurazione di sicurezza
I gruppi di log predefiniti e personalizzati saranno i seguenti:
+ **Gruppo di log degli errori predefinito:** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/error`
+ **Gruppo di log di output predefinito:** `/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/output`
+ **Gruppo di log degli errori personalizzato (AWS Glue 5.0):** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/error`
+ **Gruppo di log di output personalizzato (AWS Glue 5.0):** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/output`
### Autorizzazioni IAM richieste
Se si abilita una configurazione di sicurezza con Amazon CloudWatch Logs, è necessario aggiungere l'autrozzazione `logs:AssociateKmsKey` alle autorizzazioni del ruolo IAM. Se tale autorizzazione non è inclusa, la registrazione continua verrà disabilitata.
Inoltre, per configurare la crittografia per Amazon CloudWatch i log, segui le istruzioni in [Encrypt Log Data in Amazon CloudWatch Logs Using nella Amazon Amazon CloudWatch Logs AWS Key Management Service User](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html) Guide.
### Informazioni aggiuntive
Per ulteriori informazioni sulla creazione di configurazioni di sicurezza, consulta [Gestione delle configurazioni di sicurezza sulla console](https://docs.aws.amazon.com/glue/latest/dg/console-security-configurations.html). AWS Glue
**Topics**
+ [Comportamento di registrazione nella versione 5.0 AWS Glue](#monitor-logging-behavior-glue-50)
+ [Registrazione personalizzata](#monitor-logging-custom)
+ [Registrazione di messaggi specifici di applicazioni tramite logger di script personalizzato](#monitor-logging-script)
+ [Abilitazione della barra di avanzamento per visualizzare l'avanzamento del processo](#monitor-logging-progress)
+ [Configurazione di sicurezza con registrazione Amazon CloudWatch](#monitor-security-config-logging)
+ [Abilitazione della registrazione continua per i AWS Glue lavori 4.0 e precedenti](monitor-continuous-logging-enable.md)
+ [Visualizzazione dei registri dei lavori AWS Glue](monitor-continuous-logging-view.md)
# Abilitazione della registrazione continua per i AWS Glue lavori 4.0 e precedenti
**Nota**
Nella AWS Glue 4.0 e nelle versioni precedenti, la registrazione continua era una funzionalità disponibile. Tuttavia, con l'introduzione della AWS Glue versione 5.0, tutti i lavori dispongono di funzionalità di registrazione in tempo reale. Per ulteriori dettagli sulle funzionalità di registrazione e sulle opzioni di configurazione in AWS Glue 5.0, vedere [Logging](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html) for jobs. AWS Glue
È possibile abilitare la registrazione continua utilizzando la AWS Glue console o tramite (). AWS Command Line Interface AWS CLI
Puoi abilitare la registrazione continua al momento della creazione di un nuovo processo e della modifica di un processo esistente oppure puoi abilitarla attraverso la AWS CLI.
È inoltre possibile specificare opzioni di configurazione personalizzate come il nome del gruppo di Amazon CloudWatch log, il prefisso del flusso di CloudWatch log prima dell' driver/executor ID del AWS Glue job run e il modello di conversione dei log per i messaggi di log. Queste configurazioni consentono di impostare log aggregati in gruppi di CloudWatch log personalizzati con politiche di scadenza diverse e di analizzarli ulteriormente con prefissi e modelli di conversione personalizzati per i flussi di log.
**Topics**
+ [Utilizzando il Console di gestione AWS](#monitor-continuous-logging-enable-console)
+ [Registrazione di messaggi specifici di applicazioni tramite logger di script personalizzato](#monitor-continuous-logging-script)
+ [Abilitazione della barra di avanzamento per visualizzare l'avanzamento del processo](#monitor-continuous-logging-progress)
+ [Configurazione di sicurezza con la registrazione continua.](#monitor-logging-encrypt-log-data)
## Utilizzando il Console di gestione AWS
Segui questi passaggi per utilizzare la console per abilitare la registrazione continua durante la creazione o la modifica di un AWS Glue lavoro.
**Per creare un nuovo AWS Glue lavoro con registrazione continua**
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 riquadro di navigazione scegli **Processi ETL**.
1. Scegli **ETL visivo**.
1. Nella scheda **Dettagli del lavoro**, espandi la sezione **Proprietà avanzate**.
1. In **Registrazione continua** seleziona **Abilita accessi. CloudWatch**
**Per abilitare la registrazione continua per un lavoro esistente AWS Glue**
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 scegliere **Jobs (Processi)**.
1. Scegliere un processo esistente dall'elenco **Jobs (Processi)**.
1. Scegliere **Action (Operazione)**, **Edit job (Modifica processo)**.
1. Nella scheda **Dettagli del lavoro**, espandi la sezione **Proprietà avanzate**.
1. In **Registrazione continua** seleziona **Abilita accessi. CloudWatch**
### Usando il AWS CLI
Per abilitare la registrazione continua, si passano i parametri del processo a un AWS Glue lavoro. Passate i seguenti parametri di lavoro speciali in modo simile agli altri parametri di AWS Glue lavoro. Per ulteriori informazioni, consulta [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md).
```
'--enable-continuous-cloudwatch-log': 'true'
```
Puoi specificare un nome di gruppo di CloudWatch log Amazon personalizzato. Se non specificato, il nome predefinito del gruppo di log è `/aws-glue/jobs/logs-v2`.
```
'--continuous-log-logGroup': 'custom_log_group_name'
```
Puoi specificare un prefisso Amazon CloudWatch Log Stream personalizzato. Se non specificato, il prefisso del flusso di log predefinito è l'ID di esecuzione del processo.
```
'--continuous-log-logStreamPrefix': 'custom_log_stream_prefix'
```
È possibile specificare un modello di conversione di registrazione continua personalizzato. Se non specificato, il modello di conversione predefinito è `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`. Tieni presente che il modello di conversione si applica solo ai log dei driver e ai log delle esecuzioni. Non interessa la barra di avanzamento di AWS Glue .
```
'--continuous-log-conversionPattern': 'custom_log_conversion_pattern'
```
## Registrazione di messaggi specifici di applicazioni tramite logger di script personalizzato
È possibile utilizzare il AWS Glue logger per registrare tutti i messaggi specifici dell'applicazione nello script che vengono inviati in tempo reale al flusso di registro del driver.
Il seguente esempio mostra uno script Python.
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
logger = glueContext.get_logger()
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
```
Il seguente esempio mostra uno script Scala.
```
import com.amazonaws.services.glue.log.GlueLogger
object GlueApp {
def main(sysArgs: Array[String]) {
val logger = new GlueLogger
logger.info("info message")
logger.warn("warn message")
logger.error("error message")
}
}
```
## Abilitazione della barra di avanzamento per visualizzare l'avanzamento del processo
AWS Glue fornisce una barra di avanzamento in tempo reale sotto il flusso di `JOB_RUN_ID-progress-bar` log per controllare AWS Glue lo stato di esecuzione del lavoro. Al momento, supporta solo i processi che inizializzano `glueContext`. Se esegui un processo Spark puro senza inizializzarlo`glueContext`, la barra di AWS Glue avanzamento non viene visualizzata.
La barra di avanzamento mostra il seguente aggiornamento dell'avanzamento ogni 5 secondi.
```
Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage]
```
## Configurazione di sicurezza con la registrazione continua.
Se è abilitata una configurazione di sicurezza per CloudWatch i log, AWS Glue creerà un gruppo di log denominato come segue per i log continui:
```
-
```
I gruppi di log predefiniti e personalizzati saranno i seguenti:
+ Il gruppo di log continuo di default sarà `/aws-glue/jobs/error-`
+ Il gruppo di log continuo di default sarà `-`
È necessario aggiungere le autorizzazioni `logs:AssociateKmsKey` al ruolo IAM, se si abilita una configurazione di sicurezza con Logs. CloudWatch Se tale autorizzazione non è inclusa, la registrazione continua verrà disabilitata. Inoltre, per configurare la crittografia per CloudWatch i log, segui le istruzioni in [Encrypt Log Data in CloudWatch Logs Using nella *Amazon CloudWatch Logs AWS Key Management Service* User](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html) Guide.
Per ulteriori informazioni sulla creazione delle configurazioni di sicurezza, consulta [Gestire le configurazioni di sicurezza nella console AWS Glue](console-security-configurations.md).
**Nota**
È possibile che vengano addebitati costi aggiuntivi quando si abilita la registrazione e vengono creati eventi di registro aggiuntivi. CloudWatch Per ulteriori informazioni, consulta i [ CloudWatch prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/).
# Visualizzazione dei registri dei lavori AWS Glue
Puoi visualizzare i log in tempo reale utilizzando la AWS Glue console o la CloudWatch console Amazon.
**Per visualizzare i log in tempo reale utilizzando la dashboard della console AWS Glue**
1. Accedi 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 riquadro di navigazione scegliere **Jobs (Processi)**.
1. Aggiungere o avviare un processo esistente. Scegliere **Action (Operazione)**, **Run job (Esegui processo)**.
Quando avvii l'esecuzione di un processo, puoi accedere a una pagina che contiene informazioni sul processo in esecuzione:
+ La scheda **Logs (Log)** mostra i precedenti log dell'applicazione aggregati.
+ La scheda **Log** mostra una barra di avanzamento in tempo reale quando il processo è in esecuzione con `glueContext` inizializzato.
+ La scheda **Registri contiene anche i** **registri dei driver, che acquisiscono i** log dei driver Apache Spark in tempo reale, e i registri delle applicazioni dallo script registrato utilizzando il logger dell' AWS Glue applicazione quando il processo è in esecuzione.
1. Per processi precedenti, è anche possibile visualizzare i log in tempo reale nella vista **Job History (Cronologia processi)** scegliendo **Logs (Log)**. Questa azione ti porta alla CloudWatch console che mostra tutti i flussi di log del driver Spark, dell'executor e della barra di avanzamento relativi all'esecuzione del job.
**Per visualizzare i log in tempo reale utilizzando la dashboard della console CloudWatch**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel riquadro di navigazione selezionare **Log**.
1. Scegli il gruppo **/aws- glue/jobs/error /log.**
1. Nella casella **Filter (Filtro)**, incollare l'ID dell'esecuzione del processo.
È possibile visualizzare i log di driver, i log di executor e la barra di avanzamento (se si utilizza **Standard filter (Filtro standard)**).
# Monitoraggio con parametri AWS Glue di osservabilità
**Nota**
I parametri di osservabilità AWS Glue sono disponibili in AWS Glue 4.0 e versioni successive.
Utilizza i parametri AWS Glue di osservabilità per generare approfondimenti su ciò che accade all'interno di AWS Glue per i processi di Apache Spark e migliorare la classificazione e l'analisi dei problemi. I parametri di osservabilità vengono visualizzati tramite i pannelli di controllo Amazon CloudWatch e possono essere utilizzati per aiutare a eseguire l'analisi delle cause principali degli errori e diagnosticare i rallentamenti delle prestazioni. È possibile ridurre il tempo impiegato per il debug dei problemi su larga scala così da poterti concentrare sulla risoluzione dei problemi in modo più rapido ed efficace.
AWS GlueL'osservabilità fornisce Amazon CloudWatch metriche classificate nei seguenti quattro gruppi:
+ **Affidabilità (ad esempio, classi di errori)**: identifica facilmente i motivi di errore più comuni in un determinato intervallo di tempo che potresti voler risolvere.
+ **Prestazioni (ad esempio, asimmetria)**: individua un ostacolo prestazionale e applica tecniche di ottimizzazione. Ad esempio, quando riscontri un peggioramento delle prestazioni a causa dell'asimmetria del processo, potresti voler abilitare l'esecuzione delle query adattive Spark e ottimizzare la soglia di unione skew.
+ **Throughput (ovvero, per source/sink throughput)**: monitora le tendenze delle letture e scritture dei dati. Puoi anche configurare Amazon CloudWatch allarmi per anomalie.
+ **Utilizzo delle risorse (ad esempio, personale, utilizzo della memoria e del disco)**: individuazione efficiente dei processi con un basso utilizzo della capacità. Potresti voler abilitare il dimensionamento automatico AWS Glue per questi processi.
## Guida introduttiva ai parametri AWS Glue di osservabilità
**Nota**
I nuovi parametri sono abilitati per impostazione predefinita nella console AWS Glue Studio.
**Per configurare i parametri di osservabilità in AWS Glue Studio:**
1. Accedi alla console AWS Glue e scegli **processi ETL** dal menu della console.
1. Scegli un processo facendo clic sul suo nome nella sezione **I tuoi processi**.
1. Seleziona la scheda **Job details (Dettagli del processo)**.
1. Scorri verso il basso e scegli **Proprietà avanzate**, quindi **Parametri di osservabilità del processo**.
![\[Lo screenshot mostra le Proprietà avanzate della scheda dei dettagli del processo. L'opzione Parametri di osservabilità del processo è evidenziata.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/job-details-observability-metrics.png)
**Per abilitare le metriche di AWS Glue osservabilità utilizzando: AWS CLI**
+ Aggiungi alla mappa `--default-arguments` il seguente valore-chiave nel file JSON di input:
```
--enable-observability-metrics, true
```
## Utilizzo dell'osservabilità AWS Glue
Poiché le metriche AWS Glue di osservabilità vengono fornite tramite Amazon CloudWatch, puoi utilizzare la Amazon CloudWatch console, l'SDK o l'API per interrogare i AWS CLI datapoint delle metriche di osservabilità. Consulta [Utilizzo dell'osservabilità Glue per monitorare l'utilizzo delle risorse per ridurre i costi](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics/) per un caso d'uso di esempio su quando utilizzare i parametri AWS Glue di osservabilità.
### Utilizzo dell'osservabilità nella console AWS Glue Amazon CloudWatch
**Per interrogare e visualizzare le metriche nella console: Amazon CloudWatch**
1. Apri la Amazon CloudWatch console e scegli **Tutte le** metriche.
1. In Spazi dei nomi personalizzati, seleziona **AWS Glue**.
1. Scegli **Parametri di osservabilità del processo, Parametri di osservabilità per origine oppure Parametri di osservabilità per Sink**.
1. Cerca il nome specifico del parametro, il nome del processo, l'ID di esecuzione del processo e selezionali.
1. Nella scheda **Parametri nel grafico**, configura la statistica, il periodo e altre opzioni che preferisci.
![\[La schermata mostra il grafico della Amazon CloudWatch console e delle metriche.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/cloudwatch-console-metrics.png)
**Per interrogare una metrica di osservabilità utilizzando: AWS CLI**
1. Crea un file JSON di definizione dei parametri e sostituisci `your-Glue-job-name` e `your-Glue-job-run-id` con quelli pertinenti.
```
$ cat multiplequeries.json
[
{
"Id": "avgWorkerUtil_0",
"MetricStat": {
"Metric": {
"Namespace": "Glue",
"MetricName": "glue.driver.workerUtilization",
"Dimensions": [
{
"Name": "JobName",
"Value": ""
},
{
"Name": "JobRunId",
"Value": ""
},
{
"Name": "Type",
"Value": "gauge"
},
{
"Name": "ObservabilityGroup",
"Value": "resource_utilization"
}
]
},
"Period": 1800,
"Stat": "Minimum",
"Unit": "None"
}
},
{
"Id": "avgWorkerUtil_1",
"MetricStat": {
"Metric": {
"Namespace": "Glue",
"MetricName": "glue.driver.workerUtilization",
"Dimensions": [
{
"Name": "JobName",
"Value": ""
},
{
"Name": "JobRunId",
"Value": ""
},
{
"Name": "Type",
"Value": "gauge"
},
{
"Name": "ObservabilityGroup",
"Value": "resource_utilization"
}
]
},
"Period": 1800,
"Stat": "Minimum",
"Unit": "None"
}
}
]
```
1. Eseguire il comando `get-metric-data`:
```
$ aws cloudwatch get-metric-data --metric-data-queries file: //multiplequeries.json \
--start-time '2023-10-28T18: 20' \
--end-time '2023-10-28T19: 10' \
--region us-east-1
{
"MetricDataResults": [
{
"Id": "avgWorkerUtil_0",
"Label": "",
"Timestamps": [
"2023-10-28T18:20:00+00:00"
],
"Values": [
0.06718750000000001
],
"StatusCode": "Complete"
},
{
"Id": "avgWorkerUtil_1",
"Label": "",
"Timestamps": [
"2023-10-28T18:50:00+00:00"
],
"Values": [
0.5959183673469387
],
"StatusCode": "Complete"
}
],
"Messages": []
}
```
## Parametri di osservabilità
AWS GlueL'osservabilità profila e invia le seguenti metriche Amazon CloudWatch ogni 30 secondi e alcune di queste metriche possono essere visibili nella pagina AWS Glue Studio Job Runs Monitoring.
| Metrica | Description | Categoria |
| --- | --- | --- |
| glue.driver.skewness.stage | Categoria parametro: job\$1performance Indice di asimmetria di esecuzione delle fasi spark: questa metrica è un indicatore della durata massima dell'attività in una determinata fase rispetto alla durata media dell'attività in questa fase. Rileva l'asimmetria di esecuzione, che potrebbe essere causata dall'asimmetria dei dati di input o da una trasformazione (ad es. join asimmetrico). I valori di questo parametro rientrano nell'intervallo [0, infinito], dove 0 indica il rapporto tra il tempo di esecuzione massimo e quello medio delle attività. Tra tutte le attività nella fase, è inferiore a un determinato fattore di asimmetria della stessa. Il fattore predefinito di asimmetria della fase è “5” e può essere sovrascritto tramite la configurazione spark: spark.metrics.conf.driver.source.glue.jobPerformance.skewnessFactor Un valore di asimmetria della fase pari a 1 significa che il rapporto è il doppio del fattore di asimmetria della fase. Il valore dell'asimmetria della fase viene aggiornato ogni 30 secondi per riflettere l'asimmetria corrente. Il valore alla fine della fase riflette l'asimmetria della fase finale. Questa metrica a livello di fase viene utilizzata per calcolare la metrica a livello di lavoro `glue.driver.skewness.job`. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (job\$1performance) Statistiche valide: media, massimo, minimo, percentuale Unità: numero | job\$1performance |
| glue.driver.skewness.job | Categoria parametro: job\$1performance L'asimmetria del lavoro è l'asimmetria ponderata massima di tutte le fasi. L'asimmetria della fase (glue.driver.skewness.stage) viene ponderata in base alla durata della fase. In questo modo si evita il caso limite in cui una fase molto asimmetrica viene eseguita per un periodo molto breve rispetto ad altre fasi (quindi la sua asimmetria non è significativa per le prestazioni complessive del processo e non vale la pena cercare di correggerla). Questo parametro viene aggiornato al completamento di ogni fase, perciò l'ultimo valore riflette l'effettiva asimmetria complessiva del processo. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (job\$1performance) Statistiche valide: media, massimo, minimo, percentuale Unità: numero | job\$1performance |
| glue.succeed.ALL | Categoria parametro: errore Numero totale di processi eseguiti con successo, per completare il quadro delle categorie di errori Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (count) e ObservabilityGroup (error) Statistiche valide: SOMMA Unità: numero | error |
| glue.error.ALL | Categoria parametro: errore Numero totale di errori di esecuzione del processo, per completare il quadro delle categorie di errori Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (count) e ObservabilityGroup (error) Statistiche valide: SOMMA Unità: numero | error |
| glue.error.[error category] | Categoria parametro: errore Questo insieme di parametri viene aggiornato solo se l'esecuzione di un processo fallisce. La categorizzazione degli errori facilita la classificazione e il debug. Quando l'esecuzione di un processo fallisce, la causa dell'errore viene classificata e il parametro della categoria di errore corrispondente viene impostato su 1. Ciò consente di eseguire l'analisi degli errori nel corso tempo, nonché quella relativa a tutti i processi, per identificare le categorie di errore più comuni e risolverle. AWS Glue include 28 categorie di errore, tra cui OUT\$1OF\$1MEMORY (driver ed executor), AUTORIZZAZIONE, SINTASSI e LIMITAZIONE (DELLA LARGHEZZA DI BANDA DELLA RETE). Le categorie di errore includono anche COMPILAZIONE, AVVIO e TIMEOUT. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (count) e ObservabilityGroup (error) Statistiche valide: SOMMA Unità: numero | error |
| glue.driver.workerUtilization | Categoria parametro: resource\$1utilization La percentuale dei worker allocati che vengono effettivamente utilizzati. Se non va bene, può essere utile il dimensionamento automatico. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media, massimo, minimo, percentuale Unità: percentuale | resource\$1utilization |
| glue.driver.memory.heap.[available \$1 used] | Categoria parametro: resource\$1utilization La memoria heap del driver disponibile/utilizzata durante l'esecuzione del processo. Ciò è utile per comprendere le tendenze di utilizzo della memoria, soprattutto nel tempo, il che può contribuire a evitare potenziali errori e a eseguirne il debug. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: byte | resource\$1utilization |
| glue.driver.memory.heap.used.percentage | Categoria parametro: resource\$1utilization La memoria heap del driver utilizzata (%) durante l'esecuzione del processo. Ciò è utile per comprendere le tendenze di utilizzo della memoria, soprattutto nel tempo, il che può contribuire a evitare potenziali errori e a eseguirne il debug. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: percentuale | resource\$1utilization |
| glue.driver.memory.non-heap.[available \$1 used] | Categoria parametro: resource\$1utilization La memoria non heap del driver disponibile/utilizzata durante l'esecuzione del processo. Ciò è utile per comprendere le tendenze di utilizzo della memoria, soprattutto nel tempo, il che può contribuire a evitare potenziali errori e a eseguirne il debug. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: byte | resource\$1utilization |
| glue.driver.memory.non-heap.used.percentage | Categoria parametro: resource\$1utilization La memoria non heap del driver utilizzata (%) durante l'esecuzione del processo. Ciò è utile per comprendere le tendenze di utilizzo della memoria, soprattutto nel tempo, il che può contribuire a evitare potenziali errori e a eseguirne il debug. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: percentuale | resource\$1utilization |
| glue.driver.memory.total.[available \$1 used] | Categoria parametro: resource\$1utilization La memoria totale del driver disponibile/utilizzata durante l'esecuzione del processo. Ciò è utile per comprendere le tendenze di utilizzo della memoria, soprattutto nel tempo, il che può contribuire a evitare potenziali errori e a eseguirne il debug. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: byte | resource\$1utilization |
| glue.driver.memory.total.used.percentage | Categoria parametro: resource\$1utilization La memoria totale del driver utilizzata (%) durante l'esecuzione del processo. Ciò è utile per comprendere le tendenze di utilizzo della memoria, soprattutto nel tempo, il che può contribuire a evitare potenziali errori e a eseguirne il debug. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: percentuale | resource\$1utilization |
| glue.ALL.memory.heap.[available \$1 used] | Categoria parametro: resource\$1utilization La memoria heap degli esecutori. available/used ALL significa tutti gli executor. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: byte | resource\$1utilization |
| glue.ALL.memory.heap.used.percentage | Categoria parametro: resource\$1utilization La memoria heap degli executor utilizzata (%). ALL significa tutti gli executor. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: percentuale | resource\$1utilization |
| glue.ALL.memory.non-heap.[available \$1 used] | Categoria parametro: resource\$1utilization La memoria non heap degli esecutori. available/used ALL significa tutti gli executor. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: byte | resource\$1utilization |
| glue.ALL.memory.non-heap.used.percentage | Categoria parametro: resource\$1utilization La memoria non heap degli executor utilizzata (%). ALL significa tutti gli executor. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: percentuale | resource\$1utilization |
| glue.ALL.memory.total.[available \$1 used] | Categoria parametro: resource\$1utilization La memoria totale degli esecutori. available/used ALL significa tutti gli executor. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: byte | resource\$1utilization |
| glue.ALL.memory.total.used.percentage | Categoria parametro: resource\$1utilization La memoria totale degli executor utilizzata (%). ALL significa tutti gli executor. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: percentuale | resource\$1utilization |
| glue.driver.disk.[available\$1GB \$1 used\$1GB] | Categoria parametro: resource\$1utilization Lo spazio su disco del driver durante l'esecuzione del processo. available/used Ciò è utile per comprendere le tendenze di utilizzo del disco, soprattutto nel tempo, il che può contribuire a evitare potenziali errori e a eseguire il debug di quelli relativi alla presenza di spazio non sufficiente sul disco. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: gigabyte | resource\$1utilization |
| glue.driver.disk.used.percentage] | Categoria parametro: resource\$1utilization Lo spazio su disco del driver durante l'esecuzione del processo. available/used Ciò è utile per comprendere le tendenze di utilizzo del disco, soprattutto nel tempo, il che può contribuire a evitare potenziali errori e a eseguire il debug di quelli relativi alla presenza di spazio non sufficiente sul disco. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: percentuale | resource\$1utilization |
| glue.ALL.disk.[available\$1GB \$1 used\$1GB] | Categoria parametro: resource\$1utilization Lo spazio su disco degli esecutori. available/used ALL significa tutti gli executor. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: gigabyte | resource\$1utilization |
| glue.ALL.disk.used.percentage | Categoria parametro: resource\$1utilization Lo spazio su disco (%) degli esecutori. available/used/used ALL significa tutti gli executor. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge) e ObservabilityGroup (resource\$1utilization) Statistiche valide: media Unità: percentuale | resource\$1utilization |
| glue.driver.bytesRead | Categoria parametro: velocità di trasmissione effettiva Il numero di byte letti per ogni origine di input in questa esecuzione del processo e per TUTTE le origini. È possibile così comprendere il volume dei dati e le relative variazioni nel tempo, il che consente di risolvere problemi come l'asimmetria dei dati. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge), (resource\$1utilization) e Source ObservabilityGroup (posizione dei dati di origine) Statistiche valide: media Unità: byte | velocità di trasmissione effettiva |
| glue.driver.[recordsRead \$1 filesRead] | Categoria parametro: velocità di trasmissione effettiva Il numero di records/files letture per sorgente di input in questo processo e per TUTTE le fonti. È possibile così comprendere il volume dei dati e le relative variazioni nel tempo, il che consente di risolvere problemi come l'asimmetria dei dati. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge), (resource\$1utilization) e Source ObservabilityGroup (posizione dei dati di origine) Statistiche valide: media Unità: numero | velocità di trasmissione effettiva |
| glue.driver.partitionsRead | Categoria parametro: velocità di trasmissione effettiva Il numero di partizioni lette per ogni origine di input di Amazon S3 in questa esecuzione del processo e per TUTTE le origini. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge), (resource\$1utilization) e Source ObservabilityGroup (posizione dei dati di origine) Statistiche valide: media Unità: numero | velocità di trasmissione effettiva |
| glue.driver.bytesWrittten | Categoria parametro: velocità di trasmissione effettiva Il numero di byte scritti per ogni sink di output in questa esecuzione del processo e per TUTTI i sink. È possibile così comprendere il volume dei dati e il modo in cui evolve nel tempo, il che consente di risolvere problemi come l'asimmetria dell'elaborazione. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge), (resource\$1utilization) e Sink ObservabilityGroup (posizione dei dati del sink) Statistiche valide: media Unità: byte | velocità di trasmissione effettiva |
| glue.driver.[recordsWritten \$1 filesWritten] | Categoria parametro: velocità di trasmissione effettiva Il numero di sink records/files scritti per uscita in questa esecuzione di processo e per TUTTI i sink. È possibile così comprendere il volume dei dati e il modo in cui evolve nel tempo, il che consente di risolvere problemi come l'asimmetria dell'elaborazione. Dimensioni valide: JobName (il nome del AWS Glue Job), JobRunId ( JobRun ID. o ALL), Type (gauge), (resource\$1utilization) e Sink ObservabilityGroup (posizione dei dati del sink) Statistiche valide: media Unità: numero | velocità di trasmissione effettiva |
## Categorie di errore
| Categorie di errore | Description |
| --- | --- |
| COMPILATION\$1ERROR | Gli errori si verificano durante la compilazione del codice Scala. |
| CONNECTION\$1ERROR | Si verificano errori durante la connessione a un servizio host/database, ecc. service/remote |
| DISK\$1NO\$1SPACE\$1ERROR | Gli errori si verificano quando non c'è più spazio nel disco sul driver/executor. |
| OUT\$1OF\$1MEMORY\$1ERROR | Gli errori si verificano quando non c'è più spazio nella memoria sul driver/executor. |
| IMPORT\$1ERROR | Gli errori si verificano durante l'importazione delle dipendenze. |
| INVALID\$1ARGUMENT\$1ERROR | Gli errori si verificano quando gli argomenti di input sono non validi o illegali. |
| PERMISSION\$1ERROR | Gli errori si verificano in mancanza di autorizzazioni per il servizio, per i dati, ecc. |
| RESOURCE\$1NOT\$1FOUND\$1ERROR | Gli errori si verificano quando i dati, la posizione, ecc. non esistono. |
| QUERY\$1ERROR | Gli errori derivano dall'esecuzione delle query di Spark SQL. |
| SYNTAX\$1ERROR | Gli errori si verificano quando nello script è presente un errore di sintassi. |
| THROTTLING\$1ERROR | Gli errori si verificano quando si supera la limitazione della concorrenza del servizio o il limite della quota di servizio. |
| DATA\$1LAKE\$1FRAMEWORK\$1ERROR | Gli errori derivano da framework data lake supportati nativamente da AWS Glue, come Hudi, Iceberg, ecc. |
| UNSUPPORTED\$1OPERATION\$1ERROR | Gli errori si verificano quando si eseguono operazioni non supportate. |
| RESOURCES\$1ALREADY\$1EXISTS\$1ERROR | Gli errori si verificano quando una risorsa da creare o aggiungere esiste già. |
| GLUE\$1INTERNAL\$1SERVICE\$1ERROR | Gli errori si verificano quando c'è un problema interno al servizio AWS Glue. |
| GLUE\$1OPERATION\$1TIMEOUT\$1ERROR | Gli errori si verificano quando un'operazione AWS Glue è in timeout. |
| GLUE\$1VALIDATION\$1ERROR | Gli errori si verificano quando un valore richiesto non può essere convalidato per un processo AWS Glue. |
| GLUE\$1JOB\$1BOOKMARK\$1VERSION\$1MISMATCH\$1ERROR | Gli errori si verificano quando lo stesso processo si trova sullo stesso bucket di origine e scrive contemporaneamente nella same/different destinazione (concorrenza >1) |
| LAUNCH\$1ERROR | Gli errori si verificano durante la fase di avvio del processo AWS Glue. |
| DYNAMODB\$1ERROR | Gli errori generici derivano dal servizio. Amazon DynamoDB |
| GLUE\$1ERROR | Gli errori generici derivano dal servizio AWS Glue. |
| LAKEFORMATION\$1ERROR | Gli errori generici derivano dal AWS Lake Formation servizio. |
| REDSHIFT\$1ERROR | Gli errori generici derivano dal Amazon Redshift servizio. |
| S3\$1ERROR | Gli errori generici derivano dal servizio Amazon S3. |
| SYSTEM\$1EXIT\$1ERROR | Errore generico di uscita dal sistema. |
| TIMEOUT\$1ERROR | Gli errori generici si verificano quando il processo fallisce per timeout dell'operazione. |
| UNCLASSIFIED\$1SPARK\$1ERROR | Gli errori generici derivano da Spark. |
| UNCLASSIFIED\$1ERROR | Categoria di errore predefinita. |
## Limitazioni
**Nota**
`glueContext` deve essere inizializzato per poter pubblicare i parametri.
Nella dimensione di origine, il valore corrisponde al percorso o al nome della tabella Amazon S3, a seconda del tipo di origine. Inoltre, se l'origine è JDBC e viene utilizzata l'opzione di query, la stringa di query viene impostata nella dimensione di origine. Se il valore supera i 500 caratteri, viene ridotto per rispettare questo limite. Di seguito sono riportate le limitazioni del valore:
+ I caratteri non ASCII verranno rimossi.
+ Se il nome dell'origine non contiene alcun carattere ASCII, verrà convertito in .
### Limitazioni e considerazioni relative ai parametri della velocità di trasmissione effettiva
+ DataFrame e DataFrame based DynamicFrame (ad esempio JDBC, lettura da parquet su Amazon S3) sono supportati, mentre quelli DynamicFrame basati su RDD (ad esempio la lettura di csv, json su Amazon S3, ecc.) non sono supportati. Tecnicamente, tutte le letture e le scritture visibili sull'interfaccia utente di Spark sono supportate.
+ Il parametro `recordsRead` viene emesso se l'origine dati è una tabella di catalogo e il formato è JSON, CSV, testo o Iceberg.
+ I parametri `glue.driver.throughput.recordsWritten`, `glue.driver.throughput.bytesWritten` e `glue.driver.throughput.filesWritten` non sono disponibili nelle tabelle JDBC e Iceberg.
+ I parametri potrebbero subire ritardi. Se il lavoro termina in circa un minuto, è possibile che in Metrics non sia presente alcuna metrica di throughput. Amazon CloudWatch
# Monitoraggio e debug dei processi
Puoi raccogliere metriche sui AWS Glue lavori e visualizzarle sulle CloudWatch console AWS Glue Amazon per identificare e risolvere i problemi. Per la profilatura dei processi AWS Glue sono necessarie le fasi seguenti:
1. Abilitare i parametri:
1. Abilitare l'opzione **Job metrics (Parametri processo)** nella definizione del processo. È possibile abilitare la profilatura nella console AWS Glue o come parametro per il processo. Per ulteriori informazioni, consultare [Definire le proprietà di processo per i processi Spark](add-job.md#create-job) o [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md).
1. Abilita l'opzione **Parametri AWS Glue di osservabilità** nella definizione del processo. È possibile abilitare l'osservabilità nella console AWS Glue o come parametro per il processo. Per ulteriori informazioni, consulta [Monitoraggio con parametri AWS Glue di osservabilità](monitor-observability.md).
1. Verificare che lo script del processo inizializzi un oggetto `GlueContext`. Il frammento di script seguente inizializza ad esempio un oggetto `GlueContext` e mostra dove viene inserito il codice profilato nello script. Questo formato generale viene usato negli scenari di debug seguenti.
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
import time
## @params: [JOB_NAME]
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
...
...
code-to-profile
...
...
job.commit()
```
1. Esegui il processo.
1. Visualizzare i parametri:
1. Visualizza i parametri nella console AWS Glue e identifica quelli anomali per il driver o per un executor.
1. Controlla le metriche di osservabilità nella pagina di monitoraggio del Job run, nella pagina dei dettagli del job run o su Amazon. CloudWatch Per ulteriori informazioni, consulta [Monitoraggio con parametri AWS Glue di osservabilità](monitor-observability.md).
1. Risalire alla causa principale usando il parametro identificato.
1. Facoltativamente, confermare la causa principale usando il flusso di log del driver o dell'executor del processo identificato.
**Casi d'uso per i parametri AWS Glue di osservabilità**
+ [Debug di eccezioni di memoria esaurita (OOM) e anomalie dei processi](monitor-profile-debug-oom-abnormalities.md)
+ [Debug di fasi impegnative e attività in ritardo](monitor-profile-debug-straggler.md)
+ [Monitoraggio dell'avanzamento di processi multipli](monitor-debug-multiple.md)
+ [Monitoraggio per la pianificazione della capacità DPU](monitor-debug-capacity.md)
+ [Utilizzo dell'osservabilità AWS Glue per monitorare l'utilizzo delle risorse per ridurre i costi](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics)
# Debug di eccezioni di memoria esaurita (OOM) e anomalie dei processi
È possibile eseguire il debug di eccezioni out-of-memory (OOM) e anomalie del lavoro in. AWS Glue Le sezioni seguenti descrivono gli scenari per il debug delle out-of-memory eccezioni del driver Apache Spark o di un esecutore Spark.
+ [Debug dell'eccezione di memoria esaurita (OOM) di un driver](#monitor-profile-debug-oom-driver)
+ [Debug di un'eccezione di memoria esaurita (OOM) dell'executor](#monitor-profile-debug-oom-executor)
## Debug dell'eccezione di memoria esaurita (OOM) di un driver
In questo scenario un processo Spark sta leggendo un numero elevato di piccoli file da Amazon Simple Storage Service (Amazon S3). I file vengono convertiti nel formato Apache Parquet e quindi scritti in Amazon S3. Il driver Spark sta per esaurire la memoria. I dati Amazon S3 di input hanno più di 1 milione di file in partizioni Amazon S3 diverse.
Il codice profilato è il seguente:
```
data = spark.read.format("json").option("inferSchema", False).load("s3://input_path")
data.write.format("parquet").save(output_path)
```
### Visualizza AWS Glue le metriche profilate sulla console
Il grafico seguente mostra l'utilizzo di memoria sotto forma di percentuale per il driver e gli executor. Il grafico dell'utilizzo viene tracciato usando punti dati che rappresentano la media dei valori segnalati nell'ultimo minuto. Nel profilo di memoria del processo è possibile vedere che la [memoria del driver](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage) supera la soglia di sicurezza del 50% di utilizzo in modo rapido. L'[utilizzo di memoria medio](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) di tutti gli executor rimane invece inferiore al 4%. Ciò indica chiaramente un'anomalia nell'esecuzione del driver nel processo Spark.
![\[Utilizzo della memoria in percentuale per il driver e gli executor.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-memoryprofile.png)
L'esecuzione del processo ha esito negativo in breve tempo e viene visualizzato l'errore seguente nella scheda **History (Cronologia)** della console AWS Glue: Command Failed with Exit Code 1 (Comando non riuscito con codice di uscita 1). Questa stringa di errore indica che il processo non è riuscito a causa di un errore di sistema, che in questo caso è l'esaurimento di memoria del driver.
![\[Messaggio di errore nella console AWS Glue.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-errorstring.png)
Sulla console, scegli il link **Registri degli errori** nella scheda **Cronologia** per confermare la scoperta del driver OOM nei registri. CloudWatch Cerca "**Error**" nel log di errori del processo per verificare che la mancata riuscita del processo sia effettivamente dovuta a un'eccezione di memoria esaurita:
```
# java.lang.OutOfMemoryError: Java heap space
# -XX:OnOutOfMemoryError="kill -9 %p"
# Executing /bin/sh -c "kill -9 12039"...
```
Nella scheda **History (Cronologia)** per il processo scegli **Logs (Log)**. È possibile trovare la seguente traccia dell'esecuzione del driver nei CloudWatch registri all'inizio del processo. Il driver Spark cerca di elencare tutti i file in tutte le directory, crea una oggetto `InMemoryFileIndex` e avvia un'attività per ogni file. Di conseguenza, il driver Spark deve gestire una quantità elevata di stato in memoria per tenere traccia di tutte le attività. Viene memorizzato nella cache l'elenco completo di un numero elevato di file per l'indice in memoria, provocando l'esaurimento della memoria del driver.
### Correzione dell'elaborazione di più file mediante il raggruppamento
È possibile correggere l'elaborazione di più file usando la caratteristica di *raggruppamento* in AWS Glue. Il raggruppamento viene abilitato automaticamente quando si usano frame dinamici e quando il set di dati di input include un numero elevato di file (più di 50.000). Il raggruppamento permette di unire più file in un gruppo e permette a un'attività di elaborare l'intero gruppo invece di un singolo file. Di conseguenza, il driver Spark archivia una quantità significativamente inferiore di stato in memoria per tenere traccia di un numero minore di attività. Per ulteriori informazioni sull'abilitazione manuale del raggruppamento per un set di dati, consulta [Lettura di file di input in gruppi di grandi dimensioni](grouping-input-files.md).
Per controllare il profilo di memoria del processo AWS Glue, profila il codice seguente con il raggruppamento abilitato:
```
df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json")
datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink")
```
È possibile monitorare il profilo di memoria e lo spostamento di dati ETL nel profilo del processo AWS Glue.
Il driver viene eseguito sotto la soglia del 50% di utilizzo di memoria per l'intera durata del processo AWS Glue. Gli executor trasmettono i dati da Amazon S3, li elaborano e li scrivono in Amazon S3. Di conseguenza, usano meno del 5% di memoria in qualsiasi momento.
![\[Profilo di memoria che mostra che il problema è stato risolto.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-memoryprofile-fixed.png)
Il profilo di spostamento dei dati seguente mostra il numero totale di byte Amazon S3 che vengono [letti](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) e [scritti](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) nell'ultimo minuto da tutti gli executor man mano che il processo avanza. In entrambi i casi viene seguito un modello simile mentre i dati vengono trasmessi tra tutti gli executor. Il processo completa l'elaborazione di tutto il milione di file in meno di tre ore.
![\[Profilo di spostamento dei dati che mostra che il problema è stato risolto.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-etlmovement.png)
## Debug di un'eccezione di memoria esaurita (OOM) dell'executor
In questo scenario è possibile imparare a eseguire il debug delle eccezioni di memoria esaurita che potrebbero verificarsi negli executor Apache Spark. Il codice seguente usa il lettore Spark MySQL per leggere una tabella di grandi dimensioni con circa 34 milioni di righe in un dataframe Spark. Scrive quindi i dati in Amazon S3 in formato Parquet. È possibile fornire le proprietà di connessione e usare le configurazioni Spark predefinite per leggere la tabella.
```
val connectionProperties = new Properties()
connectionProperties.put("user", user)
connectionProperties.put("password", password)
connectionProperties.put("Driver", "com.mysql.jdbc.Driver")
val sparkSession = glueContext.sparkSession
val dfSpark = sparkSession.read.jdbc(url, tableName, connectionProperties)
dfSpark.write.format("parquet").save(output_path)
```
### Visualizzazione dei parametri profilati nella console AWS Glue
Se la pendenza del grafico di utilizzo della memoria è positiva e supera il 50% e se il processo non riesce prima che venga emesso il parametro successivo, l'esaurimento della memoria può probabilmente essere la causa. Il grafico seguente mostra che entro un minuto di esecuzione, l'[utilizzo di memoria medio](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) in tutti gli executor sale rapidamente sopra il 50%. L'utilizzo raggiunge il 92% e il container che esegue l'executor viene interrotto da Apache Hadoop YARN.
![\[Utilizzo di memoria medio in tutti gli executor.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile.png)
Come mostra il grafico seguente, c'è sempre un [singolo executor](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) in esecuzione fino a quando il processo non ha esito negativo. Ciò avviene perché viene avviato un nuovo executor per sostituire quello interrotto. Le operazioni di lettura dell'origine dati JDBC non sono parallelizzate per impostazione predefinita perché ciò richiederebbe il partizionamento della tabella in una colonna e l'apertura di più connessioni. Di conseguenza, un solo executor legge la tabella completa sequenzialmente.
![\[L'esecuzione del processo mostra un singolo executor in esecuzione fino a quando il processo non ha esito negativo.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-2-execution.png)
Come mostra il grafico seguente, Spark cerca di avviare una nuova attività quattro volte prima che il processo abbia esito negativo. È possibile visualizzare il [profilo di memoria](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.used) di tre executor. Ogni executor consuma rapidamente tutta la relativa memoria. Il quarto executor esaurisce la memoria e il processo ha esito negativo. Di conseguenza, il relativo parametro non viene segnalato immediatamente.
![\[Profili di memoria degli executor.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-2-exec-memprofile.png)
È possibile verificare dalla stringa di errore nella console AWS Glue che il processo ha avuto esito negativo a causa di eccezioni di memoria esaurita, come illustrato nell'immagine seguente.
![\[Messaggio di errore nella console AWS Glue.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-2-errorstring.png)
**Job output logs:** per confermare ulteriormente l'individuazione di un'eccezione OOM dell'executor, guarda i CloudWatch log. Eseguendo la ricerca di **Error**, puoi trovare quattro executor interrotti circa nella stessa finestra temporale, come indicato nel pannello di controllo dei parametri. Gli executor sono stati terminati tutti da YARN a causa del superamento dei limiti di memoria.
Executor 1
```
18/06/13 16:54:29 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:54:29 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:54:29 ERROR YarnClusterScheduler: Lost executor 1 on ip-10-1-2-175.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:54:29 WARN TaskSetManager: Lost task 0.0 in stage 0.0 (TID 0, ip-10-1-2-175.ec2.internal, executor 1): ExecutorLostFailure (executor 1 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
```
Executor 2
```
18/06/13 16:55:35 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:55:35 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:55:35 ERROR YarnClusterScheduler: Lost executor 2 on ip-10-1-2-16.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:55:35 WARN TaskSetManager: Lost task 0.1 in stage 0.0 (TID 1, ip-10-1-2-16.ec2.internal, executor 2): ExecutorLostFailure (executor 2 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
```
Executor 3
```
18/06/13 16:56:37 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:56:37 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:56:37 ERROR YarnClusterScheduler: Lost executor 3 on ip-10-1-2-189.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:56:37 WARN TaskSetManager: Lost task 0.2 in stage 0.0 (TID 2, ip-10-1-2-189.ec2.internal, executor 3): ExecutorLostFailure (executor 3 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
```
Executor 4
```
18/06/13 16:57:18 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:57:18 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:57:18 ERROR YarnClusterScheduler: Lost executor 4 on ip-10-1-2-96.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
18/06/13 16:57:18 WARN TaskSetManager: Lost task 0.3 in stage 0.0 (TID 3, ip-10-1-2-96.ec2.internal, executor 4): ExecutorLostFailure (executor 4 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead.
```
### Correzione dell'impostazione relativa alle dimensioni di recupero tramite frame dinamici AWS Glue
L'executor ha esaurito la memoria durante la lettura della tabella JDBC perché la configurazione predefinita per le dimensioni di recupero JDBC Spark è zero. Ciò significa che il driver JDBC nell'executor Spark cerca di recuperare i 34 milioni di righe del database contemporaneamente e di eseguirne la memorizzazione nella cache, anche se il flusso di Spark avviene una riga per volta. Con Spark, è possibile evitare questo scenario impostando il parametro relativo alle dimensioni di recupero su un valore predefinito diverso da zero.
È inoltre possibile risolvere questo errore usando frame dinamici AWS Glue. Per impostazione predefinita, i frame dinamici utilizzano una dimensione di recupero di 1.000 righe che in genere è un valore sufficiente. Di conseguenza, l'executor non usa più del 7% della memoria totale. Il processo AWS Glue termina in meno di due minuti con solo un singolo executor. Sebbene l'uso dei frame dinamici AWS Glue sia l'approccio consigliato, è anche possibile impostare la dimensione di recupero utilizzando la proprietà `fetchsize` di Apache Spark. Consulta la guida [Spark, DataFrames SQL](https://spark.apache.org/docs/2.2.0/sql-programming-guide.html#jdbc-to-other-databases) e Datasets.
```
val (url, database, tableName) = {
("jdbc_url", "db_name", "table_name")
}
val source = glueContext.getSource(format, sourceJson)
val df = source.getDynamicFrame
glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink")
```
**Parametri profilati normali:** la [memoria dell'executor](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) con frame dinamici AWS Glue non supera mai la soglia di sicurezza, come illustrato nell'immagine seguente. Il flusso passa nelle righe dal database e vengono memorizzate nella cache solo 1.000 righe nel driver JDBC in un determinato momento. Non si è verificata un'eccezione di memoria esaurita.
![\[Console AWS Glue che mostra la memoria dell'executor al di sotto della soglia di sicurezza.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile-fixed.png)
# Debug di fasi impegnative e attività in ritardo
È possibile usare la profilatura dei processi AWS Glue per identificare le fasi impegnative e le attività in ritardo nei processi ETL (Extract, Transform and Load, estrazione, trasformazione e caricamento). Un'attività in ritardo richiede molto più tempo rispetto al resto delle attività in una fase di un processo AWS Glue. Di conseguenza, il completamento della fase richiede più tempo e aumenta il tempo totale di esecuzione del processo.
## Unione di file di input di piccole dimensioni in file di output di dimensioni maggiori
Un'attività in ritardo può verificarsi in caso di distribuzione non uniforme del lavoro tra attività diverse oppure in caso di un'asimmetria dei dati a causa della quale un'attività elabora più dati.
È possibile profilare il codice seguente, che rappresenta un modello comune in Apache Spark, per unire un numero elevato di piccoli file in file di output di dimensioni maggiori. Per questo esempio, il set di dati di input è costituito da 32 GB di file compressi Gzip JSON. Il set di dati di output include circa 190 GB di file JSON non compressi.
Il codice profilato è il seguente:
```
datasource0 = spark.read.format("json").load("s3://input_path")
df = datasource0.coalesce(1)
df.write.format("json").save(output_path)
```
### Visualizzazione dei parametri profilati nella console AWS Glue
È possibile profilare il processo per esaminare quattro diversi set di parametri:
+ Spostamento di dati ETL
+ Distribuzione casuale dei dati tra executor
+ Esecuzione del processo
+ Profilo di memoria
**Spostamento di dati ETL**: nel profilo **ETL Data Movement (Spostamento di dati ETL)** i byte vengono [letti](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) abbastanza rapidamente da tutti gli executor nella prima fase, che viene completata entro i primi sei minuti. Tuttavia, il tempo di esecuzione totale del processo è di circa un'ora, principalmente a causa delle operazioni di [scrittura](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) dei dati.
![\[Grafico che mostra il profilo di spostamento di dati ETL.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-straggler-1.png)
**Distribuzione casuale dei dati tra executor:** il numero di byte [letti](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) e [scritti](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) durante la distribuzione casuale mostra un picco prima del completamento della fase 2, come indicato dai parametri **Job Execution (Esecuzione processo)** e **Data Shuffle (Distribuzione casuale dei dati)**. Dopo che i dati sono stati distribuiti in modo causale da tutti gli executor, le operazioni di lettura e scrittura procedono solo dall'executor numero 3.
![\[Parametri per la distribuzione casuale dei dati tra gli executor.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-straggler-2.png)
**Esecuzione del processo:** come illustrato nel grafico seguente, tutti gli altri executor sono inattivi e vengono infine rilasciati entro le 10:09. A questo punto, il numero totale di executor scende a uno solo. Ciò mostra chiaramente che l'executor numero 3 è costituito dall'attività in ritardo che sta impiegando il tempo di esecuzione più lungo e che contribuisce in misura maggiore al tempo di esecuzione del processo.
![\[Parametri di esecuzione per gli executor attivi.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-straggler-3.png)
**Profilo di memoria:** dopo le prime due fasi, solo l'[executor numero 3](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used) consuma attivamente memoria per elaborare i dati. Gli altri executor sono semplicemente inattivi o sono stati rilasciati poco dopo il completamento delle prime due fasi.
![\[Parametri per il profilo di memoria dopo le prime due fasi.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-straggler-4.png)
### Correzione del calo degli executor tramite il raggruppamento
È possibile evitare il calo degli executor usando la caratteristica di *raggruppamento* in AWS Glue. Usa il raggruppamento per distribuire i dati in modo uniforme tra tutti gli executor e unire i file in file di dimensioni maggiori usando tutti gli executor disponibili nel cluster. Per ulteriori informazioni, consulta [Lettura di file di input in gruppi di grandi dimensioni](grouping-input-files.md).
Per controllare gli spostamenti di dati ETL nel processo AWS Glue, profila il codice seguente con il raggruppamento abilitato:
```
df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json")
datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "json", transformation_ctx = "datasink4")
```
**Spostamento di dati ETL:** le operazioni di scrittura dei dati vengono ora trasmesse in parallelo alle operazioni di lettura dei dati per tutto il tempo di esecuzione del processo. Di conseguenza, il processo viene completato entro otto minuti, molto più rapidamente che in precedenza.
![\[Spostamenti di dati ETL che mostrano che il problema è stato risolto.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-straggler-5.png)
**Distribuzione casuale dei dati tra executor:** poiché i file di input vengono uniti durante le operazioni di lettura usando la caratteristica di raggruppamento, non vengono eseguite costose attività di distribuzione casuale dei dati dopo le operazioni di lettura dei dati.
![\[Parametri di distribuzione casuale dei dati che mostrano che il problema è stato risolto.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-straggler-6.png)
**Esecuzione del processo:** i parametri relativi all'esecuzione del processo mostrano che il numero totale di executor attivi in esecuzione e che elaborano i dati rimane relativamente costante. Non vi sono singole attività in ritardo nel processo. Tutti gli executor sono attivi e non vengono rilasciati fino al completamento del processo. Poiché non vi è alcuna operazione intermedia di distribuzione casuale dei dati tra gli executor, il processo è costituito da un'unica fase.
![\[Parametri per il widget di esecuzione del processo che mostrano che non vi sono attività in ritardo nel processo.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-straggler-7.png)
**Profilo di memoria:** i parametri mostrano il [consumo di memoria attivo](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used) tra tutti gli executor, riconfermando la presenza di attività in tutti gli executor. Poiché i dati vengono trasmessi e scritti in parallelo, l'utilizzo totale di memoria di tutti gli executor è piuttosto uniforme e ben al di sotto della soglia di sicurezza per tutti gli executor.
![\[Parametri del profilo di memoria che mostrano un consumo di memoria attivo in tutti gli executor.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-straggler-8.png)
# Monitoraggio dell'avanzamento di processi multipli
Puoi profilare più AWS Glue lavori insieme e monitorare il flusso di dati tra di essi. Si tratta di un modello di flusso di lavoro comune e richiede il monitoraggio per l'avanzamento del processo individuale, il backlog dell'elaborazione dei dati, la rielaborazione dei dati e i segnalibri dei processi.
**Topics**
+ [Codice profilato](#monitor-debug-multiple-profile)
+ [Visualizzazione dei parametri profilati nella console AWS Glue](#monitor-debug-multiple-visualize)
+ [Correzione dell'elaborazione dei file](#monitor-debug-multiple-fix)
## Codice profilato
In questo flusso di lavoro, ci sono due processi: un processo di input e uno di output. Il processo di input è pianificato per l'esecuzione ogni 30 minuti usando un trigger periodico. Il processo di output è pianificato per l'esecuzione dopo ogni esecuzione del processo di input. Questi processi pianificati sono controllati usando trigger dei processi.
![\[Screenshot della console che mostra i trigger dei processi che controllano la pianificazione dei processi di input e di output.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-multiple-1.png)
**Processo di input**: questo processo legge i dati da una posizione Amazon Simple Storage Service (Amazon S3), li trasforma tramite `ApplyMapping` e li scrive in una posizione Amazon S3 di staging. Il codice seguente è il codice profilato per il processo di input:
```
datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": ["s3://input_path"], "useS3ListImplementation":True,"recurse":True}, format="json")
applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec])
datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": staging_path, "compression": "gzip"}, format = "json")
```
**Processo di output**: questo processo legge l'output del processo di input dalla posizione di staging in Amazon S3, lo trasforma nuovamente e lo scrive in una destinazione:
```
datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json")
applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec])
datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "json")
```
## Visualizzazione dei parametri profilati nella console AWS Glue
Il pannello di controllo seguente sovrappone il parametro Amazon S3 dei byte scritti dal processo di input al parametro Amazon S3 dei byte letti nella stessa sequenza temporale del processo di output. La sequenza temporale mostra diverse esecuzioni dei processi di input e di output. Il processo di input (mostrato in rosso) inizia ogni 30 minuti. Il processo di output (mostrato in marrone) viene avviato al completamento del processo di input, con una simultaneità massima di 1.
![\[Grafico che mostra i dati letti e scritti.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-multiple-4.png)
In questo esempio, i [segnalibri dei processi](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) non sono abilitati. Non vengono usati contesti di trasformazione per abilitare i segnalibri dei processi nel codice dello script.
**Cronologia dei processi**: i processi di input e di output hanno più esecuzioni, come illustrato nella scheda **History (Cronologia)**, a partire dalle 12:00.
Il processo di input nella console AWS Glue ha il seguente aspetto:
![\[Screenshot della console che mostra la scheda della cronologia del processo di input.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-multiple-2.png)
L'immagine seguente mostra il processo di output:
![\[Screenshot della console che mostra la scheda della cronologia del processo di output.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-multiple-3.png)
**Prime esecuzioni dei processi**: come illustrato nel grafico seguente dei byte di dati letti e scritti, le prime esecuzioni dei processi di input e di output tra le 12:00 e 12:30 mostrano pressappoco la stessa area sotto le curve. Tali aree rappresentano i byte Amazon S3 scritti dal processo di input e i byte Amazon S3 letti dal processo di output. Questi dati vengono inoltre confermati dal rapporto di byte Amazon S3 scritti (sommati nell'arco di 30 minuti, la frequenza del trigger dei processi per il processo di input). Il punto dati del rapporto dell'esecuzione del processo di input iniziato alle 12:00 è 1.
Il grafico seguente mostra il rapporto del flusso di dati in tutte le esecuzioni dei processi:
![\[Grafico che mostra il rapporto del flusso di dati tra byte scritti e byte letti.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-multiple-5.png)
**Seconde esecuzioni dei processi**: nella seconda esecuzione del processo, c'è una chiara differenza tra il numero di byte letti dal processo di output rispetto al numero di byte scritti dal processo di input. Confronta l'area sotto la curva tra le due esecuzioni del processo di output o confronta le aree nella seconda esecuzione dei processi di input e di output. Il rapporto tra i byte letti e scritti mostra che il processo di output ha letto 2,5 volte i dati scritti dal processo di input nel secondo intervallo di 30 minuti dalle 12:30 alle 13:00. Ciò è dovuto al fatto che il processo di output ha rielaborato l'output della prima esecuzione del processo di input perché i segnalibri non erano abilitati. Un rapporto superiore a 1 mostra che c'è un ulteriore backlog di dati che è stato elaborato dal processo di output.
**Terze esecuzioni dei processi**: il processo di input è abbastanza coerente in termini di numero di byte scritti (vedi l'area sotto le curve rosse). Tuttavia, la terza esecuzione del processo di input è durata più tempo del previsto (vedi la lunga coda della curva rossa). Di conseguenza, la terza esecuzione del processo di output è iniziata tardi. La terza esecuzione del processo ha elaborato solo una parte dei dati accumulati nella posizione di staging nei rimanenti 30 minuti tra le 13:00 e le 13:30. Il rapporto del flusso di byte mostra che ha elaborato solo un valore pari a 0,83 dei dati scritti dalla terza esecuzione del processo di input (vedi il rapporto alle 13:00).
**Sovrapposizione dei processi di input e di output**: la quarta esecuzione del processo di input è iniziata alle 13:30 in base alla pianificazione, prima del completamento della terza esecuzione del processo di output. C'è una sovrapposizione parziale tra queste due esecuzioni del processo. Tuttavia, la terza esecuzione del processo di output acquisisce solo i file elencati nella posizione di staging di Amazon S3 al momento dell'avvio, intorno alle 13:17. Ciò corrisponde a tutti i dati di output della prima esecuzione del processo di input. Il rapporto effettivo alle 13:30 è di circa 2,75. La terza esecuzione del processo di output ha elaborato circa 2,75 volte la quantità di dati scritti dalla quarta esecuzione del processo di input dalle 13:30 alle 14:00.
Come mostrano queste immagini, il processo di output sta rielaborando i dati dalla posizione di staging di tutte le esecuzioni precedenti del processo di input. Di conseguenza, la quarta esecuzione del processo di output è la più lunga e si sovrappone all'intera quinta esecuzione del processo di input.
## Correzione dell'elaborazione dei file
È necessario accertarsi che i processi di output elaborino solo i file che non sono stati elaborati da esecuzioni precedenti del processo di output. A tale scopo, abilita i segnalibri dei processi e imposta il contesto di trasformazione nel processo di output, come segue:
```
datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json", transformation_ctx = "bookmark_ctx")
```
Con i segnalibri dei processi abilitati, il processo di output non rielabora i dati nella posizione di staging di tutte le precedenti esecuzioni del processo di input. Nell'immagine seguente, che mostra i dati letti e scritti, l'area sotto la curva marrone è abbastanza coerente e simile alle curve rosse.
![\[Grafico che mostra i dati letti e scritti sotto forma di linee rosse e marroni.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-multiple-6.png)
I rapporti dei flussi di byte rimangono abbastanza vicino a 1 perché non ci sono dati aggiuntivi elaborati.
![\[Grafico che mostra il rapporto del flusso di dati tra byte scritti e byte letti.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-multiple-7.png)
Un'esecuzione del processo di output viene avviata e acquisisce i file nella posizione di staging prima che la successiva esecuzione del processo di input inizi a inserire ulteriori dati nella posizione di staging. Fino a quando ciò avviene, vengono elaborati solo i file acquisiti dall'esecuzione del processo di input precedente e il rapporto rimane vicino a 1.
![\[Grafico che mostra il rapporto del flusso di dati tra byte scritti e byte letti.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-multiple-7.png)
Supponiamo che il processo di input richieda più tempo del previsto e, di conseguenza, il processo di output acquisisca i file nella posizione di staging da due esecuzioni del processo di input. Il rapporto è quindi superiore a 1 per l'esecuzione del processo di output. Tuttavia, le esecuzioni successive del processo di output non elaborano file già elaborati dalle esecuzioni precedenti del processo di output.
# Monitoraggio per la pianificazione della capacità DPU
Puoi utilizzare le metriche del lavoro AWS Glue per stimare il numero di unità di elaborazione dati (DPUs) che possono essere utilizzate per scalare un AWS Glue lavoro.
**Nota**
Questa pagina è applicabile solo a AWS Glue versioni 0.9 e 1.0. Le versioni successive di AWS Glue contengono funzionalità di riduzione dei costi che introducono considerazioni aggiuntive nella pianificazione della capacità.
**Topics**
+ [Codice profilato](#monitor-debug-capacity-profile)
+ [Visualizzazione dei parametri profilati nella console AWS Glue](#monitor-debug-capacity-visualize)
+ [Determinazione della capacità DPU ottimale](#monitor-debug-capacity-fix)
## Codice profilato
Lo script seguente legge una partizione Amazon Simple Storage Service (Amazon S3) contenente 428 file JSON GZIP. Lo script applica una mappatura per modificare i nomi dei campi, li converte e li scrive in Amazon S3 in un formato Apache Parquet. Si esegue il provisioning di 10 DPUs in base all'impostazione predefinita e si esegue questo processo.
```
datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [input_path], "useS3ListImplementation":True,"recurse":True}, format="json")
applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [(map_spec])
datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet")
```
## Visualizzazione dei parametri profilati nella console AWS Glue
**Job run 1:** In questo job run mostriamo come verificare se DPUs nel cluster non è disponibile un provisioning insufficiente. La funzionalità di esecuzione del processo in AWS Glue mostra il [numero totale di esecutori attivi](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors), il [numero di fasi completate](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages) e il [numero massimo di esecutori necessari](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors).
Il numero massimo di executor necessari viene calcolato aggiungendo il numero totale di attività in esecuzione e attività in sospeso e dividendo per le attività per executor. Questo risultato è una misura del numero totale di executor necessari per soddisfare il carico corrente.
Al contrario, il numero di executor attivi misura quanti executor stanno eseguendo attivamente attività Apache Spark. Con l'avanzamento del processo, il numero massimo di executor necessari può cambiare e in genere diminuisce verso la fine del processo, in quanto le attività in coda si riducono.
La linea rossa orizzontale nel grafico seguente mostra il numero massimo di executor allocati, che dipende dal numero di esecutori allocati per il DPUs job. In questo caso, ne vengono allocati 10 DPUs per l'esecuzione del job. Una DPU è riservata alla gestione. Nove DPUs eseguono due executor ciascuno e un executor è riservato al driver Spark. Il driver Spark viene eseguito all'interno dell'applicazione principale. Pertanto, il numero massimo di executor allocati è 2\$19 - 1 = 17 executor.
![\[Parametri del processo che mostrano gli executor attivi e il numero massimo di executor necessari.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-capacity-1.png)
Come mostra il grafico, il numero massimo di executor parte da 107 all'inizio del processo, mentre il numero di executor attivi rimane 17. È lo stesso del numero massimo di executor allocati, pari a 10. DPUs Il rapporto tra il numero massimo di executor necessari e il numero massimo di executor allocati (aggiungendo 1 a entrambi per il driver Spark) indica il fattore di provisioning in difetto: 108/18 = 6x. È possibile eseguire il provisioning di 6 (in base al rapporto di provisioning) \$19 (capacità DPU attuale - 1) \$1 1 DPUs = 55 DPUs per scalare il lavoro in modo da eseguirlo con il massimo parallelismo e terminarlo più velocemente.
La console AWS Glue mostra i parametri dettagliati dei processi come una linea statica che rappresenta il numero massimo originale di esecutori allocati. La console calcola il numero massimo di esecutori allocati dalla definizione del processo per i parametri. Al contrario, per metriche dettagliate sull'esecuzione del processo, la console calcola il numero massimo di esecutori allocati dalla configurazione del job run, in particolare quello allocato per l'esecuzione del job. DPUs Per visualizzare i parametri dell'esecuzione di un singolo processo, seleziona l'esecuzione del processo e scegli **View run metrics (Visualizza parametri di esecuzione)**.
![\[Parametri del processo che mostrano lo spostamento di dati ETL.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-capacity-2.png)
Osservando i byte Amazon S3 [letti](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) e [scritti](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes), si nota che il processo impiega tutti e sei i minuti per lo streaming in ingresso dei dati da Amazon S3 e la scrittura in uscita in parallelo. Tutti i core allocati DPUs sono in lettura e scrittura su Amazon S3. Il numero massimo di executor necessari (107), corrisponde anche al numero di file nel percorso di input Amazon S3 path428. Ogni executor può avviare quattro attività Spark per elaborare quattro file di input (JSON GZIP).
## Determinazione della capacità DPU ottimale
In base ai risultati dell'esecuzione precedente, puoi aumentare il numero totale di job allocati DPUs a 55 e verificare le prestazioni del job. Il processo viene completato in meno di tre minuti, ossia in metà del tempo richiesto in precedenza. Il dimensionamento del processo non è lineare in questo caso, perché si tratta di un processo a esecuzione breve. I lavori con attività di lunga durata o con un numero elevato di attività (un numero elevato di esecutori massimi necessari) traggono vantaggio da un'accelerazione delle prestazioni con scalabilità orizzontale della close-to-linear DPU.
![\[Grafico che mostra l'aumento del numero totale di risorse allocate DPUs\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-capacity-3.png)
Come mostra l'immagine seguente, il numero totale di executor attivi raggiunge il numero massimo di executor allocati (107). Analogamente, il numero massimo di executor necessari non supera mai il numero massimo di executor allocati. Il numero massimo di executor necessari viene calcolato dai conteggi di attività in esecuzione e in attesa, quindi potrebbe essere inferiore al numero di executor attivi. Questo perché non ci possono essere executor che sono parzialmente o completamente inattivi per un breve periodo di tempo e non sono ancora stati rimossi.
![\[Grafico che mostra il numero totale di executor attivi che hanno raggiunto il numero massimo allocato.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-capacity-4.png)
Questa esecuzione del processo usa una quantità di executor sei volte maggiore per leggere e scrivere da Amazon S3 in parallelo. Di conseguenza, questa esecuzione del processo usa più larghezza di banda Amazon S3 per le operazioni di scrittura e lettura e termina più velocemente.
### Identifica l'eccesso di approvvigionamento DPUs
Successivamente, è possibile determinare se la scalabilità orizzontale del lavoro con 100 DPUs (99 \$1 2 = 198 esecutori) contribuisca a un'ulteriore scalabilità orizzontale. Come mostra il grafico seguente, il processo richiede ancora tre minuti per giungere al termine. Analogamente, la scalabilità del job non supera i 107 executor (55 DPUs configurazioni) e i restanti 91 executor sono sovradimensionati e non vengono utilizzati affatto. Ciò dimostra che l'aumento del numero di esecutori DPUs potrebbe non sempre migliorare le prestazioni, come risulta evidente dal numero massimo di executor necessari.
![\[Grafico che mostra che le prestazioni lavorative non sempre aumentano aumentando il numero di DPUs.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/monitor-debug-capacity-5.png)
### Confronto tra differenze di tempo
Le tre esecuzioni di job mostrate nella tabella seguente riepilogano i tempi di esecuzione dei job per 10 DPUs DPUs, 55 e 100 DPUs. Puoi individuare la capacità DPU per migliorare il tempo di esecuzione del processo usando le stime definite monitorando la prima esecuzione del processo.
| Job ID | Numero di DPUs | Ora di esecuzione |
| --- | --- | --- |
| jr\$1c894524c8ef5048a4d9... | 10 | 6 min. |
| jr\$11a466cf2575e7ffe6856... | 55 | 3 min. |
| jr\$134fa1ed4c6aa9ff0a814... | 100 | 3 min. |
# Risoluzione dei problemi di intelligenza artificiale generativa per Apache Spark in Glue AWS
La risoluzione dei problemi di intelligenza artificiale generativa per i lavori di Apache Spark in AWS Glue è una nuova funzionalità che aiuta i data engineer e gli scienziati a diagnosticare e risolvere i problemi nelle loro applicazioni Spark con facilità. Utilizzando tecnologie di machine learning e IA generativa, questa funzionalità analizza i problemi nei processi Spark e fornisce un'analisi dettagliata delle cause principali insieme a consigli pratici per risolverli. La risoluzione dei problemi di intelligenza artificiale generativa per Apache Spark è disponibile per i lavori in esecuzione su AWS Glue versione 4.0 e successive.
| |
| --- |
| Trasforma la risoluzione dei problemi di Apache Spark con il nostro agente di risoluzione dei problemi basato sull'intelligenza artificiale, che ora supporta tutte le principali modalità di implementazione tra cui Glue, Amazon EMR-, AWS Amazon EMR-Serverless e EC2 Amazon AI Notebooks. SageMaker Questo potente agente elimina i complessi processi di debug combinando interazioni in linguaggio naturale, analisi del carico di lavoro in tempo reale e consigli sul codice intelligente in un'esperienza senza interruzioni. Per i dettagli sull'implementazione, consulta [Cos'è l'agente di risoluzione dei problemi di Apache Spark per Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshoot.html). Guarda la seconda dimostrazione in [Using the Troubleshooting Agent](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshooting-using-troubleshooting-agent.html) for AWS Glue: esempi di risoluzione dei problemi. |
## Come funzione la risoluzione dei problemi relativi all'IA generativa per Apache Spark?
Per i job Spark non riusciti, Generative AI Troubleshooting analizza i metadati del lavoro e le metriche e i log precisi associati alla firma di errore del job per generare un'analisi della causa principale e consiglia soluzioni e best practice specifiche per aiutare a risolvere i problemi del lavoro.
## Configurare la risoluzione dei problemi relativi all'IA generativa per Apache Spark per i processi
### Configurazione delle autorizzazioni IAM
La concessione delle autorizzazioni ai file APIs utilizzati da Spark Troubleshooting per i tuoi lavori in AWS Glue richiede le autorizzazioni IAM appropriate. Puoi ottenere le autorizzazioni allegando la seguente AWS policy personalizzata alla tua identità IAM (ad esempio un utente, un ruolo o un gruppo).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:StartCompletion",
"glue:GetCompletion"
],
"Resource": [
"arn:aws:glue:*:*:completion/*",
"arn:aws:glue:*:*:job/*"
]
}
]
}
```
------
**Nota**
I due seguenti APIs vengono utilizzati nella policy IAM per abilitare questa esperienza tramite la console AWS Glue Studio: `StartCompletion` e`GetCompletion`.
### Assegnare le autorizzazioni
Per fornire l’accesso, aggiungi autorizzazioni agli utenti, gruppi o ruoli:
+ Per utenti e gruppi nel Centro identità IAM: Creazione di un set di autorizzazioni. Seguire le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html) nella Guida per l'utente del Centro identità IAM.
+ Per utenti gestiti in IAM tramite un provider di identità: crea un ruolo per la federazione delle identità. Seguire le istruzioni riportate nella pagina [Creazione di un ruolo per un provider di identità di terze parti (federazione)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html) nella Guida per l'utente di IAM.
+ Per utenti IAM: Creare un ruolo che l'utente è in grado di assumere. Seguire le istruzioni riportate nella pagina [Creazione di un ruolo per un utente IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) della Guida per l'utente di IAM.
## Esecuzione dell'analisi della risoluzione dei problemi da un'esecuzione non riuscita di un processo
È possibile accedere alla funzionalità di risoluzione dei problemi tramite più percorsi nella console AWS Glue. Ecco come iniziare:
### Opzione 1: dalla pagina Elenco dei processi
1. Apri la console AWS Glue all'indirizzo [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. Nel riquadro di navigazione, scegliere **Processi**.
1. Individuare il processo non riuscito nell'elenco dei processi.
1. Selezionare la scheda **Esecuzioni** nella sezione dei dettagli del processo.
1. Fare clic sull'esecuzione del processo non riuscito che si desidera analizzare.
1. Scegliere **Risoluzione dei problemi con IA** per avviare l'analisi.
1. Una volta completata l'analisi della risoluzione dei problemi, è possibile visualizzare l'analisi della causa principale e i consigli nella scheda **Analisi della risoluzione dei problemi** nella parte inferiore dello schermo.
![\[La GIF mostra l'implementazione completa di un'esecuzione non riuscita e la risoluzione dei problemi con la funzionalità AI in esecuzione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/troubleshoot_spark_option_1_jobs_list.gif)
### Opzione 2: usare la pagina Monitoraggio dell'esecuzione dei processi
1. Andare alla pagina **Monitoraggio dell'esecuzione dei processi**.
1. Individuare l'esecuzione del processo non riuscito.
1. Selezionare il menu a discesa **Operazioni**.
1. Scegliere **Risoluzione dei problemi con IA**.
![\[La GIF mostra l'implementazione completa di un'esecuzione non riuscita e la risoluzione dei problemi con la funzionalità AI in esecuzione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/troubleshoot_spark_option_2_job_monitoring.gif)
### Opzione 3: dalla pagina Dettagli dell'esecuzione dei processi
1. Andare sulla pagina dei dettagli dell'esecuzione del processo non riuscito facendo clic su **Visualizza dettagli** su un'esecuzione non riuscita dalla scheda **Esecuzioni** o selezionando il processo eseguito dalla pagina **Monitoraggio dell'esecuzione dei processi**.
1. Nella pagina dei dettagli dell'esecuzione del processo, individuare la scheda **Analisi della risoluzione dei problemi**.
## Categorie di risoluzione dei problemi supportate
Questo servizio si concentra su tre categorie principali di problemi che gli scienziati dei dati e gli sviluppatori affrontano frequentemente nelle loro applicazioni Spark:
+ **Errori di configurazione e accesso alle risorse:** quando si eseguono applicazioni Spark in AWS Glue, gli errori di configurazione e accesso alle risorse sono tra i problemi più comuni ma difficili da diagnosticare. Questi errori si verificano spesso quando l'applicazione Spark tenta di interagire con AWS le risorse ma riscontra problemi di autorizzazione, risorse mancanti o problemi di configurazione.
+ **Problemi di memoria del driver Spark e dell'esecutore:** gli errori relativi alla memoria nei processi di Apache Spark possono essere complessi da diagnosticare e risolvere. Questi errori si verificano spesso quando i requisiti di elaborazione dei dati superano le risorse di memoria disponibili, sul nodo driver o sui nodi esecutori.
+ **Problemi di capacità del disco Spark:** gli errori relativi allo storage nei job AWS Glue Spark spesso emergono durante le operazioni di shuffle, la fuoriuscita di dati o quando si ha a che fare con trasformazioni di dati su larga scala. Questi errori possono essere particolarmente complicati perché potrebbero verificarsi solo dopo un certo periodo di esecuzione del processo, con il rischio di sprecare risorse di elaborazione e tempo preziosi.
+ Errori di **esecuzione delle query: gli errori** di query in Spark SQL e nelle DataFrame operazioni possono essere difficili da risolvere perché i messaggi di errore potrebbero non indicare chiaramente la causa principale e le query che funzionano bene con set di dati di piccole dimensioni possono improvvisamente fallire su larga scala. Questi errori diventano ancora più difficili quando si verificano all'interno di pipeline di trasformazione complesse, dove il vero problema può derivare da problemi di qualità dei dati nelle fasi precedenti piuttosto che dalla logica di interrogazione stessa.
**Nota**
Prima di implementare le modifiche suggerite nell'ambiente di produzione, esaminare attentamente le modifiche suggerite. Il servizio fornisce consigli basati su modelli e best practice, ma il caso d'uso specifico potrebbe richiedere ulteriori considerazioni.
## Regioni supportate
La risoluzione dei problemi di intelligenza artificiale generativa per Apache Spark è disponibile nelle seguenti regioni:
+ **Africa**: Città del Capo (af-south-1)
+ **Asia Pacifico**: Hong Kong (ap-east-1), Tokyo (ap-northeast-1), Seul (ap-northeast-2), Osaka (ap-northeast-3), Mumbai (ap-south-1), Singapore (ap-southeast-1)), Sydney (ap-southeast-2) e Giacarta (ap-southeast-3)
+ **Europa**: Francoforte (eu-central-1), Stoccolma (eu-north-1), Milano (eu-south-1), Irlanda (eu-west-1), Londra (eu-west-2) e Parigi (eu-west-3)
+ **Medio Oriente**: Bahrein (me-south-1) e Emirati Arabi Uniti (me-central-1)
+ **Nord America**: Canada (ca-central-1)
+ **Sud America**: San Paolo (sa-east-1)
+ **Stati Uniti**: Virginia del Nord (us-east-1), Ohio (us-east-2), California del Nord (us-west-1) e Oregon (us-west-2)
# Utilizzo di viste materializzate con AWS Glue
AWS La versione 5.1 e successive di Glue supporta la creazione e la gestione delle viste materializzate di Apache Iceberg nel AWS Glue Data Catalog. Una vista materializzata è una tabella gestita che memorizza il risultato precalcolato di una query SQL in formato Apache Iceberg e si aggiorna in modo incrementale man mano che le tabelle di origine sottostanti cambiano. È possibile utilizzare le viste materializzate per semplificare le pipeline di trasformazione dei dati e accelerare le prestazioni delle query per carichi di lavoro analitici complessi.
Quando crei una vista materializzata utilizzando Spark in AWS Glue, la definizione della vista e i metadati vengono archiviati nel AWS Glue Data Catalog. I risultati precalcolati vengono archiviati come tabelle Apache Iceberg in bucket Amazon S3 Tables o bucket Amazon S3 per uso generico all'interno del tuo account. Il AWS Glue Data Catalog monitora automaticamente le tabelle dei sorgenti e aggiorna le viste materializzate utilizzando un'infrastruttura di elaborazione gestita.
**Topics**
+ [Come funzionano le viste materializzate con AWS Glue](#materialized-views-how-they-work)
+ [Prerequisiti](#materialized-views-prerequisites)
+ [Configurazione di Spark per l'utilizzo di viste materializzate](#materialized-views-configuring-spark)
+ [Creazione di viste materializzate](#materialized-views-creating)
+ [Invio di query alle viste materializzate](#materialized-views-querying)
+ [Aggiornamento delle viste materializzate](#materialized-views-refreshing)
+ [Gestione delle viste materializzate](#materialized-views-managing)
+ [Autorizzazioni per le viste materializzate](#materialized-views-permissions)
+ [Monitoraggio delle operazioni di visualizzazione materializzata](#materialized-views-monitoring)
+ [Esempio: flusso di lavoro completo](#materialized-views-complete-workflow)
+ [Considerazioni e limitazioni](#materialized-views-considerations-limitations)
## Come funzionano le viste materializzate con AWS Glue
Le viste materializzate si integrano con AWS Glue tramite il supporto Iceberg di Apache Spark nei notebook Glue AWS job e AWS Glue Studio. Quando configuri la sessione Spark per utilizzare il AWS Glue Data Catalog, puoi creare viste materializzate utilizzando la sintassi SQL standard. L'ottimizzatore Spark può riscrivere automaticamente le query per utilizzare le viste materializzate quando offrono prestazioni migliori, eliminando la necessità di modificare manualmente il codice dell'applicazione.
Il AWS Glue Data Catalog gestisce tutti gli aspetti operativi della manutenzione delle viste materializzate, tra cui:
+ Rilevamento delle modifiche nelle tabelle dei sorgenti utilizzando il livello di metadati di Apache Iceberg
+ Pianificazione ed esecuzione di operazioni di aggiornamento utilizzando il calcolo Spark gestito
+ Determinare se eseguire l'aggiornamento completo o incrementale in base alle modifiche dei dati
+ Memorizzazione dei risultati precalcolati in formato Apache Iceberg per l'accesso a più motori
Puoi interrogare le viste materializzate da AWS Glue usando le stesse interfacce SQL Spark che usi per le tabelle normali. I dati precalcolati sono accessibili anche da altri servizi, tra cui Amazon Athena e Amazon Redshift.
## Prerequisiti
Per utilizzare le viste materializzate con AWS Glue, è necessario:
+ Un account
+ AWS Glue versione 5.1 o successiva
+ Tabelle di origine in formato Apache Iceberg registrate nel AWS Glue Data Catalog
+ AWS Lake Formation autorizzazioni configurate per le tabelle di origine e i database di destinazione
+ Un bucket S3 Tables o un bucket S3 generico registrato per l'archiviazione dei dati delle viste materializzate AWS Lake Formation
+ Un ruolo IAM con autorizzazioni per accedere a AWS Glue Data Catalog e Amazon S3
## Configurazione di Spark per l'utilizzo di viste materializzate
Per creare e gestire le viste materializzate in AWS Glue, configura la tua sessione Spark con le estensioni Iceberg e le impostazioni del catalogo richieste. Il metodo di configurazione varia a seconda che si utilizzino i lavori AWS Glue o i notebook AWS Glue Studio.
### Configurazione dei lavori AWS Glue
Durante la creazione o l'aggiornamento di un lavoro AWS Glue, aggiungete i seguenti parametri di configurazione come parametri del lavoro:
#### Per i bucket S3 Tables
```
job = glue.create_job(
Name='materialized-view-job',
Role='arn:aws:iam::111122223333:role/GlueServiceRole',
Command={
'Name': 'glueetl',
'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py',
'PythonVersion': '3'
},
DefaultArguments={
'--enable-glue-datacatalog': 'true',
'--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions '
'--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog '
'--conf spark.sql.catalog.glue_catalog.type=glue '
'--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse '
'--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 '
'--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 '
'--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ',
'--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ',
'--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog '
'--conf spark.sql.catalog.s3t_catalog.type=glue '
'--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket ',
'--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 ',
'--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true ',
'--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse '
'--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 '
'--conf spark.sql.defaultCatalog=s3t_catalog '
'--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
'--conf spark.sql.materializedViews.metadataCache.enabled=true'
},
GlueVersion='5.1'
)
```
#### Per bucket S3 per uso generico
```
job = glue.create_job(
Name='materialized-view-job',
Role='arn:aws:iam::111122223333:role/GlueServiceRole',
Command={
'Name': 'glueetl',
'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py',
'PythonVersion': '3'
},
DefaultArguments={
'--enable-glue-datacatalog': 'true',
'--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions '
'--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog '
'--conf spark.sql.catalog.glue_catalog.type=glue '
'--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse '
'--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 '
'--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ',
'--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ',
'--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ',
'--conf spark.sql.defaultCatalog=glue_catalog '
'--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true '
'--conf spark.sql.materializedViews.metadataCache.enabled=true'
},
GlueVersion='5.1'
)
```
### Configurazione dei notebook AWS Glue Studio
Nei taccuini AWS Glue Studio, configura la tua sessione Spark usando il comando magico %%configure all'inizio del notebook:
```
%%configure
{
"conf": {
"spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
"spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.glue_catalog.type": "glue",
"spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse",
"spark.sql.catalog.glue_catalog.glue.region": "us-east-1",
"spark.sql.catalog.glue_catalog.glue.id": "111122223333",
"spark.sql.catalog.glue_catalog.glue.account-id": "111122223333",
"spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true",
"spark.sql.defaultCatalog": "glue_catalog",
"spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
"spark.sql.materializedViews.metadataCache.enabled": "true"
}
}
```
### Attivazione dell'aggiornamento incrementale
Per abilitare l'ottimizzazione dell'aggiornamento incrementale, aggiungete le seguenti proprietà di configurazione ai parametri del lavoro o alla configurazione del notebook:
```
--conf spark.sql.optimizer.incrementalMVRefresh.enabled=true
--conf spark.sql.optimizer.incrementalMVRefresh.deltaThresholdCheckEnabled=false
```
### Parametri di configurazione
I seguenti parametri di configurazione controllano il comportamento delle viste materializzate:
+ `spark.sql.extensions`— Abilita le estensioni di sessione Iceberg Spark necessarie per il supporto delle viste materializzate.
+ `spark.sql.optimizer.answerQueriesWithMVs.enabled`— Consente la riscrittura automatica delle query per utilizzare le viste materializzate. Imposta su true per attivare questa ottimizzazione.
+ `spark.sql.materializedViews.metadataCache.enabled`— Abilita la memorizzazione nella cache dei metadati delle viste materializzate per l'ottimizzazione delle query. Impostato su true per migliorare le prestazioni di riscrittura delle query.
+ `spark.sql.optimizer.incrementalMVRefresh.enabled`— Consente l'ottimizzazione incrementale dell'aggiornamento. Impostato su true per elaborare solo i dati modificati durante le operazioni di aggiornamento.
+ `spark.sql.optimizer.answerQueriesWithMVs.decimalAggregateCheckEnabled`— Controlla la convalida delle operazioni di aggregazione decimale nella riscrittura delle query. Imposta su false per disabilitare determinati controlli di overflow decimale.
## Creazione di viste materializzate
È possibile creare viste materializzate utilizzando l'istruzione SQL CREATE MATERIALIZED VIEW nei lavori o nei AWS notebook Glue. La definizione della vista specifica la logica di trasformazione come una query SQL che fa riferimento a una o più tabelle di origine.
### Creazione di una vista materializzata di base nei lavori AWS Glue
L'esempio seguente dimostra la creazione di una vista materializzata in uno script di lavoro AWS Glue, utilizza nomi di tabella completi con una convenzione di denominazione in tre parti nella definizione della vista:
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Create materialized view
spark.sql("""
CREATE MATERIALIZED VIEW customer_orders
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
""")
```
### Creazione di una vista materializzata con aggiornamento automatico
Per configurare l'aggiornamento automatico, specificate una pianificazione di aggiornamento durante la creazione della vista, utilizzando nomi di tabella completi con una convenzione di denominazione in tre parti nella definizione della vista:
```
spark.sql("""
CREATE MATERIALIZED VIEW customer_orders
SCHEDULE REFRESH EVERY 1 HOUR
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
""")
```
### Creazione di una vista materializzata con riferimenti tra cataloghi
Quando le tabelle di origine si trovano in un catalogo diverso rispetto alla vista materializzata, utilizzate nomi di tabella completi con una convenzione di denominazione in tre parti sia nel nome della vista che nella definizione della vista:
```
spark.sql("""
CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
""")
```
### Creazione di viste materializzate nei notebook AWS Glue Studio
Nei notebook AWS Glue Studio, è possibile utilizzare il comando magico %%sql per creare viste materializzate, utilizzando nomi di tabella completi con una convenzione di denominazione in tre parti nella definizione delle viste:
```
%%sql
CREATE MATERIALIZED VIEW customer_orders
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
```
## Invio di query alle viste materializzate
Dopo aver creato una vista materializzata, è possibile interrogarla come qualsiasi altra tabella utilizzando le istruzioni SQL SELECT standard nei job o nei notebook AWS Glue.
### Interrogazione nei lavori AWS Glue
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Query materialized view
result = spark.sql("SELECT * FROM customer_orders")
result.show()
```
### Interrogazione nei notebook AWS Glue Studio
```
%%sql
SELECT * FROM customer_orders
```
### Riscrittura automatica delle interrogazioni
Quando la riscrittura automatica delle query è abilitata, l'ottimizzatore Spark analizza le query e utilizza automaticamente le viste materializzate quando possono migliorare le prestazioni. Ad esempio, se esegui la seguente query:
```
result = spark.sql("""
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM orders
GROUP BY customer_name
""")
```
L'ottimizzatore Spark riscrive automaticamente questa query per utilizzare la vista materializzata customer\$1orders invece di elaborare la tabella degli ordini di base, a condizione che la vista materializzata sia aggiornata.
### Verifica della riscrittura automatica delle query
Per verificare se una query utilizza la riscrittura automatica delle query, utilizzate il comando EXPLAIN EXTENDED:
```
spark.sql("""
EXPLAIN EXTENDED
SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount
FROM orders
GROUP BY customer_name
""").show(truncate=False)
```
Nel piano di esecuzione, cercate il nome della vista materializzata nell' BatchScan operazione. Se il piano mostra BatchScan glue\$1catalog.analytics.customer\$1orders anziché glue\$1catalog.sales.orders, la query è stata riscritta automaticamente per utilizzare la BatchScan vista materializzata.
Tieni presente che la riscrittura automatica delle query richiede del tempo prima che la cache dei metadati Spark venga compilata dopo la creazione di una vista materializzata. Questo processo viene in genere completato entro 30 secondi.
## Aggiornamento delle viste materializzate
È possibile aggiornare le viste materializzate utilizzando due metodi: aggiornamento completo o aggiornamento incrementale. L'aggiornamento completo ricalcola l'intera vista materializzata da tutti i dati della tabella di base, mentre l'aggiornamento incrementale elabora solo i dati che sono stati modificati dall'ultimo aggiornamento.
### Aggiornamento manuale completo nei lavori AWS Glue
Per eseguire un aggiornamento completo di una vista materializzata:
```
spark.sql("REFRESH MATERIALIZED VIEW customer_orders FULL")
# Verify updated results
result = spark.sql("SELECT * FROM customer_orders")
result.show()
```
### Aggiornamento incrementale manuale nei lavori AWS Glue
Per eseguire un aggiornamento incrementale, assicurati che l'aggiornamento incrementale sia abilitato nella configurazione della sessione Spark, quindi esegui:
```
spark.sql("REFRESH MATERIALIZED VIEW customer_orders")
# Verify updated results
result = spark.sql("SELECT * FROM customer_orders")
result.show()
```
Il AWS Glue Data Catalog determina automaticamente se l'aggiornamento incrementale è applicabile in base alla definizione della vista e alla quantità di dati modificati. Se l'aggiornamento incrementale non è possibile, l'operazione torna all'aggiornamento completo.
### Aggiornamento nei notebook AWS Glue Studio
Nei notebook, usa il comando magico %%sql:
```
%%sql
REFRESH MATERIALIZED VIEW customer_orders FULL
```
### Verifica dell'esecuzione dell'aggiornamento incrementale
Per confermare che l'aggiornamento incrementale sia stato eseguito correttamente, abilita la registrazione di debug nel tuo job Glue: AWS
```
from awsglue.context import GlueContext
from pyspark.context import SparkContext
import logging
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
# Enable debug logging
logger = logging.getLogger('org.apache.spark.sql')
logger.setLevel(logging.DEBUG)
# Execute refresh
spark.sql("REFRESH MATERIALIZED VIEW customer_orders")
```
Cerca il seguente messaggio nei log dei lavori di AWS Glue:
```
DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh
```
## Gestione delle viste materializzate
AWS Glue fornisce comandi SQL per la gestione del ciclo di vita delle viste materializzate nei lavori e nei notebook.
### Descrizione di una vista materializzata
Per visualizzare i metadati relativi a una vista materializzata, tra cui la definizione, lo stato di aggiornamento e il timestamp dell'ultimo aggiornamento:
```
spark.sql("DESCRIBE EXTENDED customer_orders").show(truncate=False)
```
### Alterazione di una vista materializzata
Per modificare la pianificazione di aggiornamento di una vista materializzata esistente:
```
spark.sql("""
ALTER MATERIALIZED VIEW customer_orders
ADD SCHEDULE REFRESH EVERY 2 HOURS
""")
```
Per rimuovere l'aggiornamento automatico:
```
spark.sql("""
ALTER MATERIALIZED VIEW customer_orders
DROP SCHEDULE
""")
```
### Eliminare una vista materializzata
Per eliminare una vista materializzata:
```
spark.sql("DROP MATERIALIZED VIEW customer_orders")
```
Questo comando rimuove la definizione della vista materializzata dal AWS Glue Data Catalog ed elimina i dati della tabella Iceberg sottostante dal bucket S3.
### Elenco delle viste materializzate
Per elencare tutte le viste materializzate in un database:
```
spark.sql("SHOW VIEWS FROM analytics").show()
```
## Autorizzazioni per le viste materializzate
Per creare e gestire le viste materializzate, è necessario configurare le autorizzazioni. AWS Lake Formation Il ruolo IAM che crea la vista materializzata (il ruolo definer) richiede autorizzazioni specifiche sulle tabelle di origine e sui database di destinazione.
### Autorizzazioni richieste per il ruolo di definitore
Il ruolo che definisce deve avere i seguenti permessi di Lake Formation:
+ Nelle tabelle di origine: autorizzazioni SELECT o ALL senza filtri di riga, colonna o cella
+ Sul database di destinazione: autorizzazione CREATE\$1TABLE
+ Sul AWS Glue Data Catalog GetTable e sulle autorizzazioni CreateTable API
Quando si crea una vista materializzata, l'ARN del ruolo definitore viene memorizzato nella definizione della vista. Il AWS Glue Data Catalog assume questo ruolo durante l'esecuzione di operazioni di aggiornamento automatico. Se il ruolo di definitore perde l'accesso alle tabelle di origine, le operazioni di aggiornamento falliranno fino al ripristino delle autorizzazioni.
### Autorizzazioni IAM per i lavori AWS Glue
Il ruolo IAM del tuo lavoro AWS Glue richiede le seguenti autorizzazioni:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"glue:GetCatalog",
"glue:GetCatalogs",
"glue:GetTable",
"glue:GetTables",
"glue:CreateTable",
"glue:UpdateTable",
"glue:DeleteTable",
"glue:GetDatabase",
"glue:GetDatabases",
"cloudwatch:PutMetricData"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket"
]
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:*:*:*:/aws-glue/*"
]
},
{
"Effect": "Allow",
"Action": [
"lakeformation:GetDataAccess"
],
"Resource": "*"
}
]
}
```
Il ruolo che usi per l'aggiornamento automatico di Materialized View deve avere l'PassRole autorizzazione iam: sul ruolo.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/materialized-view-role-name"
]
}
]
}
```
Affinché Glue aggiorni automaticamente la vista materializzata, il ruolo deve inoltre avere la seguente politica di attendibilità che consenta al servizio di assumere il ruolo.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/materialized-view-role-name"
]
}
]
}
```
Se la vista materializzata è archiviata in S3 Tables Bucket, devi anche aggiungere la seguente autorizzazione al ruolo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3tables:PutTableMaintenanceConfiguration"
],
"Resource": "arn:aws:s3tables:*:123456789012:*"
}
]
}
```
### Concessione dell'accesso alle viste materializzate
Per concedere ad altri utenti l'accesso all'interrogazione di una vista materializzata, utilizzare questa opzione AWS Lake Formation per concedere l'autorizzazione SELECT sulla tabella delle viste materializzate. Gli utenti possono interrogare la vista materializzata senza richiedere l'accesso diretto alle tabelle di origine sottostanti.
Per informazioni dettagliate sulla configurazione delle autorizzazioni di Lake Formation, consulta Concessione e revoca delle autorizzazioni sulle risorse di Data Catalog nella Developer Guide. AWS Lake Formation
## Monitoraggio delle operazioni di visualizzazione materializzata
Il AWS Glue Data Catalog pubblica metriche e log per le operazioni di aggiornamento delle viste materializzate su Amazon. CloudWatch Puoi monitorare lo stato dell'aggiornamento, la durata e il volume di dati elaborati tramite metriche. CloudWatch
### Visualizzazione dei registri dei lavori
Per visualizzare i log dei lavori AWS Glue che creano o aggiornano viste materializzate:
1. Apri la console AWS Glue.
1. Scegli Jobs dal pannello di navigazione.
1. Seleziona il tuo lavoro e scegli Esegue.
1. Seleziona una corsa specifica e scegli Registri per visualizzare i CloudWatch registri.
### Configurazione degli allarmi
Per ricevere notifiche quando le operazioni di aggiornamento falliscono o superano la durata prevista, crea CloudWatch allarmi sulle metriche delle viste materializzate. Puoi anche configurare EventBridge le regole di Amazon per attivare risposte automatiche agli eventi di aggiornamento.
## Esempio: flusso di lavoro completo
L'esempio seguente dimostra un flusso di lavoro completo per la creazione e l'utilizzo di una vista materializzata in AWS Glue.
### Esempio di script AWS Glue job
```
import sys
from awsglue.transforms import *
from awsglue.utils import getResolvedOptions
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.job import Job
args = getResolvedOptions(sys.argv, ['JOB_NAME'])
sc = SparkContext()
glueContext = GlueContext(sc)
spark = glueContext.spark_session
job = Job(glueContext)
job.init(args['JOB_NAME'], args)
# Create database and base table
spark.sql("CREATE DATABASE IF NOT EXISTS sales")
spark.sql("USE sales")
spark.sql("""
CREATE TABLE IF NOT EXISTS orders (
id INT,
customer_name STRING,
amount DECIMAL(10,2),
order_date DATE
)
""")
# Insert sample data
spark.sql("""
INSERT INTO orders VALUES
(1, 'John Doe', 150.00, DATE('2024-01-15')),
(2, 'Jane Smith', 200.50, DATE('2024-01-16')),
(3, 'Bob Johnson', 75.25, DATE('2024-01-17'))
""")
# Create materialized view
spark.sql("""
CREATE MATERIALIZED VIEW customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
""")
# Query the materialized view
print("Initial materialized view data:")
spark.sql("SELECT * FROM customer_summary").show()
# Insert additional data
spark.sql("""
INSERT INTO orders VALUES
(4, 'Jane Smith', 350.00, DATE('2024-01-18')),
(5, 'Bob Johnson', 100.25, DATE('2024-01-19'))
""")
# Refresh the materialized view
spark.sql("REFRESH MATERIALIZED VIEW customer_summary FULL")
# Query updated results
print("Updated materialized view data:")
spark.sql("SELECT * FROM customer_summary").show()
job.commit()
```
### Esempio di notebook AWS Glue Studio
```
%%configure
{
"conf": {
"spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions",
"spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.glue_catalog.type": "glue",
"spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse",
"spark.sql.catalog.glue_catalog.glue.region": "us-east-1",
"spark.sql.catalog.glue_catalog.glue.id": "111122223333",
"spark.sql.catalog.glue_catalog.glue.account-id": "111122223333",
"spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true",
"spark.sql.defaultCatalog": "glue_catalog",
"spark.sql.optimizer.answerQueriesWithMVs.enabled": "true",
"spark.sql.materializedViews.metadataCache.enabled": "true"
}
}
```
```
%%sql
CREATE DATABASE IF NOT EXISTS sales
```
```
%%sql
USE sales
```
```
%%sql
CREATE TABLE IF NOT EXISTS orders (
id INT,
customer_name STRING,
amount DECIMAL(10,2),
order_date DATE
)
```
```
%%sql
INSERT INTO orders VALUES
(1, 'John Doe', 150.00, DATE('2024-01-15')),
(2, 'Jane Smith', 200.50, DATE('2024-01-16')),
(3, 'Bob Johnson', 75.25, DATE('2024-01-17'))
```
```
%%sql
CREATE MATERIALIZED VIEW customer_summary
AS
SELECT
customer_name,
COUNT(*) as order_count,
SUM(amount) as total_amount
FROM glue_catalog.sales.orders
GROUP BY customer_name
```
```
%%sql
SELECT * FROM customer_summary
```
```
%%sql
INSERT INTO orders VALUES
(4, 'Jane Smith', 350.00, DATE('2024-01-18')),
(5, 'Bob Johnson', 100.25, DATE('2024-01-19'))
```
```
%%sql
REFRESH MATERIALIZED VIEW customer_summary FULL
```
```
%%sql
SELECT * FROM customer_summary
```
## Considerazioni e limitazioni
Considerate quanto segue quando utilizzate viste materializzate con AWS Glue:
+ Le viste materializzate richiedono AWS Glue versione 5.1 o successiva.
+ Le tabelle di origine devono essere tabelle Apache Iceberg registrate nel AWS Glue Data Catalog. Le tabelle Apache Hive, Apache Hudi e Linux Foundation Delta Lake non sono supportate al momento del lancio.
+ Le tabelle di origine devono risiedere nella stessa regione e nello stesso account della vista materializzata.
+ Tutte le tabelle di origine devono essere governate da. AWS Lake Formation Le autorizzazioni solo IAM e l'accesso ibrido non sono supportati.
+ Le viste materializzate non possono fare riferimento alle viste del AWS Glue Data Catalog, alle viste multidialettali o ad altre viste materializzate come tabelle di origine.
+ Il ruolo View Definer deve disporre dell'accesso completo in lettura (autorizzazione SELECT o ALL) su tutte le tabelle di origine senza applicare filtri di riga, colonna o cella.
+ Le viste materializzate alla fine sono coerenti con le tabelle di origine. Durante la finestra di aggiornamento, le query possono restituire dati non aggiornati. Esegui l'aggiornamento manuale per una coerenza immediata.
+ L'intervallo minimo di aggiornamento automatico è di un'ora.
+ L'aggiornamento incrementale supporta un sottoinsieme limitato di operazioni SQL. La definizione della vista deve essere un singolo blocco SELECT-FROM-WHERE-GROUP BY-HAVING e non può contenere operazioni di set, sottoquery, la parola chiave DISTINCT in SELECT o funzioni aggregate, funzioni di finestra o join diversi da INNER JOIN.
+ L'aggiornamento incrementale non supporta funzioni definite dall'utente o determinate funzioni integrate. È supportato solo un sottoinsieme delle funzioni integrate di Spark SQL.
+ La riscrittura automatica delle query considera solo le viste materializzate le cui definizioni appartengono a un sottoinsieme SQL limitato, simile alle restrizioni di aggiornamento incrementale.
+ Gli identificatori contenenti caratteri speciali diversi dai caratteri alfanumerici e dai caratteri di sottolineatura non sono supportati nelle query CREATE MATERIALIZED VIEW. Questo vale per tutti i tipi di identificatori, inclusi catalog/namespace/table nomi, nomi di campi di colonne e strutture e alias. CTEs
+ Le colonne delle viste materializzate che iniziano con il prefisso \$1\$1ivm sono riservate all'uso del sistema. Amazon si riserva il diritto di modificare o rimuovere queste colonne nelle versioni future.
+ Le clausole SORT BY, LIMIT, OFFSET, CLUSTER BY e ORDER BY non sono supportate nelle definizioni delle viste materializzate.
+ Le tabelle di origine tra regioni e tra account non sono supportate.
+ Le tabelle a cui si fa riferimento nella query di visualizzazione devono utilizzare una convenzione di denominazione in tre parti (ad esempio, glue\$1catalog.my\$1db.my\$1table) perché l'aggiornamento automatico non utilizza le impostazioni predefinite del catalogo e del database.
+ Le operazioni di aggiornamento completo sovrascrivono l'intera tabella e rendono non disponibili le istantanee precedenti.
+ Le funzioni non deterministiche come rand () o current\$1timestamp () non sono supportate nelle definizioni delle viste materializzate.
# AWS Glue tipi di lavoratori
## Panoramica di
AWS Glue offre diversi tipi di lavoratori per soddisfare diversi requisiti di carico di lavoro, da piccoli lavori in streaming a attività di elaborazione dati su larga scala e che richiedono molta memoria. Questa sezione fornisce informazioni complete su tutti i tipi di worker disponibili, le relative specifiche e i consigli di utilizzo.
### Categorie di tipi di worker
AWS Glue offre due categorie principali di tipi di lavoratori:
+ **Tipi di worker G**: elaboratori generici ottimizzati per carichi di lavoro ETL standard
+ **Tipi di worker R**: worker ottimizzati per la memoria progettati per applicazioni Spark che richiedono molta memoria
### Unità di elaborazione dati (DPUs)
Le risorse disponibili per i AWS Glue lavoratori sono misurate in DPUs. Una DPU è una misura relativa della potenza di elaborazione costituita da 4 V CPUs di capacità di elaborazione e 16 GB di memoria.
**Ottimizzato per la memoria DPUs (M-DPUs):** i lavoratori di tipo R utilizzano M-DPUs, che fornisce il doppio dell'allocazione di memoria per una determinata dimensione rispetto allo standard. DPUs Ciò significa che mentre una DPU standard fornisce 16 GB di memoria, una M-DPU di tipo R fornisce 32 GB di memoria ottimizzata per le applicazioni Spark a uso intensivo di memoria.
## Tipi di worker disponibili
### G.1X
+ **DPU**: 1 DPU (4 vCPUs, 16 GB di memoria)
+ **Memoria**: disco da 94 GB (circa 44 GB liberi)
+ **Caso d'uso**: trasformazioni, unioni e query di dati: scalabile e conveniente per la maggior parte dei processi
### G.2X
+ **DPU**: 2 DPU (8 vCPUs, 32 GB di memoria)
+ **Memoria**: disco da 138 GB (circa 78 GB liberi)
+ **Caso d'uso**: trasformazioni, unioni e query di dati: scalabile e conveniente per la maggior parte dei processi
### G.4X
+ **DPU**: 4 DPU (16 vCPUs, 64 GB di memoria)
+ **Memoria**: disco da 256 GB (circa 230 GB liberi)
+ **Caso d'uso**: trasformazioni, aggregazioni, join e query con i maggiori requisiti
### G.8X
+ **DPU**: 8 DPU (32 vCPUs, 128 GB di memoria)
+ **Memoria**: disco da 512 GB (circa 485 GB liberi)
+ **Caso d'uso**: trasformazioni, aggregazioni, join e query con i maggiori requisiti
### G.12X
+ **DPU**: 12 DPU (48 vCPUs, 192 GB di memoria)
+ **Memoria**: disco da 768 GB (circa 741 GB liberi)
+ **Caso d'uso**: carichi di lavoro molto grandi e che richiedono molte risorse con una notevole capacità di elaborazione
### G.16X
+ **DPU**: 16 DPU (64 vCPUs, 256 GB di memoria)
+ **Memoria**: disco da 1024 GB (circa 996 GB liberi)
+ **Caso d'uso**: carichi di lavoro più grandi in assoluto e che richiedono la maggiore capacità di elaborazione possibile
### R.1X - Ottimizzato per la memoria\$1
+ **DPU: 1 M-DPU** (4 v, 32 GB di memoria) CPUs
+ **Caso d'uso**: carichi di lavoro a uso intensivo di memoria con errori frequenti o requisiti di rapporto elevato out-of-memory memory-to-CPU
### R.2X - Ottimizzato per la memoria\$1
+ **DPU: 2 M-DPU** (8 v, 64 GB di memoria) CPUs
+ **Caso d'uso**: carichi di lavoro a uso intensivo di memoria con errori frequenti o requisiti di rapporto elevato out-of-memory memory-to-CPU
### R.4X - Ottimizzato per la memoria\$1
+ **DPU: 4 M-DPU** (16 v, 128 GB di memoria) CPUs
+ **Caso d'uso**: grandi carichi di lavoro che richiedono molta memoria con errori frequenti o requisiti di rapporto elevato out-of-memory memory-to-CPU
### R.8X - Ottimizzato per la memoria\$1
+ **DPU: 8 M-DPU** (32 v, 256 GB di memoria) CPUs
+ **Caso d'uso**: carichi di lavoro molto grandi che richiedono molta memoria con errori frequenti o requisiti di rapporto elevato out-of-memory memory-to-CPU
**\$1**È possibile riscontrare una maggiore latenza di avvio con questi worker. Per risolvere il problema, provare a eseguire queste operazioni:
+ Attendere alcuni minuti, quindi inviare di nuovo il processo.
+ Inviare un nuovo processo con un numero ridotto di worker.
+ Inviare un nuovo processo utilizzando un tipo o una dimensione di worker diversi.
## Tabella delle specifiche del tipo di worker
**Specifiche del tipo di worker**
| Tipo di worker | DPU per nodo | VPCU | Memoria (GB) | Disco (GB) | Spazio libero su disco approssimativo (GB) | Esecutori Spark per nodo |
| --- | --- | --- | --- | --- | --- | --- |
| G.1X | 1 | 4 | 16 | 94 | 44 | 1 |
| G.2X | 2 | 8 | 32 | 138 | 78 | 1 |
| G.4X | 4 | 16 | 64 | 256 | 230 | 1 |
| G.8X | 8 | 32 | 128 | 512 | 485 | 1 |
| G.12X | 12 | 48 | 192 | 768 | 741 | 1 |
| G.16X | 16 | 64 | 256 | 1.024 | 996 | 1 |
| R.1 X | 1 | 4 | 32 | 94 | 44 | 1 |
| R.2X | 2 | 8 | 64 | 138 | 78 | 1 |
| R. 4X | 4 | 16 | 128 | 256 | 230 | 1 |
| R.8X | 8 | 32 | 256 | 512 | 485 | 1 |
*Nota*: i tipi di worker R hanno configurazioni ottimizzate per la memoria con specifiche ottimizzate per carichi di lavoro che richiedono molta memoria.
## Considerazioni importanti
### Latenza di avvio
**Importante**
I tipi di worker G.12X e G.16X, così come tutti i tipi di worker R (da R.1X a R.8X), possono riscontrare una latenza di avvio più elevata. Per risolvere il problema, provare a eseguire queste operazioni:
Attendere alcuni minuti, quindi inviare di nuovo il processo.
Inviare un nuovo processo con un numero ridotto di worker.
Inviare un nuovo processo utilizzando un tipo e una dimensione di worker diversi.
## Scegliere il tipo di worker giusto
### Per carichi di lavoro ETL standard
+ **G.1X o G.2X**: la soluzione più conveniente per le trasformazioni, i join e le query tipiche dei dati
+ **G.4X o G.8X**: per carichi di lavoro più impegnativi con set di dati più grandi
### Per carichi di lavoro su larga scala
+ **G.12X**: set di dati molto grandi che richiedono risorse di elaborazione significative
+ **G.16X**: capacità di elaborazione massima per i carichi di lavoro più impegnativi
### Per carichi di lavoro a uso intensivo di memoria
+ **R.1X o R.2X**: processi di piccole e medie dimensioni con uso intensivo di memoria
+ **R.4X o R.8X**: carichi di lavoro di grandi dimensioni a uso intensivo di memoria con frequenti errori OOM
## Considerazioni per l'ottimizzazione dei costi
+ **Worker G standard**: offrono il giusto rapporto tra risorse di calcolo, memoria e rete e possono essere utilizzati per una varietà di carichi di lavoro diversi a costi inferiori
+ **Worker R**: specializzati per attività a uso intensivo di memoria con prestazioni elevate per carichi di lavoro che elaborano set di dati di grandi dimensioni in memoria
## Best practice
### Linee guida per la selezione dei worker
1. **Avvio con worker standard** (G.1X, G.2X) per la maggior parte dei carichi di lavoro
1. **Usa R worker** in caso di out-of-memory errori o carichi di lavoro frequenti con operazioni che richiedono molta memoria come caching, shuffling e aggregazione
1. **Considerare G.12X/G.16X** per carichi di lavoro ad alta intensità di calcolo che richiedono il massimo delle risorse
1. **Considerare i vincoli di capacità** per l'utilizzo di nuovi tipi di worker in flussi di lavoro urgenti
### Ottimizzazione delle prestazioni
+ CloudWatch Monitora le metriche per comprendere l'utilizzo delle risorse
+ Utilizzare il numero di worker appropriato in base alla dimensione e alla complessità dei dati
+ Considerare le strategie di partizionamento dei dati per ottimizzare l'efficienza dei worker
# Aggiunta di processi di streaming ETL in AWS Glue
È possibile creare operazioni in streaming di estrazione, trasformazione e caricamento (ETL) che vengono eseguite continuamente, consumano dati da origini di streaming come Amazon Kinesis Data Streams, Apache Kafka e Amazon Streaming gestito per Apache Kafka (Amazon MSK). I processi puliscono e trasformano i dati, quindi caricano i risultati in data lake Amazon S3 o datastore JDBC.
Inoltre, è possibile produrre dati per i flussi di dati Amazon Kinesis. Questa funzionalità è disponibile solo per la scrittura di AWS Glue script. Per ulteriori informazioni, consulta [Connessioni Kinesis](aws-glue-programming-etl-connect-kinesis-home.md).
Per impostazione predefinita, AWS Glue elabora e scrive i dati in finestre di 100 secondi. Ciò consente di elaborare i dati in modo efficiente e di eseguire aggregazioni su dati che arrivano più tardi del previsto. È possibile modificare questa dimensione della finestra per aumentare la tempestività o la precisione dell'aggregazione. AWS Glue I processi di streaming utilizzano i checkpoint anziché i segnalibri di lavoro per tenere traccia dei dati letti.
**Nota**
AWS Glue fatture orarie per lo streaming delle operazioni ETL mentre sono in esecuzione.
Questo video illustra le problematiche relative ai costi dello streaming ETL e le funzionalità di riduzione dei costi di. AWS Glue
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/6ggTFOtfUxU)
La creazione di un processo di streaming ETL prevede i seguenti passaggi:
1. Per un'origine di streaming Apache Kafka, creare una connessione AWS Glue alla sorgente Kafka o al cluster Amazon MSK.
1. Creare manualmente un catalogo dati per l'origine di streaming.
1. Creare un processo ETL per l'origine dati di streaming. Definire le proprietà del processo specifiche dello streaming e fornire uno script personalizzato o, facoltativamente, modificare lo script generato.
Per ulteriori informazioni, consulta [Streaming di ETL in AWS Glue](components-overview.md#streaming-etl-intro).
Quando si crea un processo ETL di streaming per Amazon Kinesis Data Streams, non è necessario creare una connessione AWS Glue. Tuttavia, se è presente una connessione collegata al flusso di lavoro ETL AWS Glue con Kinesis Data Streams come origine, quindi è necessario un endpoint cloud privato virtuale (VPC) a Kinesis. Per ulteriori informazioni, consultare [Creazione di un endpoint di interfaccia](https://docs.aws.amazon.com/vpc/latest/userguide/vpce-interface.html#create-interface-endpoint) nella *Guida per l’utente di Amazon VPC*. Quando si specifica un flusso Amazon Kinesis Data Streams in un altro account, è necessario impostare i ruoli e le politiche per consentire l'accesso multi-account. Per ulteriori informazioni, consulta [ Esempio: lettura da un flusso Kinesis in un account diverso](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html).
I processi ETL in streaming di AWS Glue possono rilevare automaticamente i dati compressi, decomprimere in modo trasparente i dati in streaming, eseguire le consuete trasformazioni sulla sorgente di ingresso e caricare nell'archivio di output.
AWS Glue supporta la decompressione automatica per i seguenti tipi di compressione, dato il formato di input:
| Tipo di compressione | File Avro | Dato Avro | JSON | CSV | Grok |
| --- | --- | --- | --- | --- | --- |
| BZIP2 | Sì | Sì | Sì | Sì | Sì |
| GZIP | No | Sì | Sì | Sì | Sì |
| SNAPPY | Sì (Snappy raw) | Sì (Snappy framed) | Sì (Snappy framed) | Sì (Snappy framed) | Sì (Snappy framed) |
| XZ | Sì | Sì | Sì | Sì | Sì |
| ZSTD | Sì | No | No | No | No |
| DEFLATE | Sì | Sì | Sì | Sì | Sì |
**Topics**
+ [Creazione di una connessione AWS Glue per un flusso di dati Apache Kafka](#create-conn-streaming)
+ [Creazione di un catalogo dati per un'origine di streaming](#create-table-streaming)
+ [Note e restrizioni per le origini di streaming Avro](#streaming-avro-notes)
+ [Applicazione di pattern Grok alle origini di streaming](#create-table-streaming-grok)
+ [Definizione delle proprietà di processo per un processo di streaming ETL](#create-job-streaming-properties)
+ [Streaming di note e restrizioni ETL](#create-job-streaming-restrictions)
## Creazione di una connessione AWS Glue per un flusso di dati Apache Kafka
Per leggere da un flusso Apache Kafka, è necessario creare una connessione AWS Glue.
**Come creare una connessione AWS Glue per un'origine Kafka (Console)**
1. Apri la console all'indirizzo. AWS Glue [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)
1. Nel riquadro di navigazione, in **Data catalog** (Catalogo dati), seleziona **Connections** (Connessioni).
1. Scegliere **Aggiungi connessione** e, nella pagina **Imposta proprietà della connessione**, immettere un nome per la connessione.
**Nota**
Per ulteriori informazioni sulla specifica delle proprietà della connessione, consulta [Proprietà della connessione di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-catalog-connections).
1. Per **Tipo di connessione**, scegli **Kafka**.
1. Per i **server bootstrap Kafka URLs**, inserisci l'host e il numero di porta per i broker di bootstrap per il tuo cluster Amazon MSK o il cluster Apache Kafka. Utilizza solo endpoint Transport Layer Security (TLS) per stabilire la connessione iniziale al cluster Kafka. Gli endpoint in testo normale non sono supportati.
Di seguito è riportato un elenco di esempio di coppie di nomi di host e numeri di porta per un cluster Amazon MSK.
```
myserver1.kafka.us-east-1.amazonaws.com:9094,myserver2.kafka.us-east-1.amazonaws.com:9094,
myserver3.kafka.us-east-1.amazonaws.com:9094
```
Per ulteriori informazioni su come ottenere le informazioni del broker bootstrap, consulta [Ottenere i broker bootstrap per un cluster Amazon MSK](https://docs.aws.amazon.com/msk/latest/developerguide/msk-get-bootstrap-brokers.html) in *Amazon Managed Streaming for Apache Kafka: Guida per gli sviluppatori*.
1. Se si desidera una connessione sicura all'origine dati Kafka, seleziona **Require SSL connection (Connessione SSL necessaria)**, e per **Kafka private CA certificate location (Posizione del certificato emesso da una CA Kafka privata)**, inserisci un percorso Amazon S3 valido per un certificato SSL personalizzato.
Per una connessione SSL a Kafka autogestito, il certificato personalizzato è obbligatorio. P Amazon MSK è facoltativo.
Per ulteriori informazioni su come specificare un certificato personalizzato per Kafka, consulta [AWS Glue proprietà della connessione SSL](connection-properties.md#connection-properties-SSL).
1. Usa AWS Glue Studio o la AWS CLI per specificare un metodo di autenticazione del client Kafka. Per accedere, AWS Glue Studio seleziona **AWS Glue**dal menu **ETL** nel riquadro di navigazione a sinistra.
Per ulteriori informazioni sui metodi di autenticazione client Kafka, consulta [AWS Glue Proprietà di connessione Kafka per l'autenticazione client](#connection-properties-kafka-client-auth).
1. Opzionalmente, inserisci una descrizione, quindi scegli **Next (Successivo)**.
1. Per un cluster Amazon MSK, specifica il cloud privato virtuale (VPC), la sottorete e il gruppo di sicurezza. Le informazioni VPC sono opzionali per Kafka autogestito.
1. Scegli **Next (Successivo)** per esaminare tutte le proprietà della connessione, quindi scegli **Finish (Termina)**.
Per ulteriori informazioni sulle connessioni AWS Glue, consulta [Connessione ai dati](glue-connections.md).
### AWS Glue Proprietà di connessione Kafka per l'autenticazione client
**Autenticazione SASL/GSSAPI (Kerberos)**
La scelta di questo metodo di autenticazione consentirà di specificare le proprietà Kerberos.
**Keytab Kerberos**
Scegliere la posizione del file keytab. Un keytab memorizza le chiavi a lungo termine per uno o più principali. Per ulteriori informazioni, consulta la [Documentazione di MIT Kerberos: keytab](https://web.mit.edu/kerberos/krb5-latest/doc/basic/keytab_def.html).
**File Kerberos krb5.conf**
Scegliere il file krb5.conf. Contiene l'area di autenticazione predefinita (una rete logica, simile a un dominio, che definisce un gruppo di sistemi sotto lo stesso KDC) e la posizione del server KDC. Per ulteriori informazioni, consulta la [Documentazione di MIT Kerberos: krb5.conf](https://web.mit.edu/kerberos/krb5-1.12/doc/admin/conf_files/krb5_conf.html).
**Principale Kerberos e nome del servizio Kerberos**
Immettere il nome del principale e il nome del servizio Kerberos. Per ulteriori informazioni, consulta [Documentazione MIT Kerberos: principale Kerberos](https://web.mit.edu/kerberos/krb5-1.5/krb5-1.5.4/doc/krb5-user/What-is-a-Kerberos-Principal_003f.html).
**Autenticazione SASL/SCRAM-SHA-512**
Scegliere questo metodo di autenticazione consentirà di specificare le credenziali di autenticazione.
**AWS Secrets Manager**
Cercare il token nella casella Cerca digitando il nome o l'ARN.
**Nome utente e password del provider direttamente**
Cercare il token nella casella Cerca digitando il nome o l'ARN.
**Autenticazione client SSL**
Scegliere questo metodo di autenticazione consente di selezionare la posizione del keystore client Kafka navigando su Amazon S3. Facoltativamente, puoi inserire la password del keystore del client Kafka e la password della chiave del client Kafka.
**Autenticazione IAM**
Questo metodo di autenticazione non richiede specifiche aggiuntive ed è applicabile solo quando la sorgente di streaming è MSK Kafka.
**Autenticazione SASL/PLAIN**
Scegliere questo metodo di autenticazione consente di specificare le credenziali di autenticazione.
## Creazione di un catalogo dati per un'origine di streaming
Una tabella del catalogo dati che specifica le proprietà del flusso dei dati di origine, incluso lo schema dei dati, può essere creata manualmente per una sorgente di streaming. Questa tabella viene utilizzata come origine dati per il processo di streaming ETL.
Se non si conosce lo schema dei dati nel flusso dei dati di origine, è possibile creare la tabella senza uno schema. Quindi, quando si crea il processo ETL di streaming, è possibile attivare la AWS Gluefunzione di rilevamento dello schema. AWS Glue determina lo schema dai dati di streaming.
Usa la [AWS Glueconsole](https://console.aws.amazon.com/glue/), il AWS Command Line Interface (AWS CLI) o l'API per creare la AWS Glue tabella. Per informazioni sulla creazione manuale di una tabella con la console AWS Glue, vedere [Creazione di tabelle](tables-described.md).
**Nota**
Non puoi usare la AWS Lake Formation console per creare la tabella; devi usare la AWS Glue console.
Considera inoltre le seguenti informazioni per le origini di streaming in formato Avro o per i dati di log a cui è possibile applicare i pattern Grok.
+ [Note e restrizioni per le origini di streaming Avro](#streaming-avro-notes)
+ [Applicazione di pattern Grok alle origini di streaming](#create-table-streaming-grok)
**Topics**
+ [Origine dati Kinesis](#kinesis-source)
+ [Origine dati Kafka](#kafka-source)
+ [Origine della tabella di AWS Glue Schema Registry](#schema-registry-table)
### Origine dati Kinesis
Durante la creazione della tabella, impostare le seguenti proprietà di streaming ETL (console).
**Tipo di origine**
**Kinesis**
**Per una fonte Kinesis nello stesso account:**
**Region**
La AWS regione in cui risiede il servizio Amazon Kinesis Data Streams. Il nome della regione e del flusso Kinesis sono tradotti insieme in un flusso ARN.
Esempio: https://kinesis.us-east-1.amazonaws.com
**Nome del flusso Kinesis**
Nome del flusso come descritto in [Creazione di un flusso](https://docs.aws.amazon.com/streams/latest/dev/kinesis-using-sdk-java-create-stream.html) nella *Guida per gli sviluppatori Amazon Kinesis Data Streams*.
**Per un'origine Kinesis in un altro account, fai riferimento a [questo esempio](https://docs.aws.amazon.com/kinesisanalytics/latest/java/examples-cross.html) per configurare i ruoli e i criteri per consentire l'accesso a più account. Configura queste impostazioni:**
**Flusso ARN**
L'ARN del flusso dei dati Kinesis con il quale il consumatore è registrato. Per ulteriori informazioni, consulta [Amazon Resource Names (ARNs) e AWS Service Namespaces](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) nel. *Riferimenti generali di AWS*
**ARN del ruolo assunto**
L'Amazon Resource Name (ARN) del ruolo assegnato al ruolo da assumere.
**Nome sessione (facoltativo)**
Un identificatore della sessione del ruolo assunto.
Utilizza il nome della sessione del ruolo per identificare in modo univoco una sessione quando lo stesso ruolo viene assunto da diverse entità principali o per motivi diversi. In scenari multi-account, l'account proprietario del ruolo può vedere il nome della sessione del ruolo e può registrarlo. Il nome della sessione del ruolo viene utilizzato anche nell'ARN dell'entità ruolo assunto. Ciò significa che le successive richieste API tra più account che utilizzano le credenziali di sicurezza temporanee esporranno il nome della sessione del ruolo all'account esterno nei relativi log. AWS CloudTrail
**Per impostare le proprietà di streaming ETL per Amazon Kinesis Data Streams (API AWS Glue o AWS CLI)**
+ Per impostare le proprietà di streaming ETL per un'origine Kinesis nello stesso account, specifica i parametri `streamName` e `endpointUrl` nella struttura `StorageDescriptor` dell'operazione API `CreateTable` o del comando CLI `create_table`.
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamName": "sample-stream",
"endpointUrl": "https://kinesis.us-east-1.amazonaws.com"
}
...
}
```
In alternativa, specifica il `streamARN`.
**Example**
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream"
}
...
}
```
+ Per impostare le proprietà di streaming ETL per un'origine Kinesis nello stesso account, specifica i parametri `streamARN`, `awsSTSRoleARN` e `awsSTSSessionName` (facoltativo) nella struttura `StorageDescriptor` dell'operazione API `CreateTable` o del comando CLI `create_table`.
```
"StorageDescriptor": {
"Parameters": {
"typeOfData": "kinesis",
"streamARN": "arn:aws:kinesis:us-east-1:123456789:stream/sample-stream",
"awsSTSRoleARN": "arn:aws:iam::123456789:role/sample-assume-role-arn",
"awsSTSSessionName": "optional-session"
}
...
}
```
### Origine dati Kafka
Durante la creazione della tabella, impostare le seguenti proprietà di streaming ETL (console).
**Tipo di origine**
**Kafka**
**Per una fonte Kafka:**
**Nome dell'argomento**
Nome argomento specificato in Kafka.
**Connessione**
Connessione AWS Glue che fa riferimento a un'origine Kafka, come descritto in [Creazione di una connessione AWS Glue per un flusso di dati Apache Kafka](#create-conn-streaming).
### Origine della tabella di AWS Glue Schema Registry
Per utilizzare AWS Glue Schema Registry per i processi di streaming, segui le istruzioni all'indirizzo [Caso d'uso: AWS Glue Data Catalog](schema-registry-integrations.md#schema-registry-integrations-aws-glue-data-catalog) su come creare o aggiornare una tabella Schema Registry.
Attualmente, lo streaming AWS Glue supporta solo il formato Glue Schema Registry Avro con inferenza dello schema impostata su `false`.
## Note e restrizioni per le origini di streaming Avro
Le seguenti note e restrizioni si applicano alle origini di streaming nel formato Avro:
+ Quando il rilevamento dello schema è attivato, lo schema Avro deve essere incluso nel payload. Quando disattivato, il payload deve contenere solo dati.
+ Alcuni tipi di dati Avro non sono supportati nei frame dinamici. Non è possibile specificare questi tipi di dati quando si definisce lo schema con la pagina **Define a schema (Definire uno schema)** nella procedura guidata per la creazione della tabella nella console AWS Glue. Durante il rilevamento dello schema, i tipi non supportati nello schema Avro vengono convertiti in tipi supportati come segue:
+ `EnumType => StringType`
+ `FixedType => BinaryType`
+ `UnionType => StructType`
+ Se si definisce lo schema della tabella utilizzando la pagina **Define a schema (Definire uno schema)** nella console, il tipo di elemento root implicito per lo schema è `record`. Se si desidera un tipo di elemento root diverso da `record`, ad esempio `array` o `map`, non è possibile specificare lo schema utilizzando la pagina **Define a schema (Definire uno schema)**. È invece necessario saltare quella pagina e specificare lo schema come proprietà di tabella o all'interno dello script ETL.
+ Per specificare lo schema nelle proprietà della tabella, completa la procedura guidata per la creazione della tabella, modifica i dettagli della tabella e aggiungi una nuova coppia chiave-valore in **Table properties (Proprietà della tabella)**. Utilizza la chiave `avroSchema`, e inserisci un oggetto JSON dello schema per il valore, come mostrato nello screenshot seguente.
![\[Sotto l'intestazione Table properties (Proprietà tabella), sono presenti due colonne di campi di testo. L'intestazione della colonna a sinistra è Key (Chiave) e l'intestazione della colonna di destra è Value (Valore). La key/value coppia nella prima riga è una classification/avro. The key/value coppia, nella seconda riga è AvroSchema/ {"type» :"array», "items» :"string "}.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/table_properties_avro.png)
+ Per specificare lo schema nello script ETL, modifica l'istruzione di assegnazione `datasource0` e aggiungi la chiave `avroSchema` all'argomento `additional_options`, come mostrato nei seguenti esempi Python e Scala.
------
#### [ Python ]
```
SCHEMA_STRING = ‘{"type":"array","items":"string"}’
datasource0 = glueContext.create_data_frame.from_catalog(database = "database", table_name = "table_name", transformation_ctx = "datasource0", additional_options = {"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema": SCHEMA_STRING})
```
------
#### [ Scala ]
```
val SCHEMA_STRING = """{"type":"array","items":"string"}"""
val datasource0 = glueContext.getCatalogSource(database = "database", tableName = "table_name", redshiftTmpDir = "", transformationContext = "datasource0", additionalOptions = JsonOptions(s"""{"startingPosition": "TRIM_HORIZON", "inferSchema": "false", "avroSchema":"$SCHEMA_STRING"}""")).getDataFrame()
```
------
## Applicazione di pattern Grok alle origini di streaming
È possibile creare un processo di streaming ETL per un'origine dati dei log e utilizzare i pattern Grok per convertire i registri in dati strutturati. Il processo ETL elabora quindi i dati come origine dati strutturata. È possibile specificare i pattern Grok da applicare quando si crea la tabella Catalogo dati per l'origine di streaming.
Per informazioni sui pattern Grok e sui valori delle stringhe di pattern personalizzati, consulta [Scrittura di classificatori personalizzati grok](custom-classifier.md#custom-classifier-grok).
**Aggiungere pattern Grok alla tabella Catalogo dati (console)**
+ Utilizza la procedura guidata per la creazione della tabella e crea la tabella con i parametri specificati in [Creazione di un catalogo dati per un'origine di streaming](#create-table-streaming). Specifica il formato dei dati come Grok, compila il **pattern Grok** e, facoltativamente, aggiungi pattern personalizzati in **Custom patterns (optional) (Modelli personalizzati [facoltativo])**.
![\[*\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/grok-data-format-create-table.png)
Premi **Invio** dopo ogni pattern personalizzato.
**Per aggiungere modelli grok alla tabella Data Catalog (API o) AWS Glue AWS CLI**
+ Aggiungi il parametro `GrokPattern` e, facoltativamente, il parametro `CustomPatterns` al processo API `CreateTable` o al comando CLI `create_table`.
```
"Parameters": {
...
"grokPattern": "string",
"grokCustomPatterns": "string",
...
},
```
Esprimi `grokCustomPatterns` come stringa e usa "\$1n" come separatore tra i pattern.
Di seguito è riportato un esempio di specifica di questi parametri.
**Example**
```
"parameters": {
...
"grokPattern": "%{USERNAME:username} %{DIGIT:digit:int}",
"grokCustomPatterns": "digit \d",
...
}
```
## Definizione delle proprietà di processo per un processo di streaming ETL
Quando definisci un processo di streaming ETL nella console AWS Glue, fornisci le seguenti proprietà specifiche dei flussi. Per le descrizioni di proprietà aggiuntive, consulta [Definire le proprietà di processo per i processi Spark](add-job.md#create-job).
**Ruolo IAM**
Specificate il ruolo AWS Identity and Access Management (IAM) utilizzato per l'autorizzazione alle risorse utilizzate per eseguire il processo, accedere alle sorgenti di streaming e accedere agli archivi dati di destinazione.
Per accedere ad Amazon Kinesis Data Streams, `AmazonKinesisFullAccess` AWS collega la policy gestita al ruolo o allega una policy IAM simile che consenta un accesso più dettagliato. Per i criteri di esempio, consulta [Controllo dell'accesso alle risorse Amazon Kinesis Data Streams tramite IAM](https://docs.aws.amazon.com/streams/latest/dev/controlling-access.html).
Per ulteriori informazioni sulle autorizzazioni per l'esecuzione di processi in AWS Glue, consulta [Gestione delle identità e degli accessi per AWS Glue](security-iam.md).
**Tipo**
Scegli **Spark streaming**.
**Versione AWS Glue**
La versione di AWS Glue determina le versioni di Apache Spark e Python che sono disponibili per il processo. Scegli una selezione che specifica la versione di Python o Scala disponibile per il processo. AWS Glue La versione 2.0 con supporto Python 3 è la versione predefinita per lo streaming delle operazioni ETL.
**Finestra di manutenzione**
Specifica una finestra in cui è possibile riavviare un processo di streaming. Per informazioni, consulta [Finestre di manutenzione per AWS Glue lo streaming](glue-streaming-maintenance.md).
**Timeout dei processi**
È possibile inserire una durata in minuti. Il valore predefinito è vuoto.
+ I processi di streaming devono avere un valore di timeout inferiore a 7 giorni o 10.080 minuti.
+ Se il valore viene lasciato vuoto, il processo verrà riavviato dopo 7 giorni, se non è stata impostata una finestra di manutenzione. Se è stata impostata una finestra di manutenzione, il processo verrà riavviato durante la finestra di manutenzione dopo 7 giorni.
**Origine dati**
Rimuovi la tabella creata in [Creazione di un catalogo dati per un'origine di streaming](#create-table-streaming).
**Destinazione dati**
Esegui una delle seguenti operazioni:
+ Scegliere **Crea tabelle nell'oggetto dati** e specificare le seguenti proprietà dell'oggetto dati.
**Datastore**
Seleziona Amazon S3 o JDBC.
**Formato**
Scegli un formato qualsiasi. Tutti sono supportati per lo streaming.
+ Scegli **Use tables in the data catalog and update your data target (Usa tabelle nel catalogo dati e aggiorna la destinazione dati)** e scegli una tabella per un data store JDBC.
**Definizione dello schema di output**
Esegui una delle seguenti operazioni:
+ Scegli **Automatically detect schema of each record (Rileva automaticamente lo schema di ciascun record)** per attivare il rilevamento dello schema. AWS Gluedetermina lo schema dai dati di streaming.
+ Scegli **Specify output schema for all records (Specificare lo schema di output per tutti i record)** per utilizzare la trasformazione Apply Mapping (Applica mapping) per definire lo schema di output.
**Script**
È possibile fornire uno script personalizzato o modificare lo script generato per eseguire le operazioni supportate dal motore di Apache Spark Structured Streaming. [Per informazioni sulle operazioni disponibili, consulta Operations on streaming/Datasets. DataFrames](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets)
## Streaming di note e restrizioni ETL
Tieni presente le seguenti note e restrizioni:
+ La decompressione automatica per i processi ETL in streaming di AWS Glue è disponibile solo per i tipi di compressione supportati. Tieni presente quanto segue:
+ Snappy framed si riferisce al [formato di framing](https://github.com/google/snappy/blob/main/framing_format.txt) ufficiale di Snappy.
+ Deflate è supportato in Glue versione 3.0, non Glue versione 2.0.
+ Quando si utilizza il rilevamento dello schema, non è possibile eseguire join dei dati di streaming.
+ I processi ETL di streaming di AWS Glue non supportano il tipo di dati Union per il registro degli schemi AWS Glue con il formato Avro.
+ Lo script ETL può utilizzare le trasformazioni integrate di AWS Glue e le trasformazioni native di Apache Spark Structured Streaming. Per ulteriori informazioni, consulta [Operazioni sullo streaming DataFrames /Datasets sul](https://spark.apache.org/docs/latest/structured-streaming-programming-guide.html#operations-on-streaming-dataframesdatasets) sito Web di Apache Spark oppure. [AWS Glue PySpark trasforma il riferimento](aws-glue-programming-python-transforms.md)
+ Le operazioni ETL di streaming AWS Glue utilizzano i checkpoint per tenere traccia dei dati letti. Pertanto, un processo arrestato e riavviato riprende da dove era stato interrotto nello stream. Se si desidera rielaborare i dati, è possibile eliminare la cartella di checkpoint a cui si fa riferimento nello script.
+ I segnalibri delle operazioni non sono supportati.
+ Per utilizzare la funzionalità di fan-out avanzato di Flusso di dati Kinesis, consulta la pagina [Utilizzo del fan-out avanzato nei processi di flussi di dati Kinesis](aws-glue-programming-etl-connect-kinesis-efo.md).
+ Se si utilizza una tabella di catalogo dati creata da AWS Glue Schema Registry, quando diventa disponibile una nuova versione dello schema, per rifletterlo, è necessario effettuare le seguenti operazioni:
1. Arrestare i processi associati alla tabella.
1. Aggiornare lo schema per la tabella catalogo dati.
1. Riavviare i processi associati alla tabella.
# Record di abbinamento con AWS Lake Formation FindMatches
**Nota**
La corrispondenza dei record non è attualmente disponibile nelle seguenti regioni della AWS Glue console: Medio Oriente (Emirati Arabi Uniti), Europa (Spagna), Asia Pacifico (Giacarta) ed Europa (Zurigo).
AWS Lake Formation offre funzionalità di apprendimento automatico per creare trasformazioni personalizzate per ripulire i dati. Attualmente è disponibile una trasformazione denominata. FindMatches La FindMatches trasformazione consente di identificare i record duplicati o corrispondenti nel set di dati, anche quando i record non hanno un identificatore univoco comune e nessun campo corrisponde esattamente. Ciò non richiederà la scrittura di alcun codice o la conoscenza di come funziona l'apprendimento automatico. FindMatches può essere utile in molti problemi diversi, come ad esempio:
+ **Matching Customers (Corrispondenza di clienti)**: collegamento di record dei clienti tra diversi database, anche quando molti campi non corrispondono esattamente tra i database (ad es. diversa ortografia dei nomi, differenze di indirizzo, dati mancanti o imprecisi e così via).
+ **Matching Products (Corrispondenza di prodotti)**: abbinamento dei prodotti nel catalogo rispetto ad altre origini, ad esempio catalogo di prodotti rispetto al catalogo di un concorrente, in cui le voci sono strutturate in modo diverso.
+ **Improving Fraud Detection (Miglioramento del rilevamento delle frodi)**: identificazione di account dei clienti duplicati, determinazione di quando un nuovo account creato è (o potrebbe essere) una corrispondenza per un utente fraudolento noto.
+ **Other Matching Problems (Altri problemi di corrispondenza)**: abbinare indirizzi, film, elenchi di parti e così via. In generale, se un essere umano potesse esaminare le righe del database e determinare che coincidono, ci sono ottime probabilità che la FindMatches trasformazione possa aiutarvi.
È possibile creare queste trasformazioni al momento della creazione di un processo. La trasformazione creata si basa su uno schema del datastore di origine e su dati di esempio del set di dati di origine etichettato (questo processo viene denominato "insegnamento" di una trasformazione). I record etichettati devono essere presenti nel set di dati di origine. In questo processo viene generato un file etichettato e quindi ricaricato nel modo appreso dalla trasformazione. Dopo aver insegnato la trasformazione, puoi richiamarla dal tuo AWS Glue job basato su Spark (PySpark o Scala Spark) e usarla in altri script con un data store di origine compatibile.
Dopo la creazione della trasformazione, questa viene memorizzata all'interno di AWS Glue. Nella console di AWS Glue è possibile gestire le trasformazioni create. Nel riquadro di navigazione in **Integrazione dei dati ed ETL**, **Strumenti di classificazione dei dati > Corrispondenza dei record**, puoi modificare e continuare a istruire la trasformazione del machine learning. Per ulteriori informazioni sulla gestione delle trasformazioni nella console, consultare [Operare con le trasformazioni basate su machine learning](console-machine-learning-transforms.md).
**Nota**
AWS Gluei FindMatches lavori della versione 2.0 utilizzano il bucket Amazon S3 `aws-glue-temp--` per archiviare file temporanei mentre la trasformazione elabora i dati. Puoi eliminare questi dati dopo aver completato l'esecuzione, manualmente o impostando una regola del ciclo di vita di Amazon S3.
## Tipi di trasformazioni basate su machine learning
È possibile creare trasformazioni di machine learning per pulire i dati. Puoi chiamare queste trasformazioni dallo script ETL. I tuoi dati passano da una trasformazione all'altra in una struttura di dati chiamata a *DynamicFrame*, che è un'estensione di Apache Spark SQL. `DataFrame` `DynamicFrame` contiene i tuoi dati e il suo schema di riferimento per elaborare i dati.
Sono disponibili i seguenti tipi di trasformazioni basate su machine learning:
*Rilevamento delle corrispondenze*
Individua i record duplicati nei dati di origine. È possibile addestrare questa trasformazione basata su machine learning etichettando dei set di dati di esempio e indicando tra quali righe sono presenti delle corrispondenze. La trasformazione basata su machine learning apprende quali righe debbano essere abbinate man mano che vengono offerti dati di esempio etichettati. A seconda della configurazione della trasformazione, l'output è uno dei seguenti:
+ Una copia della tabella di input con una colonna `match_id` aggiuntiva compilata con i valori che indicano insiemi di record corrispondenti. La colonna `match_id` è un identificatore arbitrario. Tutti i record con lo stesso `match_id` sono stati identificati come tra loro corrispondenti. I record con `match_id` diversi non corrispondono.
+ Una copia della tabella di input con le righe duplicate rimosse. Se vengono rilevati molteplici duplicati, viene mantenuto il record con la chiave primaria minore.
*Trova corrispondenze incrementali*
La trasformazione Find matches può anche essere configurata per trovare le corrispondenze tra i frame esistenti e incrementali e restituire come output una colonna contenente un ID univoco per gruppo di corrispondenza.
Per ulteriori informazioni, consulta: [Trovare corrispondenze incrementali](machine-learning-incremental-matches.md)
### Utilizzo della FindMatches trasformazione
È possibile utilizzare la trasformazione `FindMatches` per individuare i record duplicati nei dati di origine. Viene generato o fornito un file di etichettatura che possa aiutare nell'addestramento della trasformazione.
**Nota**
Attualmente, le trasformazioni `FindMatches` che usano una chiave di crittografia personalizzata non sono supportate nelle seguenti Regioni:
Asia Pacifico (Osaka): `ap-northeast-3`
Per iniziare con la FindMatches trasformazione, puoi seguire i passaggi seguenti. Per un esempio più avanzato e dettagliato, consulta il **blog AWS Big Data**: [Harmonize data using AWS Glue and AWS Lake Formation FindMatches ML to build a customer 360](https://aws.amazon.com/blogs/big-data/harmonize-data-using-aws-glue-and-aws-lake-formation-findmatches-ml-to-build-a-customer-360-view/).
#### Nozioni di base sull'utilizzo della trasformazione con rilevamento delle corrispondenze
Seguire questi passaggi per iniziare a usare la trasformazione `FindMatches`:
1. Crea una tabella AWS Glue Data Catalog per i dati di origine da pulire. Per informazioni su come creare un crawler, consultare [Uso di crawler nella console AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/console-crawlers.html).
Se i dati di origine sono contenuti in un file di testo, ad esempio un file di valori separati da virgola (CSV), tenere conto delle seguenti considerazioni:
+ Mantenere il file CSV contenente i record di input e i file di etichettatura in cartelle separate. In caso contrario, il crawler di AWS Glue potrebbe considerarli come più componenti della stessa tabella e creare tabelle nel catalogo dati in modo non corretto.
+ A meno che il file CSV includa solo caratteri ASCII, assicurarsi che per la codifica dei file CSV venga utilizzato UTF-8 senza BOM (Byte Order Mark). Microsoft Excel spesso aggiunge un BOM all'inizio dei file CSV UTF-8. Per rimuoverlo, aprire il file CSV con un editor di testo e salvare nuovamente il file in formato **UTF-8 senza BOM**.
1. Nella console di AWS Glue, creare un processo e scegliere il tipo di trasformazione **Find matches (Rilevamento delle corrispondenze)**
**Importante**
La tabella dell'origine dati selezionata per il processo può contenere fino a un massimo di 100 colonne.
1. Indica a AWS Glue di generare un file di etichettatura scegliendo **Generate labeling file (Genera file di etichettatura)**. AWS Glue utilizza il primo passaggio per raggruppare record simili per ciascun `labeling_set_id` in modo da poter rivedere tali raggruppamenti. Etichetta corrispondenze nella colonna `label`.
+ Se già disponi di un file di etichettatura, ossia di un esempio di record che indicano righe corrispondenti, carica il file su Amazon Simple Storage Service (Amazon S3). Per informazioni sul formato del file di etichettatura, consultare [Formato del file di etichettatura](#machine-learning-labeling-file). Continuare con la fase 4.
1. Scaricare il file di etichettatura ed etichettare il file come descritto nella sezione [Etichettatura](#machine-learning-labeling).
1. Caricare il file di etichettatura corretto. AWS Glue esegue delle attività per addestrare la trasformazione al riconoscimento delle corrispondenze.
Nella pagina di elenco delle **Machine learning transforms (Trasformazioni basate su machine learning)**, scegliere la scheda **History (Cronologia)**. Questa pagina indica quando AWS Glue esegue le seguenti attività:
+ **Import labels (Importa le etichette)**
+ **Export labels (Esporta le etichette)**
+ **Generate labels (Genera le etichette)**
+ **Estimate quality (Valuta la qualità)**
1. Per creare una migliore trasformazione, è possibile scaricare, etichettare e caricare il file etichettato in modo iterativo. Nell'esecuzione iniziale, molti record potrebbero essere rilevati come non corrispondenti. Ma man mano che prosegue l'addestramento tramite la verifica del file di etichettatura, AWS Glue avanza nell'apprendimento.
1. Valutare e ottimizzare la trasformazione tramite la valutazione delle prestazioni e dei risultati della ricerca delle corrispondenze. Per ulteriori informazioni, consulta [Ottimizzazione delle trasformazioni basate su machine learning in AWS Glue](add-job-machine-learning-transform-tuning.md).
#### Etichettatura
Quando `FindMatches` genera un file di etichettatura, i record vengono selezionati dalla tabella di origine. Sulla base del training precedente, `FindMatches` identifica i record più importanti da cui apprendere.
L'atto di *etichettatura* consiste nella modifica di un file di etichettatura (ad esempio, un foglio di calcolo come Microsoft Excel) e l'aggiunta di identificatori, o etichette, nella colonna `label` che identifica i record con o senza corrispondenze. È importante avere una chiara e coerente definizione di corrispondenza nei dati di origine. `FindMatches` apprende sulla base dei record designati come corrispondenti (o meno) e utilizza le decisioni dell'utente per ricavare le informazioni necessarie all'individuazione dei record duplicati.
Quando il file di etichettatura viene generato da `FindMatches`, vengono generati circa 100 record. Questi 100 record sono in genere suddivisi in 10 *set di etichettatura*, dove ogni set di etichettatura è identificato da un unico `labeling_set_id` generato da `FindMatches`. Ogni set di etichettatura deve essere considerato come un'attività di etichettatura separata indipendente dagli altri set di etichettatura. Il tuo compito consiste nell'identificare i record corrispondenti e non corrispondenti all'interno di ciascun set di etichette.
##### Suggerimenti per la modifica dei file di etichettatura in un foglio di calcolo.
Quando si modifica il file di etichettatura in un foglio di calcolo, considerare i seguenti aspetti:
+ Il file potrebbe non aprirsi con le colonne dei campi completamente espanse. Per visualizzare i contenuti di tali celle, potrebbe essere necessario espandere le colonne `labeling_set_id` e `label`.
+ Se la colonna chiave primaria è un numero, ad esempio un tipo di dato `long`, il foglio di calcolo potrebbe interpretarlo come un numero e modificarne il valore. Questo valore chiave deve essere trattato come un testo. Per risolvere il problema, formattare tutte le celle nella colonna chiave primaria come **Text data (Formato testo)**.
#### Formato del file di etichettatura
Il file di etichettatura generato da AWS Glue per insegnare la trasformazione `FindMatches` utilizza il seguente formato. Se si genera il proprio file per AWS Glue, anch'esso deve seguire questo formato:
+ Si tratta di un file di valori separati da virgola (CSV).
+ Deve essere codificato in `UTF-8`. Se il file è stato modificato con Microsoft Windows, potrebbe essere codificato con `cp1252`.
+ Affinché possa essere passato a AWS Glue è necessario che si trovi su Amazon S3.
+ Utilizza un numero modesto di righe per ogni attività di etichettatura. Sono consigliate 10-20 righe per attività, anche se 2-30 righe per attività sono accettabili. Le attività superiori a 50 righe non sono consigliate e potrebbero causare risultati scadenti o errori di sistema.
+ Se si dispone di dati già etichettati costituiti da coppie di record etichettati come "corrispondenza" o "nessuna corrispondenza", questo va bene. Queste coppie etichettate possono essere rappresentate come set di etichettatura di dimensione 2. In questo caso etichettare entrambi i record con, ad esempio, una lettera "A" se corrispondono, ma etichettare uno come "A" e uno come "B" se non corrispondono.
**Nota**
Poiché possiede delle colonne aggiuntive, il file di etichettatura presenta uno schema diverso da quello di un file che contiene i dati di origine. Posizionare il file di etichettatura in una cartella diversa da quella di qualsiasi altro file CSV di input della trasformazione in modo che il crawler di AWS Glue non lo prenda in considerazione al momento della creazione delle tabelle nel catalogo dati. In caso contrario, le tabelle create dal crawler di AWS Glue potrebbero non rappresentare correttamente i dati.
+ Le prime due colonne (`labeling_set_id`, `label`) sono richieste obbligatoriamente da AWS Glue. Le colonne rimanenti devono corrispondere allo schema dei dati che devono essere elaborati.
+ Per ogni `labeling_set_id`, è necessario identificare tutti i record corrispondenti utilizzando la stessa etichetta. Un'etichetta è una stringa univoca posizionata nella colonna `label`. Consigliamo di usare etichette contenenti caratteri semplici, ad esempio A, B, C e così via. Le etichette considerano in modo differente le maiuscole dalle minuscole e vengono inserite nella colonna `label`.
+ Le righe che contengono lo stesso `labeling_set_id` e la stessa etichetta si intendono etichettate come corrispondenza.
+ Le righe che contengono lo stesso `labeling_set_id` e un'etichetta diversa si intendono etichettate come *non* una corrispondenza
+ Le righe che contengono un `labeling_set_id` diverso non trasmettono alcuna informazione a favore o contro la corrispondenza.
Di seguito è riportato un esempio di etichettatura dei dati:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/machine-learning.html)
+ Nell'esempio precedente identifichiamo John/Johnny/Jon Doe as being a match and we teach the system that these records do not match Jane Smith. Separately, we teach the system that Richard and Rich Jones are the same person, but that these records are not a match to Sarah Jones/Jones -Walker e Richie Jones Jr.
+ Come si può vedere, l'ambito delle etichette è limitato al `labeling_set_id`. Quindi le etichette non attraversano i limiti imposti dal `labeling_set_id`. Ad esempio, un'etichetta "A" nel `labeling_set_id` 1 non ha alcuna relazione con l'etichetta "A" nel `labeling_set_id` 2.
+ Se un record non ha alcuna corrispondenza all'interno di un set di etichette, assegnargli un'etichetta univoca. Ad esempio, Jane Smith non corrisponde a nessun record nel set di etichette ABC123, quindi è l'unico disco di quel set di etichette con l'etichetta B.
+ Il set di etichette "GHI678" mostra che un set di etichette può essere composto da soli due record a cui viene assegnata la stessa etichetta per dimostrare che corrispondono. Allo stesso modo, "XYZABC" mostra due record con etichette diverse per mostrare che non corrispondono.
+ Si noti che a volte un set di etichette non può contenere corrispondenze (ovvero, si attribuisce a ogni record nel set di etichette un'etichetta diversa) o un set di etichette potrebbe essere "uguale" (ad essi è stata assegnata la stessa etichetta). Questo va bene fintanto che i set di etichettatura contengono collettivamente esempi di record "uguali" o "non uguali" secondo i propri criteri.
**Importante**
Confermare che il ruolo IAM passato a AWS Glue abbia accesso al bucket Amazon S3 che contiene il file di etichettatura. Per convenzione, le policy di AWS Glue concedono le autorizzazioni sui bucket o sulle cartelle di Amazon S3 i cui nomi contengono il prefisso **aws-glue-**. Se i file di etichettatura si trovano in percorsi diversi, aggiungere al ruolo IAM l'autorizzazione di accesso a tale posizione.
# Ottimizzazione delle trasformazioni basate su machine learning in AWS Glue
È possibile ottimizzare le trasformazioni basate su machine learning in AWS Glue al fine di migliorare i risultati delle operazioni di pulizia dei dati affinché soddisfino gli obiettivi desiderati. Per migliorare la trasformazione, è possibile addestrarla generando un set di dati da etichettare, aggiungendo le etichette e quindi ripetendo questi passaggi diverse volte fino a ottenere i risultati desiderati. È inoltre possibile applicare l'ottimizzazione modificando alcuni parametri del sistema di machine learning.
Per ulteriori informazioni sulle trasformazioni basate su machine learning, consultare [Record di abbinamento con AWS Lake Formation FindMatches](machine-learning.md).
**Topics**
+ [Misurazioni del machine learning](machine-learning-terminology.md)
+ [Scelta tra precisione e recupero](machine-learning-precision-recall-tradeoff.md)
+ [Scelta tra accuratezza e costo](machine-learning-accuracy-cost-tradeoff.md)
+ [Stima della qualità delle corrispondenze utilizzando i punteggi di confidenza delle corrispondenze](match-scoring.md)
+ [Addestramento della trasformazione di rilevamento delle corrispondenze](machine-learning-teaching.md)
# Misurazioni del machine learning
Per comprendere le misurazioni che vengono utilizzate per ottimizzare una trasformazione basata su machine learning, è necessario avere familiarità con la seguente terminologia:
**Vero positivo (True positive, TP)**
Una corrispondenza nei dati correttamente individuata dalla trasformazione, denominata anche *colpo a segno*.
**Vero negativo (True negative , TN)**
Una mancata corrispondenza nei dati correttamente esclusa dalla trasformazione.
**Falso positivo (False positive, FP)**
Una mancata corrispondenza nei dati che la trasformazione ha erroneamente classificato come una corrispondenza, denominata anche *falso allarme*.
**Falso negativo (False negative, FN)**
Una corrispondenza nei dati non rilevata dalla trasformazione, denominata anche *colpo mancato*.
Per ulteriori informazioni sulla terminologia utilizzata nel campo del machine learning, consultare la voce [Matrice di confusione](https://en.wikipedia.org/wiki/Confusion_matrix) su Wikipedia.
Per ottimizzare le trasformazioni basate su machine learning, è possibile modificare il valore delle seguenti misurazioni nella sezione **Advanced properties (Proprietà avanzate)** della trasformazione.
+ **Precision (Precisione)** misura la capacità della trasformazione di individuare veri positivi sul numero totale di record che identifica come positivi (veri positivi e falsi positivi). Per ulteriori informazioni, consulta la voce [Precisione e recupero](https://en.wikipedia.org/wiki/Precision_and_recall) su Wikipedia.
+ **Recall (Recupero)** misura la capacità della trasformazione di individuare i veri positivi rispetto al totale dei record che compongono i dati di origine. Per ulteriori informazioni, consulta la voce [Precisione e recupero](https://en.wikipedia.org/wiki/Precision_and_recall) su Wikipedia.
+ **Accuracy (Accuratezza)** misura la capacità della trasformazione di individuare i veri positivi e i veri negativi. L'incremento dell'accuratezza implica maggiori risorse di elaborazione e costi superiori. Tuttavia permette di raggiungere anche un livello maggiore di recupero. Per ulteriori informazioni, consultare la voce [Accuratezza e precisione](https://en.wikipedia.org/wiki/Accuracy_and_precision#In_information_systems) su Wikipedia.
+ **Cost (Costo)** misura la quantità di risorse di elaborazione (e quindi di denaro) consumate per l'esecuzione della trasformazione.
# Scelta tra precisione e recupero
Ogni trasformazione `FindMatches` contiene un parametro `precision-recall`. È possibile utilizzare questo parametro per specificare uno dei seguenti requisiti:
+ Se la preoccupazione maggiore riguarda la possibilità che la trasformazione indichi la corrispondenza tra due record quando in effetti tale corrispondenza non esiste, allora è opportuno enfatizzare l'aspetto della *precisione*.
+ Se la preoccupazione maggiore riguarda la mancata rilevazione di record tra i quali esiste in effetti una corrispondenza, allora è opportuno enfatizzare l'aspetto del *recupero*.
È possibile regolare questo compromesso all'interno della console di AWS Glue o utilizzando le operazioni API di machine learning di AWS Glue.
**Quando favorire la precisione**
È opportuno favorire la precisione se la preoccupazione maggiore riguarda il rischio che `FindMatches` stabilisca una relazione tra due record quando in effetti tale corrispondenza non esiste. Per favorire la precisione, scegliere un valore *più alto* per il compromesso tra precisione e recupero. Con un valore più alto, la trasformazione `FindMatches` richiede un numero maggiore di elementi a sostegno per stabilire se una coppia di record deve essere è legata da una corrispondenza. Si incrementa la predisposizione della trasformazione a supporre che tra i record non esista una corrispondenza.
Ad esempio, si supponga di utilizzare `FindMatches` per rilevare gli elementi duplicati in un catalogo di video e di assegnare al parametro precisione-recupero della trasformazione un valore elevato. Se la trasformazione rileva erroneamente che *Star Wars: Una nuova speranza* è la stessa cosa di *Star Wars: L'impero colpisce ancora*, a un cliente che desidera *Una nuova speranza* potrebbe essere mostrato *L'impero colpisce ancora*. Si tratterebbe di un'esperienza utente scadente.
Tuttavia, se la trasformazione non riesce a rilevare che *Star Wars: Una nuova speranza* e *Star Wars: Episodio IV - Una nuova speranza* sono lo stesso elemento, il cliente potrebbe essere confuso all'inizio ma potrebbe alla fine riconoscere i due elementi come lo stesso film. Sarebbe un errore, ma non così grave come nel caso precedente.
**Quando favorire il recupero**
È opportuno favorire il recupero se la preoccupazione maggiore riguarda il rischio che i risultati della trasformazione `FindMatches` possano non riuscire a rilevare una coppia di record tra i quali esiste un effetti una corrispondenza. Per favorire il recupero, scegliere un valore *più basso* per il compromesso tra precisione e recupero. Con un valore più basso, la trasformazione `FindMatches` richiede un numero minore di elementi a sostegno per decidere che una coppia di record è legata da una corrispondenza. Si incrementa la predisposizione della trasformazione a supporre che tra i record esista una corrispondenza.
Ad esempio, questa potrebbe essere una priorità per un'azienda che si occupa di sicurezza. Si supponga di confrontare l'elenco dei clienti con uno di noti frodatori e che sia importante determinare se un cliente è un frodatore. Si sta utilizzando `FindMatches` per trovare le corrispondenze tra l'elenco dei frodatori e quello dei clienti. Ogni volta che `FindMatches` rileva una corrispondenza tra i due elenchi, a un revisore umano viene assegnato il compito di verificare che la persona sia, in effetti, un frodatore. L'azienda potrebbe scegliere di favorire il recupero rispetto alla precisione. In altre parole, è preferibile che i verificatori debbano esaminare manualmente e rigettare alcuni casi in cui il cliente non è un frodatore piuttosto che fallire nell'identificazione di un cliente che si trova, in effetti, nell'elenco dei frodatori.
**Come favorire sia la precisione che il recupero**
Il modo migliore per migliorare la precisione e il recupero è etichettare una maggiore quantità di dati. Etichettando una maggiore quantità di dati, migliora la precisione globale della trasformazione `FindMatches`, con conseguenti miglioramenti sia della precisione che del recupero. Tuttavia, anche nel caso della trasformazione più accurata possibile, esiste sempre un'area grigia dove è necessario sperimentare se favorire precisione o recupero oppure scegliere un valore intermedio.
# Scelta tra accuratezza e costo
Ogni trasformazione `FindMatches` contiene un parametro `accuracy-cost`. È possibile utilizzare questo parametro per specificare uno dei seguenti requisiti:
+ Se la preoccupazione maggiore riguarda la possibilità che la trasformazione riveli con precisione la corrispondenza tra due record, allora è opportuno enfatizzare l'aspetto dell'*accuratezza*.
+ Se la preoccupazione maggiore riguarda il costo o la velocità di esecuzione della trasformazione, allora è opportuno enfatizzare l'aspetto della *riduzione del costo*.
È possibile regolare questo compromesso all'interno della console di AWS Glue o utilizzando le operazioni API di machine learning di AWS Glue.
**Quando favorire l'accuratezza**
È opportuno favorire l'accuratezza se la preoccupazione maggiore riguarda il rischio che i risultati della trasformazione `find matches` non includano le corrispondenze. Per favorire l'accuratezza, scegliere un valore *più alto* per il compromesso tra accuratezza e costo. Con un valore più elevato, la trasformazione `FindMatches` richiede più tempo per approfondire la ricerca sui record tra i quali esiste una corrispondenza. Si noti che questo parametro non rende meno probabile la possibilità di indicare erroneamente corrispondenti due record tra i quali non esiste nessuna corrispondenza. Si incrementa la predisposizione della trasformazione a dedicare un tempo maggiore alla ricerca delle corrispondenze.
**Quando favorire il costo**
È opportuno favorire il costo se la preoccupazione maggiore riguarda il costo di esecuzione della trasformazione `find matches` rispetto al numero di corrispondenze rilevate. Per favorire il costo, scegliere un valore *più basso* per il compromesso tra accuratezza e costo. Con un valore più basso, la trasformazione `FindMatches` richiede una minore quantità di risorse per l'esecuzione. Si incrementa la predisposizione della trasformazione alla ricerca di un numero minore di corrispondenze. Utilizzare questa impostazione se, pur favorendo la ricerca di costi inferiori, i risultati sono comunque accettabili.
**Come favorire sia l'accuratezza che il costo**
Per esaminare un numero maggiore di coppie di record al fine di determinare la presenza di eventuali corrispondenze, serve un tempo di elaborazione maggiore. Se si desidera ridurre i costi senza ridurre la qualità, è possibile seguire la procedura illustrata qui di seguito:
+ Eliminare i record dell'origine dati per i quali la presenza di una corrispondenza non è di interesse.
+ Eliminare le colonne dell'origine dati che si è certi non siano utili ai fini della determinazione della presenza o meno di una corrispondenza. Un buon metodo per stabilirle quali siano è eliminare le colonne che non sembrano influenzare la propria valutazione sul fatto che un insieme di record rappresentino "la stessa cosa".
# Stima della qualità delle corrispondenze utilizzando i punteggi di confidenza delle corrispondenze
I punteggi di confidenza delle partite forniscono una stima della qualità delle corrispondenze rilevate FindMatches per distinguere tra record corrispondenti in cui il modello di apprendimento automatico è altamente sicuro, incerto o improbabile. Un punteggio di confidenza delle corrispondenze sarà compreso tra 0 e 1, dove il punteggio più alto significa una somiglianza più elevata. L'esame dei punteggi di confidenza delle corrispondenze consente di distinguere tra cluster di corrispondenze in cui il sistema è altamente sicuro (che potresti decidere di unire), cluster su cui il sistema è incerto (che potresti decidere di far esaminare da un essere umano) e cluster che il sistema ritiene improbabile (che potresti decidere di rifiutare).
Potresti dover modificare i tuoi dati di formazione in situazioni in cui vedi un punteggio di confidenza elevato, ma determinare che non ci sono corrispondenze, o dove vedi un punteggio basso determinare che ci sono, di fatto, corrispondenze.
I punteggi di fiducia sono particolarmente utili quando esistono set di dati industriali di grandi dimensioni, in cui è impossibile rivedere ogni decisione. FindMatches
I punteggi di confidenza delle corrispondenze sono disponibili in AWS Glue versione 2.0 o successive.
## Generazione di punteggi di confidenza delle corrispondenze
È possibile generare punteggi di confidenza delle corrispondenze impostando il valore booleano di `computeMatchConfidenceScores` su Vero quando si chiama `FindMatches` o lAPI `FindIncrementalMatches`.
AWS Glue aggiunge una nuova `column match_confidence_score` all'output.
## Esempi di punteggio di corrispondenza
Considera, ad esempio, le corrispondenze di registri seguenti:
**Punteggio >= 0,9**
Riepilogo dei registri corrispondenti:
```
primary_id | match_id | match_confidence_score
3281355037663 85899345947 0.9823658302132061
1546188247619 85899345947 0.9823658302132061
```
Informazioni:
![\[Esempio di tabella di routing con un gateway Internet.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/match_score1.png)
Da questo esempio, possiamo vedere che due registri sono molto simili e condividono `display_position`, `primary_name` e`street name`.
**Punteggio >= 0,8 e punteggio < 0,9**
Riepilogo dei registri corrispondenti:
```
primary_id | match_id | match_confidence_score
309237680432 85899345928 0.8309852373674638
3590592666790 85899345928 0.8309852373674638
343597390617 85899345928 0.8309852373674638
249108124906 85899345928 0.8309852373674638
463856477937 85899345928 0.8309852373674638
```
Informazioni:
![\[Esempio di tabella di routing con un gateway Internet.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/match_score2.png)
Da questo esempio, possiamo vedere che questi registri condividono gli stessi `primary_name` e`country`.
**Punteggio >= 0,6 e punteggio < 0,7**
Riepilogo dei registri corrispondenti:
```
primary_id | match_id | match_confidence_score
2164663519676 85899345930 0.6971099896480333
317827595278 85899345930 0.6971099896480333
472446424341 85899345930 0.6971099896480333
3118146262932 85899345930 0.6971099896480333
214748380804 85899345930 0.6971099896480333
```
Informazioni:
![\[Esempio di tabella di routing con un gateway Internet.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/match_score3.png)
Da questo esempio, possiamo vedere che questi registri condividono solo lo stesso `primary_name`.
Per ulteriori informazioni, consulta:
+ [Fase 5: aggiunta ed esecuzione di un processo con la trasformazione basata su machine learning](machine-learning-transform-tutorial.md#ml-transform-tutorial-add-job)
+ PySpark: [FindMatches classe](aws-glue-api-crawler-pyspark-transforms-findmatches.md)
+ PySpark: [FindIncrementalMatches classe](aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.md)
+ Scala: [FindMatches classe](glue-etl-scala-apis-glue-ml-findmatches.md)
+ Scala: [FindIncrementalMatches classe](glue-etl-scala-apis-glue-ml-findincrementalmatches.md)
# Addestramento della trasformazione di rilevamento delle corrispondenze
Ogni trasformazione `FindMatches` deve essere addestrata rispetto a ciò che deve essere considerato una corrispondenza e ciò che non deve essere considerato tale. Una trasformazione viene addestrata aggiungendo delle etichette a un file e caricando tali scelte su AWS Glue.
È possibile orchestrare questa operazione di etichettatura all'interno della console di AWS Glue o utilizzando le operazioni API di machine learning di AWS Glue.
**Quante volte è necessario eseguire l'operazione di etichettatura? Quante etichette sono necessarie?**
Le risposte a queste domande dipendono generalmente dall'utilizzatore. È necessario valutare se `FindMatches` offre il livello di accuratezza di cui si necessita e se si ritiene che un'etichettatura aggiuntiva possa valere la pena. Il modo migliore per deciderlo è analizzare i parametri "Precision", "Recall" e "Area sotto la curva di precisione e recall" che è possibile generare selezionando **Estimate quality (Valuta la qualità)** all'interno della console di AWS Glue. Dopo aver etichettato ulteriori insiemi di attività, ricalcolare questi parametri e verificare il loro eventuale miglioramento. Se, dopo l'etichettatura di alcuni insiemi di attività, non si percepisce un miglioramento del parametro di interesse, la qualità della trasformazione potrebbe aver raggiunto uno stato stazionario.
**Perché servono le etichette sia per gli eventi veri positivi che per quelli veri negativi?**
La trasformazione `FindMatches` ha bisogno di esempi sia positivi che negativi per comprendere cosa intende l'utente per corrispondenza. Se si stanno etichettando dei dati di addestramento generati da `FindMatches` (ad esempio, utilizzando l'opzione **I do not have labels (Non dispongo di etichette)**), `FindMatches` prova a generare un set di "id di insiemi di etichette". All'interno di ciascuna attività, si assegna la stessa "etichetta" ad alcuni record e diverse "etichette" ad altri record. In altre parole, le attività generalmente non prevedono solo la presenza di elementi tutti uguali o tutti diversi (anche se è normale che una specifica attività comprenda elementi "tutti uguali" o "tutti diversi").
Se si sta addestrando la trasformazione `FindMatches` utilizzando l'opzione **Upload labels from S3 (Caricamento delle etichette da S3)**, provare a includere sia esempi di record corrispondenti e che di record non corrispondenti. È accettabile averne di un solo tipo. Queste etichette consentono di creare una trasformazione `FindMatches` più accurata, ma è comunque necessario etichettare alcuni record generati utilizzando l'opzione **Generate labeling file (Genera file di etichettatura)**.
**Come posso fare in modo che la trasformazione rilevi le corrispondenze esattamente come è stata addestrata a fare?**
La trasformazione `FindMatches` esegue un processo di apprendimento a partire dalle etichette fornite, perciò potrebbe generare coppie di record che non rispettano tali etichette. Per far sì che la `FindMatches` trasformazione rispetti le tue etichette, seleziona **EnforceProvidedLabels**in. **FindMatchesParameter**
**Quali tecniche è possibile utilizzare quando una trasformazione basata su ML identifica come corrispondenti degli elementi che non lo sono?**
È possibile utilizzare le seguenti tecniche:
+ Incrementare il valore di `precisionRecallTradeoff`. Questa operazione porterà all'individuazione di un numero minore di corrispondenze ma, al raggiungimento di un valore sufficientemente elevato, dovrebbe anche suddividere un cluster di grandi dimensioni in componenti più piccole.
+ Selezionare le righe di output corrispondenti ai risultati errati e riformattarle sotto forma di insieme di dati per l'etichettatura (rimuovendo la colonna `match_id` e aggiungendo le colonne `labeling_set_id` e `label`). Se necessario, spezzettarle (suddividerle) in più insiemi di dati per l'etichettatura al fine di assicurare che l'addetto all'etichettatura possa concentrarsi su ogni set di dati durante il processo di etichettatura. Quindi, etichettare correttamente i set corrispondenti e caricare il file di etichettatura accodandolo alle etichette esistenti. Queste informazioni potrebbero addestrare la trasformazione a sufficienza su cosa cercare per comprendere lo schema.
+ (Avanzato) Infine, controllare i dati per verificare la presenza di uno schema che il sistema non sta rilevando. Pre-elaborare tali dati utilizzando le funzioni standard di AWS Glue per *normalizzarli*. Evidenziare gli elementi dai quali si desidera che l'algoritmo tragga insegnamenti separando i dati che l'utente ritiene importanti per la loro diversità nelle rispettive colonne. Oppure creare colonne combinate a partire dalle colonne i cui dati sono da ritenersi correlati.
# Operare con le trasformazioni basate su machine learning
Puoi utilizzarle AWS Glue per creare trasformazioni di machine learning personalizzate che possono essere utilizzate per pulire i dati. È possibile creare queste trasformazioni al momento della creazione di un processo nella console di AWS Glue .
Per informazioni su come creare una trasformazione basata su machine learning, consultare [Record di abbinamento con AWS Lake Formation FindMatches](machine-learning.md).
**Topics**
+ [Proprietà della trasformazione](#console-machine-learning-properties)
+ [Aggiunta e modifica della trasformazione basata su machine learning](#console-machine-learning-transforms-actions)
+ [Visualizzazione dei dettagli della trasformazione](#console-machine-learning-transforms-details)
+ [Insegnamento delle trasformazioni utilizzando le etichette](#console-machine-learning-transforms-teaching-transforms)
## Proprietà della trasformazione
Per visualizzare una trasformazione di machine learning esistente, accedi a e apri la Console di gestione AWSAWS Glue console all'indirizzo. [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) Nel pannello di navigazione sotto **Integrazione dati ed ETL**, scegli **Strumenti di classificazione dei dati > Corrispondenza dei record**.
Le proprietà di ogni trasformazione:
**Nome trasformazione**
Il nome univoco che assegnato alla trasformazione al momento della creazione.
**ID**
Un identificatore unico della trasformazione.
**Numero delle etichette**
Il numero di etichette nel file di etichettatura fornito per l'addestramento della trasformazione.
**Status**
Indica se la trasformazione è **Ready (Pronta)** o **Needs training (Ha bisogno di addestramento)**. Per eseguire correttamente una trasformazione basata su machine learning in un processo, questa deve trovarsi nello stato **Ready (Pronta)**.
**Creato**
La data di creazione della trasformazione.
**Modificato**
La data dell'ultimo aggiornamento della trasformazione.
**Description**
La descrizione fornita per la trasformazione, se ne è stata fornita una.
**Versione AWS Glue**
La versione di AWS Glue utilizzata.
**ID esecuzione**
Il nome univoco che assegnato alla trasformazione al momento della creazione.
**Tipo di attività**
Il tipo di trasformazione basata su machine learning; ad esempio, **Find matching records (Rilevamento record corrispondenti)**.
**Status**
Indica lo stato dell'esecuzione dell'attività. Gli stati possibili comprendono:
+ Avvio in corso
+ In esecuzione
+ In arresto
+ Arrestato
+ Riuscito
+ Non riuscito
+ Timeout
**Errore**
Se lo stato è Non riuscito, viene visualizzato un messaggio di errore che descrive il motivo dell'errore.
## Aggiunta e modifica della trasformazione basata su machine learning
Nella console AWS Glue è possibile visualizzare, eliminare, impostare e addestrare o ottimizzare una trasformazione. Selezionare la casella di controllo accanto alla trasformazione nell'elenco, scegliere **Action (Operazione)** e quindi scegliere l'operazione che si desidera eseguire.
### Creazione di una nuova trasformazione ML
Per aggiungere una nuova trasformazione di machine learning, scegli **Crea trasformazione**. Segui le istruzioni nella procedura guidata **Aggiungi crawler**. Per ulteriori informazioni, consulta [Record di abbinamento con AWS Lake Formation FindMatches](machine-learning.md).
#### Passaggio 1. Imposta le proprietà della trasformazione.
1. Inserisci il nome e la descrizione (facoltativo).
1. Facoltativamente, imposta la configurazione di sicurezza. Per informazioni, consulta [Utilizzo della crittografia dati con le trasformazioni basate su machine learning](#ml_transform_sec_config).
1. Facoltativamente, configura le impostazioni di esecuzione delle attività. Le impostazioni di esecuzione delle attività consentono di personalizzare la modalità di esecuzione dell'attività. Seleziona il tipo di e il numero di worker, il timeout dell'attività (in minuti), il numero di nuovi tentativi e la versione di AWS Glue.
1. Facoltativamente, imposta i tag. I tag sono etichette che puoi assegnare a una AWS risorsa. Ciascun tag è formato da una chiave e da un valore facoltativo. I tag possono essere utilizzati per cercare e filtrare la risorsa o tenere traccia AWS dei costi.
#### Passaggio 2. Scegli la tabella e la chiave primaria.
1. Scegli il database e la tabella di Catalogo AWS Glue.
1. Scegli una chiave primaria dalla tabella selezionata. La colonna della chiave primaria contiene in genere un identificatore univoco per ogni record nell'origine dati.
#### Fase 3. Seleziona le opzioni di ottimizzazione.
1. Per **Richiamo o precisione**, scegli il valore di regolazione per ottimizzare la trasformazione in modo da favorire il richiamo o la precisione. Per impostazione predefinita, è selezionata l'opzione **Bilanciato**, ma puoi scegliere di favorire il richiamo o la precisione; puoi anche scegliere l'opzione **Personalizzato** e inserire un valore compreso tra 0,0 e 1,0 (inclusi).
1. Per **Costo o precisione inferiore**, scegli il valore di regolazione per favorire un costo o una precisione inferiori oppure scegli **Personalizzato** e inserisci un valore compreso tra 0,0 e 1,0 (inclusi).
1. Per **Forza corrispondenza**, scegli **Forza l'output a corrispondere alle etichette** se desideri addestrare la trasformazione ML forzando l'output a corrispondere alle etichette utilizzate.
#### Passaggio 4. Revisione e creazione.
1. Esamina le opzioni per i passaggi da 1 a 3.
1. Scegli **Modifica** per qualsiasi passaggio che desideri modificare. Scegli **Crea trasformazione** per completare la procedura guidata di creazione della trasformazione.
### Utilizzo della crittografia dati con le trasformazioni basate su machine learning
Quando si aggiunge una trasformazione basata su machine learning a AWS Glue, è possibile specificare facoltativamente una configurazione di sicurezza associata all'origine dati o alla destinazione dati. Se il bucket Amazon S3 utilizzato per memorizzare i dati è crittografato con una configurazione di sicurezza, specifica la stessa configurazione di sicurezza durante la creazione della trasformazione.
Puoi anche scegliere di utilizzare la crittografia lato server con AWS KMS (SSE-KMS) per crittografare il modello e le etichette per impedire l'ispezione da parte di persone non autorizzate. Se scegli questa opzione, ti viene richiesto di scegliere il nome AWS KMS key per nome oppure puoi scegliere **Inserisci una chiave ARN.** Se si sceglie di inserire l'ARN per la chiave KMS, viene visualizzato un secondo campo in cui è possibile inserire l'ARN della chiave KMS.
**Nota**
Attualmente, le trasformazioni ML che usano una chiave di crittografia personalizzata non sono supportate nelle seguenti Regioni:
Asia Pacifico (Osaka): `ap-northeast-3`
## Visualizzazione dei dettagli della trasformazione
### Visualizzazione delle proprietà della trasformazione
La pagina **Proprietà della trasformazione** include gli attributi della trasformazione. Mostra i dettagli relativi alla definizione della trasformazione, tra cui i seguenti:
+ **Transform name (Nome della trasformazione)** mostra il nome della trasformazione.
+ **Tipo** elenca il tipo della trasformazione.
+ **Stato** indica se la trasformazione è pronta per essere utilizzata in uno script o un processo.
+ **Force output to match labels (Forza l'output affinché corrisponda alle etichette)** mostra se la trasformazione esegue una forzatura affinché l'output corrisponda alle etichette indicate dall'utente.
+ **Versione Spark** è correlato alla versione di AWS Glue che hai scelto nelle **Proprietà esecuzione processo** all'aggiunta della trasformazione. AWS Glue 1.0 e Spark 2.4 sono consigliati per la maggior parte dei clienti. Per ulteriori informazioni, consulta [Versioni di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/release-notes.html#release-notes-versions).
### Schede Cronologia, Stima qualità e Tag
I dettagli includono le informazioni definite al momento della creazione della trasformazione. Per visualizzare i dettagli di una trasformazione, selezionare la trasformazione nell'elenco delle **Machine learning transforms (Trasformazioni basate su machine learning)** e rivedere le informazioni contenute nelle seguenti schede:
+ Cronologia
+ Stima della qualità
+ Tag
#### Cronologia
La scheda **History (Cronologia)** mostra la cronologia delle esecuzioni della trasformazione. Per addestrare una trasformazione, vengono eseguiti diversi tipi di attività. Per ogni attività, i parametri di esecuzione includono:
+ **Run ID (ID esecuzione)** è un identificatore creato da AWS Glue per ogni esecuzione di questo processo.
+ **Task type (Tipo di attività)** mostra il tipo di attività eseguita.
+ **Status (Stato)** mostra la corretta conclusione di ogni esecuzione posizionando quella più recente in cima all'elenco.
+ **Errore** mostra i dettagli di un messaggio di errore se l'esecuzione non riesce.
+ **Start time (Orario inizio)** mostra la data e l'ora (ora locale) in cui è stato avviato il processo.
+ **Orario fine** mostra la data e l'ora (ora locale) in cui il processo è finito.
+ **Log** collega ai log scritti in `stdout` per questa esecuzione di processo.
Il link **Logs** ti porta ad Amazon CloudWatch Logs. Qui puoi visualizzare i dettagli sulle tabelle create in AWS Glue Data Catalog e gli eventuali errori riscontrati. È possibile gestire il periodo di conservazione dei registri sulla CloudWatch console. Il periodo di conservazione log predefinito è `Never Expire`. Per ulteriori informazioni su come modificare il periodo di conservazione, consulta [Change Log Data Retention in CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#SettingLogRetention) nella *Amazon CloudWatch Logs User* Guide.
+ **File di etichettatura** mostra un link ad Amazon S3 che permette di raggiungere un file di etichettatura generato.
#### Stima della qualità
La scheda **Estimate quality (Stima qualità)** mostra i parametri utilizzati per misurare la qualità della trasformazione. Le stime vengono calcolate confrontando le previsioni di conversione utilizzando un sottoinsieme dei dati etichettati con le etichette fornite. Queste stime sono approssimative. Da questa scheda è possibile richiamare l'esecuzione dell'attività **Estimate quality (Stima qualità)**.
La scheda **Estimate quality (Stima qualità)** mostra i parametri dell'ultima esecuzione **Estimate quality (Stima qualità)**, incluse le seguenti proprietà:
+ **Area under the Precision-Recall curve (Area sotto la curva precisione-recupero)** è un singolo numero che stima il limite superiore della qualità complessiva della trasformazione. È indipendente dalla scelta del parametro precisione-recupero. Valori più elevati indicano che si dispone di un compromesso precisione-recupero migliore.
+ **Precision (Precisione)** stima la frequenza di correttezza della trasformazione quando prevede una corrispondenza.
+ **Recall upper limit (Limite superiore recupero)** stima quanto spesso la trasformazione prevede una corrispondenza in caso di effettiva presenza.
+ **F1** stima l'accuratezza della trasformazione con un valore tra 0 e 1, dove 1 è la migliore precisione. Per ulteriori informazioni, consulta la voce [F1 score](https://en.wikipedia.org/wiki/F1_score) su Wikipedia.
+ La tabella **Column importance (Importanza colonna)** mostra i nomi delle colonne e il punteggio di importanza per ogni colonna. L'importanza delle colonne consente di comprendere il modo in cui queste contribuiscono al modello, identificando quali colonne nei record vengono maggiormente utilizzate per la corrispondenza. Questi dati possono richiedere di aggiungere o modificare il set di etichette per aumentare o diminuire l'importanza delle colonne.
La colonna Importance (Importanza) fornisce un punteggio numerico per ogni colonna, come decimale non maggiore di 1,0.
Per ulteriori informazioni su come comprendere le stime della qualità rispetto alla vera qualità, consultare [Stime sulla qualità rispetto alla qualità ( end-to-endvera)](#console-machine-learning-quality-estimates-true-quality).
Per ulteriori informazioni sull'ottimizzazione della trasformazione, consultare [Ottimizzazione delle trasformazioni basate su machine learning in AWS Glue](add-job-machine-learning-transform-tuning.md).
#### Stime sulla qualità rispetto alla qualità ( end-to-endvera)
AWS Glue stima la qualità della trasformazione passando al modello addestrato tramite machine learning interno un certo numero di coppie di record per i quali sono state fornite delle etichette corrispondenti ma che il modello non ha mai visto in precedenza. Queste stime di qualità sono una funzione della qualità del modello addestrato tramite machine learning (che dipende dal numero di record etichettati per "addestrare" la trasformazione). Il richiamo end-to-end, o *vero*, (che non viene calcolato automaticamente da`ML transform`) è influenzato anche dal meccanismo di `ML transform` filtraggio che propone un'ampia varietà di possibili corrispondenze al modello di apprendimento automatico.
È possibile ottimizzare tale metodo di filtraggio principalmente utilizzando il cursore **Costo o accuratezza inferiore**. Spostando il cursore verso **Accuratezza** per favorire questo aspetto, il sistema esegue una ricerca più vasta e approfondita delle coppie di record che potrebbero rappresentare delle corrispondenze. Più coppie di record vengono inserite nel modello di apprendimento automatico e il tuo richiamo effettivo si avvicina alla metrica `ML transform` di end-to-end richiamo stimata. Di conseguenza, le variazioni nella end-to-end qualità delle partite dovute a variazioni del rapporto costo/precisione delle partite in genere non si riflettono nella stima della qualità.
#### Tag
I tag sono etichette che puoi assegnare a una risorsa. AWS Ciascun tag è formato da una chiave e da un valore facoltativo. I tag possono essere utilizzati per cercare e filtrare la risorsa o tenere traccia AWS dei costi.
## Insegnamento delle trasformazioni utilizzando le etichette
È possibile insegnare la trasformazione ML tramite le etichette (esempi) scegliendo **Insegna la trasformazione** dalla pagina dei dettagli della trasformazione ML. Quando addestri l'algoritmo di machine learning fornendo esempi (chiamati etichette), puoi scegliere etichette esistenti da utilizzare o creare un file di etichettatura.
![\[La schermata mostra una schermata della procedura guidata per Insegnare la trasformazione utilizzando le etichette.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/machine-learning-teach-transform.png)
+ **Etichettatura**: se hai delle etichette, scegli **Ho delle etichette**. Se non disponi di etichette, puoi comunque proseguire con il passaggio successivo per generare un file di etichettatura.
+ **Genera un file di etichettatura**: AWS Glue estrae i record dai dati di origine e suggerisce potenziali record corrispondenti. Scegli il bucket Amazon S3 per archiviare il file di etichette generato. Scegli **Genera file di etichettatura** per avviare il processo. Al termine, scegli **Scarica il file di etichettatura**. Il file scaricato avrà una colonna per le etichette in cui potrai inserire le etichette.
+ **Carica etichette da Amazon S3**: scegli il file di etichettatura completo dal bucket Amazon S3 in cui è archiviato il file di etichette. Quindi, scegli se aggiungere le etichette alle etichette esistenti o sovrascriverle. Scegli **Carica file di etichettatura da Amazon S3**.
# Tutorial: creazione di una trasformazione dell'apprendimento automatico con AWS Glue
Questa esercitazione guida l'utente nelle operazioni necessarie per creare e gestire una trasformazione basata su machine learning (ML) utilizzando AWS Glue. Prima di seguire questa esercitazione, è necessario sapere come utilizzare la console di AWS Glue per aggiungere crawler e processi e modificare script. È inoltre necessario avere familiarità con la ricerca e il download di file tramite la console Amazon Simple Storage Service (Amazon S3).
In questo esempio, viene creata una trasformazione `FindMatches` per identificare i record corrispondenti, insegnando ad essa come identificare i record con corrispondenze e quelli senza, e la si utilizza in un processo AWS Glue. Il processo AWS Glue genera un nuovo file Amazon S3 con una colonna aggiuntiva denominata `match_id`.
I dati di origine utilizzati da questa esercitazione cono contenuti in un file denominato `dblp_acm_records.csv`. Questo file è una versione modificata derivante da pubblicazioni accademiche (DBLP e ACM) disponibili presso la fonte originale [set di dati DBLP ACM ](https://doi.org/10.3886/E100843V2). Il file `dblp_acm_records.csv` è un file di valori separati da virgole (CSV) in formato UTF-8 senza BOM (Byte Order Mark).
Un secondo file, `dblp_acm_labels.csv`, è un esempio di file di etichettatura che contiene sia i record con corrispondenze che quelli senza utilizzato per addestrare la trasformazione come parte dell'esercitazione.
**Topics**
+ [Fase 1: crawling dei dati di origine](#ml-transform-tutorial-crawler)
+ [Fase 2: aggiunta di una trasformazione basata su machine learning](#ml-transform-tutorial-create)
+ [Fase 3: addestramento della trasformazione basata su machine learning](#ml-transform-tutorial-teach)
+ [Fase 4: stima della qualità della trasformazione basata su machine learning](#ml-transform-tutorial-estimate-quality)
+ [Fase 5: aggiunta ed esecuzione di un processo con la trasformazione basata su machine learning](#ml-transform-tutorial-add-job)
+ [Fase 6: verifica dei dati di output da Amazon S3](#ml-transform-tutorial-data-output)
## Fase 1: crawling dei dati di origine
In primo luogo, esegui il crawling del file CSV di origine su Amazon S3 per creare una tabella di metadati corrispondente nel catalogo dati.
**Importante**
Per ottenere dal crawler la creazione di una tabella per il solo file CSV, archivia il file CSV dei dati di origine in una cartella Amazon S3 diversa da quella degli altri file.
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 riquadro di navigazione, selezionare **Crawlers (Crawler)**, **Add crawler (Aggiungi Crawler)**.
1. Seguire la procedura guidata per creare ed eseguire un crawler denominato `demo-crawl-dblp-acm` con output indirizzato verso il database `demo-db-dblp-acm`. Se questo non esiste già, durante l'esecuzione della procedura guidata è necessario creare il database `demo-db-dblp-acm`. Scegli un percorso di inclusione di Amazon S3 per i dati di esempio nella regione corrente AWS . Ad esempio, per `us-east-1`, il percorso di inclusione per i dati di origine su Amazon S3 è `s3://ml-transforms-public-datasets-us-east-1/dblp-acm/records/dblp_acm_records.csv`.
Se conclude l'attività con successo, il crawler crea la tabella `dblp_acm_records_csv` con le seguenti colonne: id, title, authors, venue, year e source.
## Fase 2: aggiunta di una trasformazione basata su machine learning
A questo punto, aggiungere una trasformazione basata su machine learning basata sullo schema dei dati della tabella di origine creata dal crawler e denominata `demo-crawl-dblp-acm`.
1. Nella console AWS Glue, nel riquadro di navigazione in **Integrazione dati e ETL**, scegli **Strumenti di classificazione dei dati > Corrispondenza dei record**, quindi **Aggiungi trasformazione**. Quindi segui la procedura guidata per creare una trasformazione `Find matches` con le seguenti proprietà.
1. Alla voce **Transform name (Nome trasformazione)**, immettere **demo-xform-dblp-acm**. Questo è il nome della trasformazione che viene utilizzato per trovare le corrispondenze nei dati di origine.
1. Alla voce **IAM role (Ruolo IAM)**, scegli un ruolo IAM che disponga delle autorizzazioni per accedere ai dati di origine su Amazon S3, ai file di etichettatura e alle operazioni API di AWS Glue. Per ulteriori informazioni, consulta [Creazione di un ruolo IAM per AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html) nella *Guida per sviluppatori di AWS Glue *.
1. Per l'**origine dei dati**, scegli la tabella denominata **dblp\$1acm\$1records\$1csv** nel database. **demo-db-dblp-acm**
1. Alla voce **Primary key (Chiave primaria)**, scegliere la colonna chiave primaria della tabella, **id**.
1. Nella procedura guidata, scegliere **Finish (Fine)** e tornare all'elenco delle **ML transforms (Trasformazioni basate su ML)**.
## Fase 3: addestramento della trasformazione basata su machine learning
A questo punto è necessario addestrare la trasformazione basata su machine learning utilizzando il file di etichettatura di esempio del tutorial.
Non è possibile utilizzare una trasformazione basata su machine learning in un processo di estrazione, trasformazione e caricamento (ETL) finché il suo stato non è **Ready for use (Pronta per l'uso)**. Affinché la trasformazione sia pronta, è necessario addestrarla a identificare i record con corrispondenze e quelli senza fornendo esempi di record con corrispondenza e di record senza corrispondenza. Per addestrare la trasformazione, è possibile scegliere **Generate a label file (Genera un file di etichettatura)**, aggiungere le etichette e quindi selezionare **Upload label file (Carica un file di etichettatura)**. In questa esercitazione è possibile utilizzare il file di etichettatura di esempio denominato `dblp_acm_labels.csv`. Per ulteriori informazioni sul processo di etichettatura, consultare [Etichettatura](machine-learning.md#machine-learning-labeling).
1. Nella console AWS Glue, seleziona **Corrispondenza dei record** nel riquadro di navigazione.
1. Scegliere la trasformazione `demo-xform-dblp-acm` e quindi scegliere **Action (Operazione)**, **Teach (Addestra)**. Seguire la procedura guidata per addestrare la trasformazione `Find matches`.
1. Nella pagina delle proprietà della trasformazione, scegliere **I have labels (Dispongo delle etichette)**. Scegli un percorso Amazon S3 per il file di etichettatura di esempio nella regione corrente. AWS Ad esempio, nel caso di `us-east-1`, caricare il file di etichettatura fornito dal percorso su Amazon S3 `s3://ml-transforms-public-datasets-us-east-1/dblp-acm/labels/dblp_acm_labels.csv` con l'opzione di **overwrite (sovrascrivere)** le etichette esistenti. Il file di etichettatura deve essere situato su Amazon S3 nella stessa regione in cui si trova la console di AWS Glue.
Quando si carica un file di etichettatura, AWS Glue avvia un'attività per aggiungere o sovrascrivere le etichette utilizzate per addestrare la trasformazione sull'elaborazione dell'origine dati.
1. Nella pagina finale della procedura guidata scegliere **Finish (Fine)** e tornare all'elenco delle **ML transforms (Trasformazioni basate su ML)**.
## Fase 4: stima della qualità della trasformazione basata su machine learning
Successivamente, è possibile stimare la qualità della propria trasformazione basata su machine learning. La qualità varia in base al numero di etichettature eseguite. Per ulteriori informazioni sulla stima della qualità, consultare [Stima della qualità](console-machine-learning-transforms.md#console-machine-learning-transforms-metrics).
1. Nella console AWS Glue, nel riquadro di navigazione in **Integrazione dati e ETL**, scegli **Strumenti di classificazione dei dati > Corrispondenza dei record**.
1. Scegliere la trasformazione `demo-xform-dblp-acm` e scegliere la scheda **Estimate quality (Stima della qualità)**. Questa scheda visualizza l'attuale stima di della qualità, se disponibile, per la trasformazione.
1. Scegliere **Estimate quality (Stima della qualità)** per avviare un'attività di stima della qualità della trasformazione. La precisione della stima della qualità si poggia sull'etichettatura dei dati di origine.
1. Passare alla scheda **History (Cronologia)**. In questo riquadro sono elencate le esecuzioni di attività per ogni trasformazione, inclusa l'attività di **Estimate quality (Stima della qualità)**. Per ulteriori informazioni sull'esecuzione, scegliere **Logs (Log)**. Verificare che, al termine dell'operazione, lo stato di esecuzione sia **Succeeded (Completata correttamente)**.
## Fase 5: aggiunta ed esecuzione di un processo con la trasformazione basata su machine learning
In questo passaggio si utilizza la trasformazione basata su machine learning per aggiungere ed eseguire un processo in AWS Glue. Quando la trasformazione `demo-xform-dblp-acm` è **Ready for use (Pronta per l'uso)** è possibile utilizzarla in un processo ETL.
1. Nel riquadro di navigazione della console di AWS Glue, scegliere **Jobs (Processi)**.
1. Scegliere **Add job (Aggiungi processo)** e seguire la procedura guidata per creare un processo ETL Spark con uno script generato. Per le proprietà della trasformazione scegliere i seguenti valori:
1. Per **Nome**, scegli il lavoro di esempio in questo tutorial,. **demo-etl-dblp-acm**
1. Alla voce **IAM role (Ruolo IAM)**, scegli un ruolo IAM che disponga delle autorizzazioni per accedere ai dati di origine su Amazon S3, ai file di etichettatura dei dati e alle operazioni API di AWS Glue. Per ulteriori informazioni, consulta [Creazione di un ruolo IAM per AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html) nella *Guida per sviluppatori di AWS Glue *.
1. Alla voce **ETL language** (Linguaggio ETL) scegli **Scala**. Questo è il linguaggio di programmazione dello script ETL.
1. Per il **nome del file di script**, scegliete **demo-etl-dblp-acm**. Questo è il nome del file dello script Scala (uguale al nome del processo).
1. Come **Data source (Origine dati)**, scegliere **dblp\$1acm\$1records\$1csv**. L'origine dati scelta deve corrispondere allo schema dell'origine dati della trasformazione basata su machine learning.
1. Alla voce **Transform type (Tipo di trasformazione)**, scegliere **Find matching records (Individuazione record corrispondenti)** per creare un processo che utilizza una trasformazione basata su machine learning.
1. Annullare la selezione di **Remove duplicate records (Rimuovi record duplicati)**. Si sceglie di non rimuovere i record duplicati perché i record di output dispongono di un campo aggiuntivo `match_id` accodato.
1. Per **Transform **demo-xform-dblp-acm****, scegli la trasformazione di machine learning utilizzata dal job.
1. Alla voce **Create tables in your data target (Crea tabelle nella destinazioni dati)**, scegliere di creare tabelle con le seguenti proprietà:
+ **Tipo di memorizzazione dei dati**: **Amazon S3**
+ **Formato**: **CSV**
+ **Tipo di compressione**: **None**
+ **Percorso di destinazione**: il percorso Amazon S3 in cui viene scritto l'output del processo (nell'attuale regione della console AWS )
1. Scegliere **Save job and edit script (Salva processo e modifica script)** per visualizzare la pagina dell'editor dello script.
1. Modificare lo script per aggiungere un'istruzione che faccia sì che l'output del processo sia scritto sul **Target path (Percorso di destinazione)** in un file a singola partizione. Aggiungere questa istruzione immediatamente dopo l'istruzione che esegue la trasformazione `FindMatches`. Le istruzioni sono simili alle seguenti.
```
val single_partition = findmatches1.repartition(1)
```
È necessario modificare l'istruzione `.writeDynamicFrame(findmatches1)` per scrivere l'output come `.writeDynamicFrame(single_partion)`.
1. Dopo aver modificato lo script, scegliere **Save (Salva)**. Lo script modificato è simile al codice riportato qui di seguito, ma personalizzato in base al proprio tuo ambiente.
```
import com.amazonaws.services.glue.GlueContext
import com.amazonaws.services.glue.errors.CallSite
import com.amazonaws.services.glue.ml.FindMatches
import com.amazonaws.services.glue.util.GlueArgParser
import com.amazonaws.services.glue.util.Job
import com.amazonaws.services.glue.util.JsonOptions
import org.apache.spark.SparkContext
import scala.collection.JavaConverters._
object GlueApp {
def main(sysArgs: Array[String]) {
val spark: SparkContext = new SparkContext()
val glueContext: GlueContext = new GlueContext(spark)
// @params: [JOB_NAME]
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
Job.init(args("JOB_NAME"), glueContext, args.asJava)
// @type: DataSource
// @args: [database = "demo-db-dblp-acm", table_name = "dblp_acm_records_csv", transformation_ctx = "datasource0"]
// @return: datasource0
// @inputs: []
val datasource0 = glueContext.getCatalogSource(database = "demo-db-dblp-acm", tableName = "dblp_acm_records_csv", redshiftTmpDir = "", transformationContext = "datasource0").getDynamicFrame()
// @type: FindMatches
// @args: [transformId = "tfm-123456789012", emitFusion = false, survivorComparisonField = "", transformation_ctx = "findmatches1"]
// @return: findmatches1
// @inputs: [frame = datasource0]
val findmatches1 = FindMatches.apply(frame = datasource0, transformId = "tfm-123456789012", transformationContext = "findmatches1", computeMatchConfidenceScores = true)
// Repartition the previous DynamicFrame into a single partition.
val single_partition = findmatches1.repartition(1)
// @type: DataSink
// @args: [connection_type = "s3", connection_options = {"path": "s3://aws-glue-ml-transforms-data/sal"}, format = "csv", transformation_ctx = "datasink2"]
// @return: datasink2
// @inputs: [frame = findmatches1]
val datasink2 = glueContext.getSinkWithFormat(connectionType = "s3", options = JsonOptions("""{"path": "s3://aws-glue-ml-transforms-data/sal"}"""), transformationContext = "datasink2", format = "csv").writeDynamicFrame(single_partition)
Job.commit()
}
}
```
1. Scegliere **Run job (Esegui processo)** per avviare l'esecuzione del processo. Controllare lo stato del processo nell'elenco dei processi. Al termine del processo, nella finestra **ML transform (Trasformazione ML)**, **History (Cronologia)**, è disponibile una nuova riga **Run ID (ID esecuzione)** aggiunta di tipo ** ETL job (Processo ETL)**.
1. Passare alla scheda **Jobs (Processi)**, **History (Cronologia)**. In questo riquadro vengono elencate le esecuzioni dei processi. Per ulteriori informazioni sull'esecuzione, scegliere **Logs (Log)**. Verificare che, al termine dell'operazione, lo stato di esecuzione sia **Succeeded (Completata correttamente)**.
## Fase 6: verifica dei dati di output da Amazon S3
In questa fase si verifica l'output dell'esecuzione del processo nel bucket Amazon S3 scelto al momento dell'aggiunta del processo. È possibile scaricare il file di output sulla propria macchina locale e verificare che i record corrispondenti siano stati identificati.
1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Scaricare il file di output di destinazione del processo `demo-etl-dblp-acm`. Aprire il file in un foglio di calcolo (per aprire il file correttamente, potrebbe essere necessario aggiungere al file l'estensione `.csv`).
L'immagine seguente mostra un estratto dell'output in Microsoft Excel.
![\[Foglio di calcolo Excel che mostra l'output della trasformazione.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/demo_output_dblp_acm.png)
L'origine e la destinazione dei dati contano entrambe 4.911 record. Tuttavia, la trasformazione `Find matches` aggiunge un'altra colonna denominata `match_id` per identificare i record corrispondenti nell'output. Le righe con gli stessi `match_id` sono considerate record corrispondenti. La `match_confidence_score` è un numero compreso tra 0 e 1 che fornisce una stima della qualità delle corrispondenze trovate da `Find matches`.
1. Ordinare il file di output per `match_id` al fine di visualizzare facilmente i record corrispondenti. Confrontare i valori nelle altre colonne per confermare i risultati della trasformazione `Find matches`. Se i risultati non sono soddisfacenti, è possibile continuare ad addestrare la trasformazione aggiungendo ulteriori etichette.
È anche possibile ordinare i file per un altro campo, ad esempio `title`, per vedere se record con titoli simili presentano lo stesso `match_id`.
# Trovare corrispondenze incrementali
La caratteristica FindMatches permette di identificare registri duplicati o corrispondenti nel set di dati, anche quando i registri non dispongono di un identificatore univoco comune e nessun campo corrisponde esattamente. La versione iniziale di Trova corrispondenze trasforma i registri corrispondenti identificati all'interno di un singolo set di dati. Quando si aggiungono nuovi dati al set, avrai già dovuto unirli con il set di dati pulito esistente e rieseguire la corrispondenza con il set di dati unito completo.
La funzione di corrispondenza incrementale semplifica la corrispondenza con i registri incrementali rispetto ai set di dati corrispondenti esistenti. Supponiamo che desideri abbinare i dati dei potenziali clienti con i set di dati esistenti dei clienti. La funzionalità di corrispondenza incrementale offre la flessibilità necessaria per abbinare centinaia di migliaia di nuovi prospect con un database esistente di prospect e potenziali clienti combinando i risultati in un unico database o tabella. Corrispondendo solo tra i set di dati nuovi ed esistenti, l'ottimizzazione delle corrispondenze incrementali di ricerca riduce i tempi di calcolo, riducendo anche i costi.
L'uso della corrispondenza incrementale è simile a Trova corrispondenze come descritto in [Tutorial: creazione di una trasformazione dell'apprendimento automatico con AWS Glue](machine-learning-transform-tutorial.md). Questo argomento identifica solo le differenze con la corrispondenza incrementale.
Per ulteriori informazioni, leggi il post del blog su [Corrispondenza incrementale dei dati](https://aws.amazon.com/blogs/big-data/incremental-data-matching-using-aws-lake-formation/).
## Esecuzione di un processo di corrispondenza incrementale
Per la seguente procedura, supponiamo quanto segue:
+ Hai eseguito il crawling del set di dati esistente nella tabella *first\$1records*. Il set di dati *first\$1records* deve essere un set di dati corrispondente o l'output del processo corrispondente.
+ Hai creato e addestrato una trasformazione Find matches (Trova corrispondenze) con AWS Glue Glue versione 2.0. Questa è l'unica versione di AWS Glue che supporti le corrispondenze incrementali.
+ Il linguaggio ETL è Scala. Si noti che anche Python è supportato.
+ Il modello già generato viene chiamato `demo-xform`.
1. Esegui la scansione del set di dati incrementale nella tabella *second\$1records*.
1. Nel riquadro di navigazione della console di AWS Glue, scegliere **Jobs (Processi)**.
1. Scegliere **Add job (Aggiungi processo)** e seguire la procedura guidata per creare un processo ETL Spark con uno script generato. Per le proprietà della trasformazione scegliere i seguenti valori:
1. Per **Name** (Nome), scegli **demo-etl**.
1. Alla voce **IAM role (Ruolo IAM)**, scegli un ruolo IAM che disponga delle autorizzazioni per accedere ai dati di origine su Amazon S3, ai file di etichettatura dei dati e alle [operazioni API di AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html).
1. Alla voce **ETL language** (Linguaggio ETL) scegli **Scala**.
1. Come **Script file name (Nome del file di script)**, scegli **demo-etl**. Questo è il nome del file dello script Scala.
1. Per **Data source (Origine dati)**, scegli **first\$1records**. L'origine dati scelta deve corrispondere allo schema dell'origine dati della trasformazione basata su machine learning.
1. Alla voce **Transform type (Tipo di trasformazione)**, scegliere **Find matching records (Individuazione record corrispondenti)** per creare un processo che utilizza una trasformazione basata su machine learning.
1. Seleziona l'opzione di corrispondenza incrementale e per **Data source** (Origine dati) seleziona la tabella denominata **second\$1records**.
1. Alla voce **Transform (Trasformazione)**, scegli **demo-xform**, la trasformazione basata su machine learning utilizzata del processo.
1. Scegli **Create tables in your data target** (Crea tabelle nella tua destinazione di dati) o **Use tables in the catalogo dati and update your data target** (Usa tabelle nel catalogo dati e aggiorna la destinazione dati).
1. Scegliere **Save job and edit script (Salva processo e modifica script)** per visualizzare la pagina dell'editor dello script.
1. Scegliere **Run job (Esegui processo)** per avviare l'esecuzione del processo.
# Utilizzo FindMatches in un lavoro visivo
Per utilizzare la **FindMatches**trasformazione inAWS Glue Studio, puoi utilizzare il nodo **Custom Transform** che richiama l' FindMatches API. Per ulteriori informazioni su come utilizzare una trasformazione personalizzata, consulta la pagina [Creating a custom transformation](https://docs.aws.amazon.com/glue/latest/ug/transforms-custom.html)
**Nota**
Attualmente, l' FindMatches API funziona solo con. `Glue 2.0` Per eseguire un lavoro con la trasformazione personalizzata che richiama l' FindMatches API, assicurati che la AWS Glue versione sia `Glue 2.0` nella **scheda Dettagli del lavoro**. Se la versione di non lo AWS Glue è`Glue 2.0`, il processo fallirà in fase di esecuzione con il seguente messaggio di errore: «impossibile importare il nome '' da FindMatches 'awsglueml.transforms'».
## Prerequisiti
+ Per utilizzare la trasformazione **Trova corrispondenze**, apri la console AWS Glue Studio all'indirizzo [https://console.aws.amazon.com/gluestudio/](https://console.aws.amazon.com/gluestudio/).
+ Crea una trasformazione basata su machine learning. Una volta creata, viene generato un transformId. Avrai bisogno di questo ID per i passaggi successivi. Per ulteriori informazioni su come creare una trasformazione basata su machine learning, consulta la pagina [Adding and editing machine learning transforms](https://docs.aws.amazon.com/glue/latest/dg/console-machine-learning-transforms.html#console-machine-learning-transforms-actions).
## Aggiungere una trasformazione FindMatches
**Per aggiungere una FindMatches trasformazione:**
1. Nell'editor dei processi AWS Glue Studio, apri il pannello Risorse facendo clic sul simbolo della croce nell'angolo in alto a sinistra del grafico visivo del processo e scegli un'origine dati selezionando la **scheda Dati**. Questa è l'origine dati nella quale verificare la presenza di corrispondenze.
![\[La schermata mostra un simbolo a croce all'interno di un cerchio. Facendo clic su questo pulsante nell'editor visivo dei processi, si apre il pannello delle risorse.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/resource-panel-blank-canvas.png)
1. Scegli il nodo dell'origine dati, quindi apri il pannello Risorse facendo clic sul simbolo della croce nell'angolo in alto a sinistra del grafico visivo del processo e cerca "trasformazione personalizzata". Scegli il nodo **Trasformazione personalizzata** per aggiungerlo al grafico. La **Trasformazione personalizzata** è collegata al nodo dell'origine dati. In caso contrario, puoi fare clic sul nodo **Trasformazione personalizzata** e scegliere la scheda **Proprietà del nodo**, quindi, in **Padri del nodo**, scegli l'origine dati.
1. Fai clic sul nodo **Trasformazione personalizzata** nel grafico visivo, quindi scegli la scheda **Proprietà del nodo** e assegna un nome alla trasformazione personalizzata. Ti consigliamo di rinominare la trasformazione assegnandole un nome facilmente identificabile nel grafico visivo.
1. Scegli la scheda **Trasforma**, dove puoi modificare il blocco di codice. Qui è possibile aggiungere il codice per richiamare l' FindMatches API.
![\[La schermata mostra il blocco di codice nella scheda Trasforma quando è selezionato il nodo Trasformazione personalizzata.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/custom-transform-code-block.png)
Il blocco di codice contiene codice precompilato per aiutarti a iniziare. Sovrascrivi il codice precompilato con il modello seguente. Il modello ha un segnaposto per **transformId**, che puoi sostituire con il tuo valore.
```
def MyTransform (glueContext, dfc) -> DynamicFrameCollection:
dynf = dfc.select(list(dfc.keys())[0])
from awsglueml.transforms import FindMatches
findmatches = FindMatches.apply(frame = dynf, transformId = "")
return(DynamicFrameCollection({"FindMatches": findmatches}, glueContext))
```
1. Fai clic sul nodo **Trasformazione personalizzata** nel grafico visivo, quindi apri il pannello Risorse facendo clic sul simbolo della croce nell'angolo in alto a sinistra del grafico visivo del processo e cerca "Seleziona dalla raccolta". Non è necessario modificare la selezione predefinita poiché ce n'è solo una DynamicFrame nella raccolta.
1. È possibile continuare ad aggiungere trasformazioni o archiviare il risultato, che ora è arricchito con le colonne aggiuntive delle corrispondenze trovate. Se vuoi fare riferimento a quelle nuove colonne nelle trasformazioni a valle, devi aggiungerle allo schema di output della trasformazione. Il modo più semplice per farlo è scegliere la scheda **Anteprima dati** e quindi, nella scheda Schema, scegliere "Utilizza schema di anteprima dati".
1. Per personalizzare FindMatches, puoi aggiungere parametri aggiuntivi da passare al metodo 'applica'. Vedi [FindMatches classe](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-findmatches.html).
## Aggiungere una trasformazione FindMatches incrementale
Nel caso di corrispondenze incrementali, il processo è lo stesso dell'**aggiunta di una FindMatches trasformazione** con le seguenti differenze:
+ Per la trasformazione personalizzata sono necessari due nodi padri anziché un solo nodo.
+ Il primo nodo padre dovrebbe essere il set di dati.
+ Il secondo nodo padre dovrebbe essere il set di dati incrementale.
Sostituisci il valore `transformId` con il tuo `transformId` nel blocco di codice del modello:
```
def MyTransform (glueContext, dfc) -> DynamicFrameCollection:
dfs = list(dfc.values())
dynf = dfs[0]
inc_dynf = dfs[1]
from awsglueml.transforms import FindIncrementalMatches
findmatches = FindIncrementalMatches.apply(existingFrame = dynf, incrementalFrame = inc_dynf,
transformId = "")
return(DynamicFrameCollection({"FindMatches": findmatches}, glueContext))
```
+ Per i parametri opzionali, vedete [FindIncrementalMatches class](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-findincrementalmatches.html).
# Esegui la migrazione dei programmi Apache Spark a AWS Glue
Apache Spark è una piattaforma open source per carichi di lavoro di calcolo distribuiti eseguiti su set di dati di grandi dimensioni. AWS Glue sfrutta le capacità di Spark per fornire un'esperienza ottimizzata per ETL. Puoi migrare i programmi Spark per sfruttare AWS Glue le nostre funzionalità. AWS Glue offre gli stessi miglioramenti delle prestazioni che ti aspetteresti da Apache Spark su Amazon EMR.
## Esegui codice Spark
Il codice Spark nativo può essere eseguito in un AWS Glue ambiente pronto all'uso. Gli script sono spesso sviluppati modificando iterativamente un pezzo di codice, un flusso di lavoro adatto per una sessione interattiva. Tuttavia, il codice esistente è più adatto all'esecuzione in un AWS Glue job, il che consente di pianificare e ottenere in modo coerente log e metriche per ogni esecuzione di script. Puoi caricare e modificare uno script esistente tramite la console.
1. Acquisisci la fonte del tuo script. Per questo esempio, si utilizzerà uno script di esempio dal repository Apache Spark. [Esempio di Binarizer](https://github.com/apache/spark/blob/master/examples/src/main/python/ml/binarizer_example.py)
1. ****Nella AWS Glue console, espandi il riquadro di navigazione a sinistra e seleziona ETL > Jobs****
Nel panello **Create job** (crea processo), seleziona **Spark script editor** (editor di script di Spark). Apparirà una sezione **Options** (opzioni). Sotto **Options** (opzioni) , seleziona **Upload and edit an existing script** (carica e modifica uno script esistente).
Apparirà una sezione **File upload** (caricamento file). Sotto a **File upload** (caricamento file), fai clic su **Choose file** (seleziona file). Apparirà il tuo selettore di file di sistema. Accedi al percorso in cui hai effettuato il salvataggio di `binarizer_example.py`, selezionalo e conferma della selezione.
Verrà visualizzato un pulsante **Create** (crea) nell’intestazione del pannello **Create job** (crea processo). Fai clic sul pulsante.
![\[La pagina AWS Glue Studio Jobs con il riquadro dell'editor di script Spark selezionato.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/migrate-apache-spark-01-upload-job.png)
1. Il tuo browser accederà all'editor di script. Nell'intestazione, fai clic sul sulla scheda **Job details** (dettagli processo). Imposta il **Nome** e il **Ruolo IAM**. Per indicazioni sui ruoli AWS Glue IAM, consulta[Configurazione delle autorizzazioni IAM per AWS Glue](set-up-iam.md).
Facoltativo: imposta **Requested number of workers (numero di worker richiesti)** su `2` e **Number of retries (numero di tentativi)** su `1`. Queste opzioni sono utili quando si eseguono lavori di produzione, ma la loro riduzione semplificherà la tua esperienza durante il test di una funzionalità.
Nella barra del titolo, fai clic su **Save (salva)**, quindi **Run (esegui)**
![\[La pagina dei dettagli del processo con le opzioni impostate come indicato.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/migrate-apache-spark-02-job-details.png)
1. Passa alla scheda **Runs** (esecuzioni). Vedrai un pannello corrispondente all’esecuzione del processo. Attendi alcuni minuti e la pagina dovrebbe essere aggiornata automaticamente per mostrare **Succeeded** (elaborazione riuscita) sotto a **Run status** (stato dell’esecuzione).
![\[La pagina delle esecuzioni del processo con un'esecuzione riuscita.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/migrate-apache-spark-03-job-runs.png)
1. Dovrai esaminare l’output per confermare che lo script Spark è stato eseguito come previsto. Questo script di esempio di Apache Spark dovrebbe scrivere una stringa nel flusso di output. Puoi trovarlo navigando su **Output logs** (registri di output) sotto a **Cloudwatch logs**(registri di Cloudwatch) nel pannello dell'esecuzione del processo riuscito. Ricorda l'id di esecuzione del processo, un id generato sotto l’etichetta **Id** che inizia con `jr_`.
Si aprirà la CloudWatch console, impostata per visualizzare il contenuto del gruppo di AWS Glue log predefinito`/aws-glue/jobs/output`, filtrato in base al contenuto dei flussi di log per l'ID di esecuzione del processo. Ogni worker avrà generato un flusso di log, mostrato in righe sotto **Log streams (Flussi di log)**. Un worker dovrebbe aver eseguito il codice richiesto. Sarà necessario aprire tutti i flussi di log per identificare il worker corretto. Una volta trovato il worker giusto, dovresti vedere l'output dello script, come mostrato nell'immagine seguente:
![\[La pagina della CloudWatch console con l'output del programma Spark.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/migrate-apache-spark-04-log-output.png)
## Procedure comuni necessarie per la migrazione dei programmi Spark
### Convalida il supporto della versione di Spark
AWS Glue le versioni di rilascio definiscono la versione di Apache Spark e Python disponibile per il job. AWS Glue Puoi trovare AWS Glue le nostre versioni e il loro supporto all'indirizzo. [AWS Glue versioni](release-notes.md#release-notes-versions) Potrebbe essere necessario aggiornare il programma Spark per renderlo compatibile con una versione più recente di Spark per accedere a determinate caratteristiche di AWS Glue .
### Includi librerie di terze parti
Molti programmi Spark esistenti avranno dipendenze, sia da artefatti privati che pubblici. AWS Glue supporta le dipendenze in stile JAR per processi Scala così come le dipendenze Wheel e pure-Python per i processi Python.
**Python **: per informazioni sulle dipendenze Python, consulta [Usare le librerie Python con Glue AWS](aws-glue-programming-python-libraries.md)
[Le dipendenze Python comuni sono fornite nell' AWS Glue ambiente, inclusa la libreria Pandas comunemente richiesta.](https://pandas.pydata.org/) Le dipendenze sono incluse in AWS Glue versione 2.0\$1. Per ulteriori informazioni sui moduli disponibili, consulta [Moduli Python già forniti in Glue AWS](aws-glue-programming-python-libraries.md#glue-modules-provided). Se è necessario fornire un processo con una versione diversa da quella di una dipendenza inclusa per impostazione predefinita, è possibile utilizzare `--additional-python-modules`. Per informazioni su questi argomenti, consulta [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md).
È possibile fornire dipendenze Python aggiuntive con l’argomento del processo `--extra-py-files`. Se state migrando un job da un programma Spark, questo parametro è una buona opzione perché è funzionalmente equivalente al `--py-files` flag in ed è soggetto alle stesse PySpark limitazioni. Per ulteriori informazioni sul parametro `--extra-py-files`, consulta [Inclusione di file Python con funzionalità native PySpark](aws-glue-programming-python-libraries.md#extra-py-files-support).
Per i nuovi processi, è possibile gestire le dipendenze Python con l’argomento del processo `--additional-python-modules`. L'utilizzo di questo argomento consente un'esperienza di gestione delle dipendenze più approfondita. Questo parametro supporta le dipendenze dello stile Wheel, incluse quelle con associazioni di codice native compatibili con Amazon Linux 2.
**Scala**
È possibile fornire dipendenze Scala aggiuntive con l’argomento del processo `--extra-jars`. Le dipendenze devono essere ospitate in Amazon S3 e il valore dell'argomento deve essere un elenco delimitato da virgole di percorsi Amazon S3 senza spazi. Potresti trovare più semplice gestire la configurazione riorganizzando le dipendenze prima di ospitarle e configurarle. AWS Glue Le dipendenze JAR contengono bytecode Java, che può essere generato da qualsiasi linguaggio JVM. È possibile utilizzare altri linguaggi JVM, come Java, per scrivere dipendenze personalizzate.
### Gestisci le credenziali dell'origine dei dati.
I programmi Spark esistenti possono avere una configurazione complessa o personalizzata per estrarre dati dalle loro origini dati. I flussi di autenticazione delle origini dati comuni sono supportati dalle connessioni. AWS Glue Per ulteriori informazioni sulle connessioni AWS Glue , consulta [Connessione ai dati](glue-connections.md).
AWS Glue le connessioni facilitano la connessione del Job a una varietà di tipi di archivi dati in due modi principali: tramite chiamate di metodo alle nostre librerie e impostando la **connessione di rete aggiuntiva** nella AWS console. Puoi anche chiamare l' AWS SDK dall'interno del tuo job per recuperare informazioni da una connessione.
**Chiamate di metodo**: AWS Glue le connessioni sono strettamente integrate con AWS Glue Data Catalog, un servizio che consente di gestire le informazioni sui set di dati, e i metodi disponibili per interagire con le connessioni lo riflettono. AWS Glue Se disponi di una configurazione di autenticazione esistente che desideri riutilizzare, per le connessioni JDBC, puoi accedere alla configurazione della AWS Glue connessione tramite il metodo su. `extract_jdbc_conf` `GlueContext` Per ulteriori informazioni, consulta [extract\$1jdbc\$1conf](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-extract_jdbc_conf)
**Configurazione della console**: i AWS Glue job utilizzano AWS Glue le connessioni associate per configurare le connessioni alle sottoreti Amazon VPC. Se gestisci direttamente i tuoi materiali di sicurezza, potrebbe essere necessario fornire un `NETWORK` tipo «**Connessione di rete aggiuntiva**» nella AWS console per configurare il routing. Per ulteriori informazioni sull’API di connessione AWS Glue , consulta [API Connessioni](aws-glue-api-catalog-connections.md).
Se i tuoi programmi Spark hanno un flusso di autenticazione personalizzato o non comune, potresti dover gestire i materiali di sicurezza in modo pratico. Se AWS Glue le connessioni non sembrano adatte, puoi ospitare in modo sicuro i materiali di sicurezza in Secrets Manager e accedervi tramite boto3 o AWS SDK, forniti nel job.
### Configurazione di Apache Spark
Le migrazioni complesse spesso alterano la configurazione di Spark per adattarsi ai loro carichi di lavoro. Le versioni moderne di Apache Spark consentono di impostare la configurazione di runtime con. `SparkSession` AWS Glue Sono disponibili oltre 3.0 job`SparkSession`, che possono essere modificati per impostare la configurazione di runtime. [Configurazione di Apache Spark](https://spark.apache.org/docs/latest/configuration.html). L'ottimizzazione di Spark è complessa e AWS Glue non garantisce il supporto per l'impostazione di tutte le configurazioni di Spark. Se la migrazione richiede una configurazione sostanziale a livello di Spark, contatta l'assistenza.
### Impostazione della configurazione personalizzata
I programmi Spark migrati possono essere progettati per accettare configurazioni personalizzate. AWS Glue consente di impostare la configurazione a livello di job e job run, tramite gli argomenti del job. Per informazioni su questi argomenti, consulta [Utilizzo dei parametri del lavoro nei lavori AWS Glue](aws-glue-programming-etl-glue-arguments.md). Puoi accedere agli argomenti relativi al lavoro nel contesto di un lavoro tramite le nostre librerie. AWS Glue fornisce una funzione di utilità per fornire una visualizzazione coerente tra gli argomenti impostati nel job e gli argomenti impostati durante l'esecuzione del job. Consulta [Accesso ai parametri utilizzando `getResolvedOptions`](aws-glue-api-crawler-pyspark-extensions-get-resolved-options.md) in Python e [AWS GlueScala GlueArgParser APIs](glue-etl-scala-apis-glue-util-glueargparser.md) in Scala.
### Migrazione del codice Java
Come spiegato in [Includi librerie di terze parti](#glue-author-migrate-apache-spark-third-party-libraries), le dipendenze possono contenere classi generate da linguaggi JVM, come Java o Scala. Le dipendenze possono includere un metodo `main`. È possibile utilizzare un `main` metodo in una dipendenza come punto di ingresso per un AWS Glue processo Scala. Questo permette di scrivere il proprio metodo `main` in Java o riutilizzare un metodo `main` elaborato in pacchetti secondo gli standard della tua libreria.
Per utilizzare un metodo `main` da una dipendenza, esegui le seguenti operazioni: cancella il contenuto del riquadro di modifica fornendo il valore predefinito dell’oggetto `GlueApp`. Fornisci il nome completo di una classe in una dipendenza come argomento di processo con la chiave`--class`. A questo punto dovresti essere in grado di attivare un’esecuzione del processo.
Non è possibile configurare l'ordine o la struttura degli argomenti passati al AWS Glue metodo. `main` Se il codice esistente deve leggere la configurazione impostata AWS Glue, ciò potrebbe causare incompatibilità con il codice precedente. Se utilizzi `getResolvedOptions`, non avrai nemmeno un luogo ideale per chiamare questo metodo. Prendi in considerazione la possibilità di invocare la tua dipendenza direttamente da un metodo principale generato da AWS Glue. Il seguente script AWS Glue ETL ne mostra un esempio.
```
import com.amazonaws.services.glue.util.GlueArgParser
object GlueApp {
def main(sysArgs: Array[String]) {
val args = GlueArgParser.getResolvedOptions(sysArgs, Seq("JOB_NAME").toArray)
// Invoke static method from JAR. Pass some sample arguments as a String[], one defined inline and one taken from the job arguments, using getResolvedOptions
com.mycompany.myproject.MyClass.myStaticPublicMethod(Array("string parameter1", args("JOB_NAME")))
// Alternatively, invoke a non-static public method.
(new com.mycompany.myproject.MyClass).someMethod()
}
}
```
# Lavorare con Ray Jobs in AWS Glue
**Importante**
AWS Glue for Ray non sarà più aperto a nuovi clienti a partire dal 30 aprile 2026. Se desideri utilizzarlo AWS Glue per Ray, registrati prima di tale data. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per funzionalità simili a for AWS Glue for Ray, esplora Amazon EKS. Per ulteriori informazioni, consulta [AWS Glue Ray End of Support](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
Questa sezione fornisce informazioni sull'utilizzo AWS Glue per i lavori Ray. Per ulteriori informazioni sulla scrittura di script AWS Glue per Ray, consulta la [Script di programmazione Ray](aws-glue-programming-ray.md) sezione.
**Topics**
+ [Guida introduttiva AWS Glue per Ray](#author-job-ray-using)
+ [Ambienti di runtime Ray supportati](#author-job-ray-runtimes)
+ [Contabilità per i worker nei processi Ray](#author-job-ray-worker-accounting)
+ [Utilizzo dei parametri di processo nei processi Ray](author-job-ray-job-parameters.md)
+ [Monitoraggio dei processi di Ray con i parametri](author-job-ray-monitor.md)
## Guida introduttiva AWS Glue per Ray
Per lavorare con AWS Glue for Ray, usi gli stessi AWS Glue job e le stesse sessioni interattive che usi AWS Glue per Spark. AWS Glue i job sono progettati per eseguire lo stesso script con una cadenza ricorrente, mentre le sessioni interattive sono progettate per consentire di eseguire frammenti di codice in sequenza sulle stesse risorse assegnate.
AWS Glue ETL e Ray sono fondamentalmente diversi, quindi nello script è possibile accedere a diversi strumenti, funzionalità e configurazioni. Essendo un nuovo framework di calcolo gestito da AWS Glue, Ray ha un'architettura diversa e utilizza un vocabolario diverso per descrivere ciò che fa. Per ulteriori informazioni, consulta [Whitepaper sull'architettura](https://docs.ray.io/en/latest/ray-contribute/whitepaper.html) nella documentazione di Ray.
**Nota**
AWS Glue for Ray è disponibile negli Stati Uniti orientali (Virginia settentrionale), Stati Uniti orientali (Ohio), Stati Uniti occidentali (Oregon), Asia Pacifico (Tokyo) ed Europa (Irlanda).
### Ray Jobs nella console AWS Glue Studio
Nella pagina **Lavori** della AWS Glue Studio console, puoi selezionare una nuova opzione quando crei un lavoro in AWS Glue Studio: **Ray script editor**. Scegli questa opzione per creare un processo Ray nella console. Per ulteriori informazioni sui processi e sul relativo utilizzo, consulta la pagina [Creazione di processi ETL visivi](author-job-glue.md).
![\[Viene visualizzata la pagina Jobs AWS Glue Studio con l'opzione Ray Script Editor selezionata.\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/ray_job_setup.png)
### Lavori Ray nell'SDK AWS CLI e
I lavori Ray in AWS CLI uso utilizzano le stesse azioni e parametri SDK degli altri job. AWS Glue for Ray introduce nuovi valori per determinati parametri. Per ulteriori informazioni sull'API Processi, consulta la pagina [Jobs](aws-glue-api-jobs-job.md).
## Ambienti di runtime Ray supportati
Nei processi Spark, `GlueVersion` determina le versioni di Apache Spark e Python disponibili in un processo AWS Glue per Spark. La versione di Python indica la versione supportata per i processi di tipo Spark. Questo non è il modo in cui sono configurati gli ambienti di runtime Ray.
Per i processi Ray, è necessario impostare `GlueVersion` su `4.0` o superiore. Tuttavia, le versioni di Ray, Python e le librerie aggiuntive disponibili nel processo Ray sono determinate dal campo `Runtime` nella definizione del processo.
L'ambiente di runtime `Ray2.4` sarà disponibile per un minimo di 6 mesi dopo il rilascio. Di pari passo con la rapida evoluzione di Ray, potrai incorporare aggiornamenti e miglioramenti di Ray nelle future versioni dell'ambiente di runtime.
Valori validi: `Ray2.4`
| Valore di runtime | Versioni di Ray e Python |
| --- | --- |
| Ray2.4 (per AWS Glue 4.0 e versioni successive) | Ray 2.4.0 Python 3.9 |
**Informazioni aggiuntive**
+ Per le note di rilascio che accompagnano AWS Glue le versioni di Ray, vedi[AWS Glue versioni](release-notes.md#release-notes-versions).
+ Per le librerie Python disponibili in un ambiente di runtime, consulta la pagina [Moduli disponibili con i processi Ray](edit-script-ray-env-dependencies.md#edit-script-ray-modules-provided).
## Contabilità per i worker nei processi Ray
AWS Glue esegue lavori Ray su nuovi tipi di worker EC2 basati su Graviton, disponibili solo per i lavori Ray. Per fornire in modo appropriato questi worker per i carichi di lavoro per cui Ray è progettato, forniamo un rapporto diverso tra risorse di calcolo e risorse di memoria rispetto alla maggior parte dei worker. Per tenere conto di queste risorse, utilizziamo l'unità di elaborazione dati ottimizzata per la memoria (M-DPU) anziché l'unità di elaborazione dati standard (DPU).
+ Una M-DPU corrisponde a 4 v CPUs e 32 GB di memoria.
+ Una DPU corrisponde a 4 v CPUs e 16 GB di memoria. DPUs vengono utilizzati per contabilizzare le risorse relative AWS Glue ai job Spark e ai lavoratori corrispondenti.
I processi Ray attualmente hanno accesso a un tipo di worker, `Z.2X`. Il `Z.2X` worker esegue la mappatura su 2 M- DPUs (8 vCPUs, 64 GB di memoria) e dispone di 128 GB di spazio su disco. Una macchina `Z.2X` fornisce 8 worker Ray (uno per vCPU).
Il numero di M- DPUs che è possibile utilizzare contemporaneamente in un account è soggetto a una quota di servizio. Per ulteriori informazioni sui limiti del tuo AWS Glue account, consulta [AWS Glue endpoint e quote](https://docs.aws.amazon.com/general/latest/gr/glue.html).
Nella definizione del processo si specifica il numero di nodi worker disponibili per un processo Ray con `--number-of-workers (NumberOfWorkers)`. Per ulteriori informazioni sui valori di Ray nell'API Processi, consulta la pagina [Jobs](aws-glue-api-jobs-job.md).
È possibile specificare ulteriormente un numero minimo di worker che un processo Ray deve allocare con il parametro di processo `--min-workers`. Per ulteriori informazioni sui parametri di processo, consulta [Documentazione di riferimento](author-job-ray-job-parameters.md#author-job-ray-parameters-reference).
# Utilizzo dei parametri di processo nei processi Ray
**Importante**
AWS Glue for Ray non sarà più aperto a nuovi clienti a partire dal 30 aprile 2026. Se desideri utilizzarlo AWS Glue per Ray, registrati prima di tale data. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per funzionalità simili a for AWS Glue for Ray, esplora Amazon EKS. Per ulteriori informazioni, consulta [AWS Glue Ray End of Support](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
Gli argomenti per i lavori AWS Glue Ray vengono impostati nello stesso modo in cui si impostano gli argomenti AWS Glue per i lavori Spark. Per ulteriori informazioni sull' AWS Glue API, consulta[Jobs](aws-glue-api-jobs-job.md). È possibile configurare i lavori AWS Glue Ray con diversi argomenti, elencati in questo riferimento. È anche possibile fornire i propri argomenti.
È possibile configurare un processo tramite la console, nella scheda **Job details** (Dettagli del processo), sotto l'intestazione **Job Parameters** (Parametri del processo). È inoltre possibile configurare un lavoro tramite AWS CLI `DefaultArguments` impostando un lavoro o impostando l'`Arguments`esecuzione di un lavoro. Gli argomenti e i parametri dei processi predefiniti resteranno gli stessi nel processo anche dopo più esecuzioni.
Ad esempio, la seguente è la sintassi per l'esecuzione di un processo utilizzando `--arguments` per impostare un parametro speciale.
```
$ aws glue start-job-run --job-name "CSV to CSV" --arguments='--scriptLocation="s3://my_glue/libraries/test_lib.py",--test-environment="true"'
```
Dopo aver impostato gli argomenti, è possibile accedere ai parametri di processo dall'interno del processo Ray tramite le variabili di ambiente. Questo ti consente di configurare il processo per ogni esecuzione. Il nome della variabile di ambiente sarà il nome dell'argomento del processo senza il prefisso `--`.
Ad esempio, nell'esempio precedente, i nomi delle variabili sarebbero `scriptLocation` e `test-environment`. Pertanto, l'argomento dovrebbe essere recuperato tramite i metodi disponibili nella libreria standard: `test_environment = os.environ.get('test-environment')`. Per ulteriori informazioni sull'accesso alle variabili di ambiente con Python, consulta la sezione [OS module](https://docs.python.org/3/library/os.html) nella documentazione di Python.
## Configurazione delle modalità di generazione dei log da parte dei processi Ray
Per impostazione predefinita, i lavori Ray generano log e metriche che vengono inviati ad Amazon CloudWatch S3. È possibile utilizzare il parametro `--logging_configuration` per modificare la modalità di generazione dei log; attualmente è possibile utilizzarlo per impedire ai processi Ray di generare vari tipi di log. Questo parametro accetta un oggetto JSON, le cui chiavi corrispondono a quelle logs/behaviors che desideri modificare. Supporta le seguenti chiavi:
+ `CLOUDWATCH_METRICS`— Configura serie di CloudWatch metriche che possono essere utilizzate per visualizzare lo stato del lavoro. Per ulteriori informazioni sui parametri, consulta [Monitoraggio dei processi di Ray con i parametri](author-job-ray-monitor.md).
+ `CLOUDWATCH_LOGS`— Configura i CloudWatch log che forniscono dettagli a livello di applicazione Ray sullo stato di esecuzione del job. Per ulteriori informazioni sui log, consulta [Risoluzione dei problemi relativi AWS Glue agli errori di Ray nei log](troubleshooting-ray.md).
+ `S3`— Configura ciò che viene AWS Glue scritto su Amazon S3, principalmente informazioni CloudWatch simili nei log ma come file anziché come flussi di log.
Per disabilitare un comportamento di registrazione di Ray, fornisci il valore `{\"IS_ENABLED\": \"False\"}`. Ad esempio, per disabilitare CloudWatch metriche e CloudWatch log, fornisci la seguente configurazione:
```
"--logging_configuration": "{\"CLOUDWATCH_METRICS\": {\"IS_ENABLED\": \"False\"}, \"CLOUDWATCH_LOGS\": {\"IS_ENABLED\": \"False\"}}"
```
## Documentazione di riferimento
I processi Ray riconoscono i seguenti nomi di argomenti che possono essere utilizzati per configurare l'ambiente di script per i processi Ray e le esecuzioni di processo:
+ `--logging_configuration`: viene utilizzato per interrompere la generazione di vari log creati dai processi Ray. Questi log vengono generati per impostazione predefinita su tutti i processi Ray. Formato: oggetto JSON con escape di stringhe. Per ulteriori informazioni, consulta [Configurazione delle modalità di generazione dei log da parte dei processi Ray](#author-job-ray-logging-configuration).
+ `--min-workers`: il numero minimo di nodi worker allocati a un processo Ray. Un nodo worker può eseguire più repliche, una per CPU virtuale. Formato: numero intero. Minimo: 0 Massimo: valore specificato in `--number-of-workers (NumberOfWorkers)` nella definizione di processo. Per ulteriori informazioni su come allocare adeguatamente i nodi worker, consulta la pagina [Contabilità per i worker nei processi Ray](ray-jobs-section.md#author-job-ray-worker-accounting).
+ `--object_spilling_config`— AWS Glue for Ray supporta l'utilizzo di Amazon S3 per estendere lo spazio disponibile per l'object store di Ray. Per abilitare questo comportamento, è possibile fornire a Ray un oggetto di configurazione JSON per il *riversamento di oggetti* con questo parametro. Per ulteriori informazioni sulla configurazione del riversamento di oggetti in Ray, consulta la pagina [Object Spilling](https://docs.ray.io/en/latest/ray-core/objects/object-spilling.html) nella documentazione di Ray. Formato: oggetto JSON.
AWS Glue for Ray supporta solo la fuoriuscita su disco o la trasmissione su Amazon S3 contemporaneamente. È possibile fornire più punti di riversamento, purché rispettino questa limitazione. In caso di riversamento su Amazon S3, sarà necessario aggiungere al processo anche le autorizzazioni IAM per questo bucket.
Quando si fornisce un oggetto JSON come configurazione con la CLI, è necessario fornirlo come stringa, specificando l'oggetto JSON con escape di stringa. Ad esempio, un valore di stringa per il riversamento su un percorso Amazon S3 apparirebbe come: `"{\"type\": \"smart_open\", \"params\": {\"uri\":\"s3path\"}}"`. In AWS Glue Studio, fornisci questo parametro come oggetto JSON senza formattazioni aggiuntive.
+ `--object_store_memory_head`: la memoria allocata all'archivio di oggetti Plasma sul nodo principale di Ray. Questa istanza esegue i servizi di gestione dei cluster e le repliche dei worker. Il valore rappresenta una percentuale di memoria libera sull'istanza dopo un avvio a caldo. Questo parametro viene utilizzato per ottimizzare i carichi di lavoro che richiedono un uso intensivo della memoria: i valori predefiniti sono accettabili per la maggior parte dei casi d'uso. Formato: numero intero positivo. Minimo: 1. Massimo: 100
Per ulteriori informazioni su Plasma, consulta [L'archivio oggetti in memoria di Plasma](https://ray-project.github.io/2017/08/08/plasma-in-memory-object-store.html) nella documentazione di Ray.
+ `--object_store_memory_worker`: la memoria allocata all'archivio di oggetti Plasma sui nodi worker di Ray. Queste istanze eseguono solo repliche worker. Il valore rappresenta una percentuale di memoria libera sull'istanza dopo un avvio a caldo. Questo parametro viene utilizzato per ottimizzare i carichi di lavoro che richiedono un uso intensivo della memoria: i valori predefiniti sono accettabili per la maggior parte dei casi d'uso. Formato: numero intero positivo. Minimo: 1. Massimo: 100
Per ulteriori informazioni su Plasma, consulta [L'archivio oggetti in memoria di Plasma](https://ray-project.github.io/2017/08/08/plasma-in-memory-object-store.html) nella documentazione di Ray.
+ `--pip-install`: un set di pacchetti Python da installare. È possibile installare pacchetti da PyPI utilizzando questo argomento. Formato: elenco delimitato da virgole.
Una voce del pacchetto PyPI sarà nel formato `package==version`, con il nome e la versione di PyPI del pacchetto di destinazione. Le voci usano la corrispondenza della versione Python per abbinare il pacchetto e la versione, come `==`, non il singolo uguale a `=`. Esistono altri operatori di corrispondenza delle versioni. Per ulteriori informazioni, consulta [PEP 440](https://peps.python.org/pep-0440/#version-matching) sul sito Web di Python. È inoltre possibile fornire moduli personalizzati con `--s3-py-modules`.
+ `--s3-py-modules`: un set di percorsi Amazon S3 che ospitano le distribuzioni di moduli Python. Formato: elenco delimitato da virgole.
Puoi utilizzarlo per distribuire i tuoi moduli al tuo processo di Ray. I moduli possono essere forniti anche da PyPI con `--pip-install`. A differenza di AWS Glue ETL, i moduli personalizzati non vengono configurati tramite pip, ma vengono passati a Ray per la distribuzione. Per ulteriori informazioni, consulta [Moduli Python aggiuntivi per i processi Ray](edit-script-ray-env-dependencies.md#edit-script-ray-python-libraries-additional).
+ `--working-dir`: un percorso verso un file .zip ospitato in Amazon S3 che contiene file da distribuire a tutti i nodi che eseguono il processo Ray. Formato: stringa. Per ulteriori informazioni, consulta [Fornitura di file al processo Ray](edit-script-ray-env-dependencies.md#edit-script-ray-working-directory).
# Monitoraggio dei processi di Ray con i parametri
**Importante**
AWS Glue for Ray non sarà più aperto a nuovi clienti a partire dal 30 aprile 2026. Se desideri utilizzarlo AWS Glue per Ray, registrati prima di tale data. I clienti esistenti possono continuare a utilizzare il servizio normalmente. Per funzionalità simili a for AWS Glue for Ray, esplora Amazon EKS. Per ulteriori informazioni, consulta [AWS Glue Ray End of Support](https://docs.aws.amazon.com/glue/latest/dg/awsglue-ray-jobs-availability-change.html).
Puoi monitorare i lavori Ray utilizzando AWS Glue Studio e Amazon CloudWatch. CloudWatch raccoglie ed elabora le metriche non elaborate AWS Glue con Ray, che le rende disponibili per l'analisi. Queste metriche vengono visualizzate nella AWS Glue Studio console, in modo da poter monitorare il lavoro mentre viene eseguito.
Per una panoramica generale su come monitorare AWS Glue, consulta. [Monitoraggio AWS Glue tramite CloudWatch parametri Amazon](monitoring-awsglue-with-cloudwatch-metrics.md) Per una panoramica generale su come utilizzare le CloudWatch metriche pubblicate da AWS Glue, consulta[Monitoraggio con Amazon CloudWatch](monitor-cloudwatch.md).
## Monitoraggio dei job di Ray nella console AWS Glue
Nella pagina dei dettagli dell'esecuzione di un lavoro, sotto la sezione **Dettagli dell'esecuzione**, puoi visualizzare grafici aggregati predefiniti che visualizzano le metriche dei job disponibili. AWS Glue Studio invia le metriche dei job a per ogni job eseguito. CloudWatch Con questi, è possibile creare un profilo del cluster e delle attività, nonché accedere a informazioni dettagliate su ciascun nodo.
Per ulteriori informazioni sui grafici di parametri disponibili, consulta [Visualizzazione delle Amazon CloudWatch metriche per l'esecuzione di un job Ray](view-job-runs.md#monitoring-job-run-metrics-ray).
## Panoramica delle metriche di Ray Jobs in CloudWatch
Pubblichiamo le metriche Ray quando è abilitato il monitoraggio dettagliato. CloudWatch Le metriche vengono pubblicate nel namespace. `Glue/Ray` CloudWatch
+ **Parametri dell'istanza**
Pubblichiamo i parametri sull'utilizzo della CPU, della memoria e del disco delle istanze assegnate a un processo. Questi parametri sono identificati da funzionalità quali `ExecutorId`, `ExecutorType` e `host`. Queste metriche sono un sottoinsieme delle metriche standard degli agenti Linux. CloudWatch Puoi trovare informazioni sui nomi e le funzionalità delle metriche nella documentazione. CloudWatch Per ulteriori informazioni, consulta [Metriche raccolte dall' CloudWatch agente](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/metrics-collected-by-CloudWatch-agent.html).
+ **Parametri del cluster Ray**
Inoltriamo i parametri dai processi Ray che eseguono lo script a questo spazio dei nomi, quindi ti trasmettiamo quelli più rilevanti per te. I parametri disponibili potrebbero differire in base alla versione di Ray. Per ulteriori informazioni sulla versione di Ray utilizzata dal processo, consulta [AWS Glue versioni](release-notes.md).
Ray raccoglie i parametri a livello di istanza. Inoltre, fornisce parametri per le attività e il cluster. Per ulteriori informazioni sulla strategia dei parametri di base di Ray, consulta la pagina [Metrics](https://docs.ray.io/en/latest/ray-observability/ray-metrics.html#system-metrics) nella documentazione di Ray.
**Nota**
Non pubblichiamo i parametri Ray nello spazio dei nomi `Glue/Job Metrics/`; questo viene utilizzato solo per i processi AWS Glue ETL.
# Configurazione delle proprietà del processo per i processi shell di Python in AWS Glue
Puoi utilizzare un processo shell di Python per eseguire gli script di Python come una shell in AWS Glue. Con un processo shell di Python puoi eseguire script compatibili con Python 3.6 o Python 3.9.
**Nota**
Il supporto per Pyshell v3.6 terminerà il 1° marzo 2026. Per migrare i carichi di lavoro, consulta [Migrare dai job della shell Python AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/pyshell-migration.html). Se desideri continuare con la shell di Python v3.9, consulta [Migrazione dalla shell 3.6 di Python alla 3.9](#migrating-version-pyshell36-to-pyshell39).
**Topics**
+ [Limitazioni](#python-shell-limitations)
+ [Ambiente di esecuzione](#python-shell-execution-environment)
+ [Definire le proprietà del processo per i processi shell di Python](#create-job-python-properties)
+ [Librerie supportate dai processi shell di Python](#python-shell-supported-library)
+ [Fornire la propria libreria Python](#create-python-extra-library)
+ [Utilizzabile AWS CloudFormation con i lavori della shell Python in AWS Glue](#python-shell-jobs-cloudformation)
+ [Migrazione dalla shell 3.6 di Python alla 3.9](#migrating-version-pyshell36-to-pyshell39)
+ [Migrazione dai job della AWS shell Glue Python](pyshell-migration.md)
## Limitazioni
Tieni presente le seguenti limitazioni dei processi shell Python:
+ Non è possibile utilizzare i segnalibri nei processi di shell di Python.
+ In Python 3.9 e versioni successive non puoi pacchettizzare alcuna libreria Python come file `.egg`. Utilizza invece `.whl`.
+ Per via di una limitazione sulle copie temporanee dei dati di S3, l'opzione `--extra-files` non può essere utilizzata.
## Ambiente di esecuzione
I job della shell Python vengono eseguiti in un ambiente di esecuzione gestito che fornisce l'accesso all'archiviazione locale per l'elaborazione temporanea dei dati:
**Archiviazione temporanea locale**
La `/tmp` directory è disponibile per l'archiviazione temporanea durante l'esecuzione del lavoro. Questa directory fornisce circa 14 GiB di spazio libero che è possibile utilizzare per:
+ Elaborazione di file temporanei
+ Archiviazione intermedia dei dati
+ Memorizzazione nella cache di piccoli set di dati
La `/tmp` directory è effimera e viene ripulita dopo il completamento del lavoro. Non utilizzarlo per l'archiviazione persistente di dati importanti.
## Definire le proprietà del processo per i processi shell di Python
Queste sezioni descrivono la definizione delle proprietà del lavoro nella AWS Glue Studio o l'utilizzo della AWS CLI.
### AWS Glue Studio
Quando definisci il processo della shell Python in AWS Glue Studio, fornisci alcune delle seguenti proprietà:
**Ruolo IAM**
Specificate il ruolo AWS Identity and Access Management (IAM) utilizzato per l'autorizzazione alle risorse utilizzate per eseguire il processo e accedere agli archivi dati. Per ulteriori informazioni sulle autorizzazioni per l'esecuzione di processi in AWS Glue, consulta [Gestione delle identità e degli accessi per AWS Glue](security-iam.md).
**Tipo**
Scegli **Python shell (Shell di Python)** per eseguire uno script Python con il comando di processo denominato `pythonshell`.
**Versione di Python**
Scegli la versione di Python. La versione predefinita è Python 3.9. Le versioni valide sono Python 3.6 e Python 3.9.
**Carica librerie di analisi comuni (scelta consigliata)**
Scegli questa opzione per includere le librerie comuni per Python 3.9 nella shell Python.
Se le tue librerie sono personalizzate o sono in conflitto con quelle preinstallate, puoi scegliere di non installare librerie comuni. Tuttavia, oltre alle librerie comuni puoi installare librerie aggiuntive.
Quando selezioni questa opzione, l'opzione `library-set` è impostata su `analytics`. Quando deselezioni questa opzione, l'opzione `library-set` è impostata su `none`.
**Nome file e percorso dello script**
Il codice nello script definisce la logica procedurale del processo. Puoi fornire il nome e la posizione dello script in Amazon Simple Storage Service (Amazon S3). Conferma che non esiste un file con lo stesso nome della directory di script nel percorso. Per ulteriori informazioni sull'uso degli script, consulta [AWS Glue guida alla programmazione](edit-script.md).
**Script**
Il codice nello script definisce la logica procedurale del processo. Puoi codificare lo script in Python 3.6 o Python 3.9. Puoi modificare uno script in AWS Glue Studio.
**Unità di elaborazione dati (DPU)**
Il numero massimo di unità di elaborazione AWS Glue dati (DPUs) che possono essere allocate durante l'esecuzione di questo processo. Una DPU è una misura relativa della potenza di elaborazione costituita da 4 V di capacità CPUs di elaborazione e 16 GB di memoria. Per ulteriori informazioni, consultare [Prezzi di AWS Glue](https://aws.amazon.com/glue/pricing/).
Puoi impostare il valore su 0,0625 o 1. Il valore predefinito è 0.0625. In entrambi i casi, il disco locale per l'istanza sarà di 20 GB.
### CLI
Puoi anche creare un job della **shell Python** usando AWS CLI, come nell'esempio seguente.
```
aws glue create-job --name python-job-cli --role Glue_DefaultRole
--command '{"Name" : "pythonshell", "PythonVersion": "3.9", "ScriptLocation" : "s3://amzn-s3-demo-bucket/scriptname.py"}'
--max-capacity 0.0625
```
**Nota**
Non devi specificare la versione di AWS Glue poiché il parametro `--glue-version` non si applica ai processi shell di AWS Glue. Qualsiasi versione specificata verrà ignorata.
Lavori che crei con l' AWS CLI impostazione predefinita di Python 3. Le versioni valide di Python sono 3 (corrispondenti a 3.6) e 3.9. Per specificare Python 3.6, aggiungi questa tupla al parametro `--command`: `"PythonVersion":"3"`
Per specificare Python 3.9, aggiungi questa tupla al parametro `--command`: `"PythonVersion":"3.9"`
Per impostare la capacità massima utilizzata da un processo shell di Python, fornire il parametro `--max-capacity`. Per i processi di shell di Python non è possibile utilizzare il parametro `--allocated-capacity`.
## Librerie supportate dai processi shell di Python
Nella shell Python con Python 3.9 puoi scegliere il set di librerie per utilizzare set di librerie preconfezionati per le tue esigenze. Puoi utilizzare l'opzione `library-set` per scegliere il set di librerie. I valori validi sono `analytics` e `none`.
L'ambiente per l'esecuzione di un processo shell di Python supporta le seguenti librerie:
| Versione di Python | Python 3.6 | Python 3.9 |
| --- | --- | --- |
| Set di librerie | N/D | analytics | nessuno |
| avro | | 1.11.0 | |
| awscli | 116,242 | 1,23,5 | 1,23,5 |
| awswrangler | | 2,15,1 | |
| botocore | 1,12.232 | 1,24,21 | 1,23,5 |
| boto3 | 1,9203 | 1,21,21 | |
| elasticsearch | | 8.2.0 | |
| numpy | 1,16,2 | 1.22.3 | |
| pandas | 0,24,2 | 1.4.2 | |
| psycopg2 | | 2,9,3 | |
| pyathena | | 2.5.3 | |
| PyGreSQL | 5.0.6 | | |
| PyMySQL | | 1.0.2 | |
| pyodbc | | 4.0.32 | |
| pyorc | | 0,6,0 | |
| redshift-connector | | 2.0,907 | |
| richieste | 2.22.0 | 2,27,1 | |
| scikit-learn | 0,20,3 | 1.0.2 | |
| scipy | 1.2.1 | 1.8.0 | |
| SQLAlchemy | | 1,4,36 | |
| s3fs | | 2022,3,0 | |
Puoi utilizzare la libreria `NumPy` in un processo shell di Python per il calcolo scientifico. Per ulteriori informazioni, consulta [NumPy](http://www.numpy.org). L'esempio seguente mostra uno NumPy script che può essere usato in un job della shell Python. Lo script visualizza "Hello world" e i risultati di numerosi calcoli matematici.
```
import numpy as np
print("Hello world")
a = np.array([20,30,40,50])
print(a)
b = np.arange( 4 )
print(b)
c = a-b
print(c)
d = b**2
print(d)
```
## Fornire la propria libreria Python
### Utilizzo di PIP
La shell Python che utilizza Python 3.9 consente di fornire moduli Python aggiuntivi o versioni diverse a livello di processo. Puoi utilizzare l'opzione `--additional-python-modules` con un elenco di moduli Python separati da virgole per aggiungere un nuovo modulo o modificare la versione di un modulo esistente. Non è possibile fornire moduli Python personalizzati ospitati su Amazon S3 con questo parametro quando si utilizzano processi di shell Python.
Ad esempio, per aggiornare o aggiungere un nuovo modulo `scikit-learn` usa la seguente coppia di chiave-valore: `"--additional-python-modules", "scikit-learn==0.21.3"`.
AWS Glue utilizza Python Package Installer (pip3) per installare i moduli aggiuntivi. Puoi passare opzioni pip3 aggiuntive all'interno del valore di `--additional-python-modules`. Ad esempio, `"scikit-learn==0.21.3 -i https://pypi.python.org/simple/"`. Si applicano eventuali incompatibilità o limitazioni da pip3.
**Nota**
Per evitare incompatibilità in futuro, si consiglia di utilizzare le librerie create per Python 3.9.
### Utilizzo di un file Egg o Whl
È possibile che uno o più pacchetti di librerie Python siano disponibili come un file `.whl` o `.egg`. In questo caso, puoi specificarli nel tuo processo utilizzando AWS Command Line Interface (AWS CLI) sotto il flag "`--extra-py-files`", come mostrato nell'esempio seguente.
```
aws glue create-job --name python-redshift-test-cli --role role --command '{"Name" : "pythonshell", "ScriptLocation" : "s3://MyBucket/python/library/redshift_test.py"}'
--connections Connections=connection-name --default-arguments '{"--extra-py-files" : ["s3://amzn-s3-demo-bucket/EGG-FILE", "s3://amzn-s3-demo-bucket/WHEEL-FILE"]}'
```
In caso di dubbi su come creare un file `.egg` o `.whl` da una libreria Python, utilizza la procedura seguente. Questo esempio si applica su sistemi macOS, Linux e Windows Subsystem for Linux (WSL).
**Per creare un file .egg o .whl Python**
1. Crea un cluster Amazon Redshift in un cloud privato virtuale (VPC, Virtual Private Cloud) e aggiungi alcuni dati a una tabella.
1. Crea una AWS Glue connessione per la VPC-SecurityGroup-Subnet combinazione che hai usato per creare il cluster. Verifica che la connessione funzioni.
1. Crea una directory denominata `redshift_example` e crea un file denominato `setup.py`. Incollare il codice seguente in `setup.py`.
```
from setuptools import setup
setup(
name="redshift_module",
version="0.1",
packages=['redshift_module']
)
```
1. Nella directory `redshift_example` crea una directory `redshift_module`. Nella directory `redshift_module` crea i file `__init__.py` e `pygresql_redshift_common.py`.
1. Lascia il file `__init__.py` vuoto. Incolla il codice seguente in `pygresql_redshift_common.py`. Sostituisci *port**db\$1name*,*user*, e *password\$1for\$1user* con dettagli specifici del tuo cluster Amazon Redshift. Sostituisci *table\$1name* con il nome della tabella in Amazon Redshift.
```
import pg
def get_connection(host):
rs_conn_string = "host=%s port=%s dbname=%s user=%s password=%s" % (
host, port, db_name, user, password_for_user)
rs_conn = pg.connect(dbname=rs_conn_string)
rs_conn.query("set statement_timeout = 1200000")
return rs_conn
def query(con):
statement = "Select * from table_name;"
res = con.query(statement)
return res
```
1. Se non sei ancora in tale directory, passa alla directory `redshift_example`.
1. Esegui una delle seguenti operazioni:
+ Per creare un file `.egg`, esegui il comando seguente.
```
python setup.py bdist_egg
```
+ Per creare un file `.whl`, esegui il comando seguente.
```
python setup.py bdist_wheel
```
1. Installa le dipendenze necessarie per il comando precedente.
1. Il comando crea un file nella directory `dist`:
+ Se hai creato un file egg, viene denominato `redshift_module-0.1-py2.7.egg`.
+ Se hai creato un file wheel, viene denominato `redshift_module-0.1-py2.7-none-any.whl`.
Carica questo file in Amazon S3.
In questo esempio, il percorso del file caricato è *s3://amzn-s3-demo-bucket/EGG-FILE* o *s3://amzn-s3-demo-bucket/WHEEL-FILE*.
1. Crea un file Python da utilizzare come script per il processo AWS Glue e aggiungi al file il codice seguente.
```
from redshift_module import pygresql_redshift_common as rs_common
con1 = rs_common.get_connection(redshift_endpoint)
res = rs_common.query(con1)
print "Rows in the table cities are: "
print res
```
1. Carica il file precedente in Amazon S3. In questo esempio, il percorso del file caricato è *s3://amzn-s3-demo-bucket/scriptname.py*.
1. Crea un processo shell di Python utilizzando questo script. Nella console AWS Glue, nella pagina **Job properties (Proprietà processo)**, specifica il percorso al file `.egg/.whl` nella casella **Python library path (Percorso libreria Python)**. Se sono presenti più file `.egg/.whl` e file Python, occorre fornire un elenco separato da virgole in questa casella.
Quando si modificano o si rinominano i file `.egg`, i nomi dei file devono utilizzare i nomi predefiniti generati dal comando "python setup.py bdist\$1egg" o devono rispettare le convenzioni di denominazione del modulo Python. Per ulteriori informazioni, vedere la [Guida di stile per il codice Python](https://www.python.org/dev/peps/pep-0008/).
Utilizzando AWS CLI, crea un lavoro con un comando, come nell'esempio seguente.
```
aws glue create-job --name python-redshift-test-cli --role Role --command '{"Name" : "pythonshell", "ScriptLocation" : "s3://amzn-s3-demo-bucket/scriptname.py"}'
--connections Connections="connection-name" --default-arguments '{"--extra-py-files" : ["s3://amzn-s3-demo-bucket/EGG-FILE", "s3://amzn-s3-demo-bucket/WHEEL-FILE"]}'
```
Quando il processo viene eseguito, lo script stampa le righe create nella *table\$1name* tabella nel cluster Amazon Redshift.
## Utilizzabile AWS CloudFormation con i lavori della shell Python in AWS Glue
È possibile utilizzare AWS CloudFormation con i job della shell Python in. AWS Glue Di seguito è riportato un esempio:
```
AWSTemplateFormatVersion: 2010-09-09
Resources:
Python39Job:
Type: 'AWS::Glue::Job'
Properties:
Command:
Name: pythonshell
PythonVersion: '3.9'
ScriptLocation: 's3://bucket/location'
MaxRetries: 0
Name: python-39-job
Role: RoleName
```
L'output del gruppo Amazon CloudWatch Logs per i job della shell Python è. `/aws-glue/python-jobs/output` Per gli errori, consulta il gruppo di log `/aws-glue/python-jobs/error`.
## Migrazione dalla shell 3.6 di Python alla 3.9
Per migrare i lavori della shell Python alla versione più recente: AWS Glue
1. Nella AWS Glue console ([https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/)), scegli il tuo job di shell Python esistente.
1. Nella scheda **Dettagli del processo**, imposta la versione di Python su `Python 3.9` e scegli **Salva**.
1. Assicurati che lo script del processo sia compatibile con Python 3.9 e che funzioni correttamente.
# Migrazione dai job della AWS shell Glue Python
AWS ha lanciato i job della shell AWS Glue Python nel 2018 AWS ha lanciato i lavori della shell Glue AWS Python nel 2018 per offrire ai clienti un modo semplice per eseguire script Python per lavori ETL di small-to-medium grandi dimensioni e per attivare query SQL. Tuttavia, ora esistono opzioni più moderne e flessibili per affrontare i carichi di lavoro attualmente in esecuzione. PythonShell Questo argomento spiega come migrare i carichi di lavoro dai job della shell Glue AWS Python a una di queste opzioni alternative per sfruttare le nuove funzionalità disponibili.
Questo argomento spiega come migrare dai job della shell AWS Glue Python a opzioni alternative.
## Migrazione del carico di lavoro verso i job AWS Glue Spark
[AWS Glue Spark e PySpark jobs](https://docs.aws.amazon.com/glue/latest/dg/spark_and_pyspark.html) ti consentono di eseguire i tuoi carichi di lavoro in modo distribuito. Poiché sia i job AWS Glue Python Shell che i job AWS Glue Spark vengono eseguiti sulla stessa piattaforma, la migrazione è facile e puoi continuare a utilizzare le funzionalità di Glue esistenti che usi con i job di Python Shell, come AWS Glue AWS Workflows, Glue AWS Triggers, l' Amazon EventBridge integrazione di Glue, l'installazione di pacchetti basata su\$1 PIP e così via. AWS
Tuttavia, i job AWS Glue Spark sono progettati per eseguire carichi di lavoro Spark e il numero minimo di lavoratori è 2. Se si effettua la migrazione dai processi shell di Python senza modificare gli script, verrà effettivamente utilizzato solo un worker e gli altri worker rimarranno inattivi. Questa operazione aumenterà i costi.
Per aumentare l'efficienza, occorre riscrivere lo script del processo di Python per utilizzare le funzionalità di Spark e distribuire il carico di lavoro tra più worker. Se lo script di Python si basa su Pandas, è facile eseguire la migrazione usando la nuova API Pandas su Spark. Scopri di più su questo argomento [nel blog AWS Big Data: approfondisci la conoscenza di AWS Glue 4.0 for Apache Spark](https://aws.amazon.com/blogs/big-data/dive-deep-into-aws-glue-4-0-for-apache-spark/).
## Migrazione del carico di lavoro a AWS Lambda
AWS Lambda è un servizio di elaborazione serverless che consente di eseguire codice senza effettuare il provisioning o la gestione di server. Poiché AWS Lambda offre tempi di startup inferiori e opzioni più flessibili per la capacità di elaborazione, è possibile beneficiare di questi vantaggi. Per gestire librerie Python aggiuntive, i processi shell di AWS Glue Python utilizzano l'installazione basata su PIP. Tuttavia, per AWS Lambda, devi scegliere una delle seguenti opzioni: un archivio zip, un'immagine del contenitore o Lambda Layers.
D'altra parte, il timeout massimo AWS Lambdaè di 900 secondi (15 minuti). Se la durata del tuo attuale carico di lavoro di AWS Glue Python Shell è superiore a quella, o se il tuo carico di lavoro presenta uno schema a picchi che può causare durate di lavoro più lunghe, ti consigliamo di esplorare altre opzioni invece di. AWS Lambda
## Migrazione del carico di lavoro su Amazon ECS/Fargate
Amazon Elastic Container Service (Amazon ECS) è un servizio completamente gestito che semplifica la distribuzione, la gestione e la scalabilità delle applicazioni containerizzate. AWS Fargate è un motore di elaborazione serverless per carichi di lavoro containerizzati in esecuzione su Amazon ECS e Amazon Elastic Kubernetes Service (Amazon EKS). Non è previsto un timeout massimo su Amazon ECS e Fargate, quindi questa è una buona opzione per i processi di lunga durata. Poiché si ha il pieno controllo sull'immagine del container, è possibile portare lo script Python e librerie Python supplementari nel container e usarle. Tuttavia, è necessario containerizzare lo script Python per utilizzare questo approccio.
## Migrazione del carico di lavoro verso Flussi di lavoro gestiti da Amazon per operatore Python di Apache Airflow
Amazon Managed Workflows for Apache Airflow (Managed Workflows for Apache Airflow) è un servizio di orchestrazione gestito per Apache Airflow che semplifica la configurazione e la gestione di pipeline di dati nel cloud su larga scala. end-to-end Se disponi già di un ambiente MWAA, sarà semplice utilizzare l'operatore Python anziché i job AWS Glue Python Shell. L'operatore Python è un operatore che esegue il codice Python all'interno di un flusso di lavoro Airflow. Tuttavia, se non si dispone di un ambiente MWAA esistente, consigliamo di valutare altre opzioni.
## Migrazione del carico di lavoro verso i lavori di formazione sull'intelligenza artificiale Amazon SageMaker AI
Amazon SageMaker AI La formazione è un servizio di machine learning (ML) completamente gestito offerto da Amazon SageMaker AI che consente di addestrare in modo efficiente un'ampia gamma di modelli di machine learning su larga scala. Il fulcro dei lavori di Amazon SageMaker AI intelligenza artificiale è la containerizzazione dei carichi di lavoro ML e la capacità di gestire AWS le risorse di elaborazione. Se preferisci un ambiente serverless in cui non è previsto un timeout massimo, i lavori di formazione sull' Amazon SageMaker AI intelligenza artificiale potrebbero essere la soluzione giusta per te. Tuttavia, la latenza di avvio tende ad essere più lunga rispetto ai job di Glue AWS Python Shell. Per i processi sensibili alla latenza, consigliamo di valutare altre opzioni.
# Monitoraggio AWS Glue
Il monitoraggio è un elemento importante per mantenere l'affidabilità, la disponibilità e le prestazioni delle AWS Glue altre AWS soluzioni. AWS fornisce strumenti di monitoraggio che è possibile utilizzare per osservare AWS Glue, segnalare quando qualcosa non va e agire automaticamente quando appropriato:
Per controllare AWS Glue e segnalare l'eventuale presenza di problemi, puoi usare gli strumenti di monitoraggio automatici seguenti:
+ **Amazon CloudWatch Events** offre un flusso quasi in tempo reale di eventi di sistema che descrivono i cambiamenti nelle AWS risorse. CloudWatch Events consente l'elaborazione automatizzata basata sugli eventi. È possibile scrivere regole che controllano determinati eventi e attivano azioni automatiche in altri AWS servizi quando si verificano tali eventi. Per ulteriori informazioni, consulta la [Amazon CloudWatch Events User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/).
+ **Amazon CloudWatch Logs** ti consente di monitorare, archiviare e accedere ai tuoi file di registro da EC2 istanze Amazon e altre fonti. AWS CloudTrail CloudWatch I log possono monitorare le informazioni contenute nei file di registro e avvisarti quando vengono raggiunte determinate soglie. Puoi inoltre archiviare i dati del log in storage estremamente durevole. Per ulteriori informazioni, consulta la [Amazon CloudWatch Logs User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/).
+ **AWS CloudTrail**acquisisce le chiamate API e gli eventi correlati effettuati da o per conto del tuo AWS account e invia i file di log a un bucket Amazon S3 da te specificato. Puoi identificare quali utenti e account effettuano le chiamate AWS, l'indirizzo IP di origine da cui vengono effettuate le chiamate e quando vengono effettuate le chiamate. Per ulteriori informazioni, consulta la [Guida per l'utente AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
Inoltre, hai accesso alle seguenti informazioni nella AWS Glue console per aiutarti a eseguire il debug e profilare i lavori:
+ Lavori Spark: puoi visualizzare una visualizzazione di serie di CloudWatch metriche selezionate e i lavori più recenti hanno accesso all'interfaccia utente di Spark. Per ulteriori informazioni, consulta [Monitoraggio dei processi Spark AWS Glue](monitor-spark.md).
+ Ray jobs: puoi vedere una visualizzazione di serie di metriche selezionate. CloudWatch Per ulteriori informazioni, consulta [Monitoraggio dei processi di Ray con i parametri](author-job-ray-monitor.md).
**Topics**
+ [AWS tag in AWS Glue](monitor-tags.md)
+ [Automatizzazione con AWS Glue EventBridge](automating-awsglue-with-cloudwatch-events.md)
+ [Risorse di monitoraggio AWS Glue](monitor-resource-metrics.md)
+ [Registrazione delle chiamate AWS Glue API con AWS CloudTrail](monitor-cloudtrail.md)
# AWS tag in AWS Glue
Per facilitare la gestione delle risorse AWS Glue puoi facoltativamente assegnare i tag ad alcuni tipi di risorse AWS Glue. Un tag è un'etichetta che si assegna a una AWS risorsa. Ogni tag è composto da una chiave e da un valore opzionale, entrambi personalizzabili. Puoi usare i tag in AWS Glue per organizzare e identificare le risorse. I tag possono essere utilizzati per creare report di contabilità dei costi e limitare l'accesso alle risorse. Se lo utilizzi AWS Identity and Access Management, puoi controllare quali utenti del tuo AWS account sono autorizzati a creare, modificare o eliminare i tag. Oltre alle autorizzazioni per chiamare i tag relativi ai tag APIs, ti serve anche l'`glue:GetConnection`autorizzazione per richiamare i tag APIs sulle connessioni e l'`glue:GetDatabase`autorizzazione per richiamare i tag sui database. APIs Per ulteriori informazioni, consulta [ABAC con Glue AWS](security_iam_service-with-iam.md#security_iam_service-with-iam-tags).
In AWS Glue è possibile applicare tag alle seguenti risorse:
+ Connessione
+ Database
+ Crawler
+ Sessione interattiva
+ Endpoint di sviluppo
+ Processo
+ Trigger
+ Flusso di lavoro
+ Blueprint
+ Trasformazione basata su machine learning
+ Set di regole sulla qualità dei dati
+ Schemi di flussi di dati
+ Registri degli schemi di flussi di dati
**Nota**
Come best practice, per consentire il tagging di queste risorse AWS Glue, includi sempre l'operazione `glue:TagResource` nelle policy.
Tieni in considerazione le informazioni seguenti quando usi i tag con AWS Glue.
+ Il numero massimo di tag supportati per entità è 50.
+ In AWS Glue, i tag vengono specificati come elenco di coppie chiave-valore nel formato `{"string": "string" ...}`
+ Quando crei un tag su un oggetto, la chiave di tag è obbligatoria e il valore di tag è facoltativo.
+ La chiave di tag e il valore di tag fanno distinzione tra maiuscole e minuscole.
+ La chiave di tag e il valore di tag non devono contenere il prefisso *aws*. Non sono consentite operazioni su questi tag.
+ La lunghezza massima delle chiavi di tag è 128 caratteri Unicode in UTF-8. La chiave di tag non deve essere vuota o nulla.
+ Il valore massimo dei tag è 256 caratteri Unicode in UTF-8. Il valore di tag può essere vuoto o nullo.
## Supporto per l'etichettatura delle connessioni AWS Glue
È possibile limitare le autorizzazioni alle operazioni `CreateConnection`, `UpdateConnection`, `GetConnection` e `DeleteConnection` basate sull'assegnazione di tag alla risorsa. Ciò consente di implementare il controllo degli accessi con privilegi minimi sui AWS Glue lavori con origini dati JDBC che devono recuperare le informazioni di connessione JDBC dal Data Catalog.
**Esempio di utilizzo**
Crea una AWS Glue connessione con il tag ["connection-category», «dev-test"].
Specifica la condizione del tag per l'operazione `GetConnection` nella policy IAM.
```
{
"Effect": "Allow",
"Action": [
"glue:GetConnection"
],
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"aws:ResourceTag/tagKey": "dev-test"
}
}
}
```
## Esempi
I seguenti esempi creano un processo con tag assegnati.
**AWS CLI**
```
aws glue create-job --name job-test-tags --role MyJobRole --command Name=glueetl,ScriptLocation=S3://aws-glue-scripts//prod-job1
--tags key1=value1,key2=value2
```
**CloudFormation JSON**
```
{
"Description": "AWS Glue Job Test Tags",
"Resources": {
"MyJobRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com"
]
},
"Action": [
"sts:AssumeRole"
]
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "root",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "*",
"Resource": "*"
}
]
}
}
]
}
},
"MyJob": {
"Type": "AWS::Glue::Job",
"Properties": {
"Command": {
"Name": "glueetl",
"ScriptLocation": "s3://aws-glue-scripts//prod-job1"
},
"DefaultArguments": {
"--job-bookmark-option": "job-bookmark-enable"
},
"ExecutionProperty": {
"MaxConcurrentRuns": 2
},
"MaxRetries": 0,
"Name": "cf-job1",
"Role": {
"Ref": "MyJobRole",
"Tags": {
"key1": "value1",
"key2": "value2"
}
}
}
}
}
}
```
**CloudFormation YAML**
```
Description: AWS Glue Job Test Tags
Resources:
MyJobRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service:
- glue.amazonaws.com
Action:
- sts:AssumeRole
Path: "/"
Policies:
- PolicyName: root
PolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Action: "*"
Resource: "*"
MyJob:
Type: AWS::Glue::Job
Properties:
Command:
Name: glueetl
ScriptLocation: s3://aws-glue-scripts//prod-job1
DefaultArguments:
"--job-bookmark-option": job-bookmark-enable
ExecutionProperty:
MaxConcurrentRuns: 2
MaxRetries: 0
Name: cf-job1
Role:
Ref: MyJobRole
Tags:
key1: value1
key2: value2
```
Per ulteriori informazioni, consulta [Strategie di tagging di AWS](https://aws.amazon.com/answers/account-management/aws-tagging-strategies/).
Per informazioni su come controllare l'accesso tramite i tag, consulta [ABAC con Glue AWS](security_iam_service-with-iam.md#security_iam_service-with-iam-tags).
# Automatizzazione con AWS Glue EventBridge
Puoi utilizzare Amazon EventBridge per automatizzare AWS i tuoi servizi e rispondere automaticamente a eventi di sistema come problemi di disponibilità delle applicazioni o modifiche delle risorse. Gli eventi AWS relativi ai servizi vengono forniti quasi EventBridge in tempo reale. Puoi compilare regole semplici che indichino quali eventi sono considerati di interesse per te e quali azioni automatizzate intraprendere quando un evento corrisponde a una regola. Le azioni che possono essere attivate automaticamente includono le seguenti:
+ Invocare una funzione AWS Lambda
+ Richiamo del comando Amazon EC2 Run
+ Inoltro dell'evento a Amazon Kinesis Data Streams
+ Attivazione di una macchina a stati AWS Step Functions
+ Notifica di un argomento Amazon SNS o di una coda Amazon SQS
Alcuni esempi di utilizzo di EventBridge with AWS Glue includono quanto segue:
+ Attivazione di una funzione Lambda in caso di esito positivo di un processo ETL
+ Notifica di un argomento Amazon SNS quando un processo ETL ha esito negativo
Quanto segue EventBridge è generato daAWS Glue.
+ Gli eventi per `"detail-type":"Glue Job State Change"` vengono generati per `SUCCEEDED`, `FAILED`, `TIMEOUT` e `STOPPED`.
+ Eventi per `"detail-type":"Glue Job Run Status"` vengono generati per l'esecuzione dei processi `RUNNING`, `STARTING`e `STOPPING` quando superano la soglia di notifica di ritardo del processo. È necessario impostare la proprietà della soglia di notifica del ritardo del processo per ricevere questi eventi.
Quando viene superata la soglia di notifica del ritardo del processo, viene generato un solo evento per ciascuno stato di esecuzione del processo.
+ Eventi per `"detail-type":"Glue Crawler State Change"` vengono generati per `Started`, `Succeeded` e `Failed`.
+ Gli eventi per `“detail_type”:“Glue Scheduled Crawler Invocation Failure”` vengono generati quando il crawler pianificato non si avvia. Nei dettagli della notifica:
+ `customerId` contiene l'ID account del cliente.
+ `crawlerName` contiene il nome del crawler che non è stato avviato.
+ `errorMessage` contiene il messaggio di eccezione dell'errore di invocazione.
+ Gli eventi per `“detail_type”:“Glue Auto Statistics Invocation Failure“` vengono generati quando l'esecuzione dell'attività di statistica delle colonne gestita automaticamente non viene avviata. Nei dettagli della notifica:
+ `catalogId` contiene l'ID associato a un catalogo.
+ `databaseName` contiene il nome del database interessato.
+ `tableName` contiene il nome della tabella interessata.
+ `errorMessage` contiene il messaggio di eccezione dell'errore di invocazione.
+ Gli eventi per `“detail_type”:“Glue Scheduled Statistics Invocation Failure”` vengono generati quando l'esecuzione dell'attività di statistica delle colonne pianificate (cron) non viene avviata. Nei dettagli della notifica:
+ `catalogId` contiene l'ID associato a un catalogo.
+ `databaseName` contiene il nome del database interessato.
+ `tableName` contiene il nome della tabella interessata.
+ `errorMessage` contiene il messaggio di eccezione dell'errore di invocazione.
+ Gli eventi per `“detail_type”:“Glue Statistics Task Started”` vengono generati quando l'esecuzione dell'attività di statistica delle colonne viene avviata.
+ Gli eventi per `“detail_type”:“Glue Statistics Task Succeeded”` vengono generati quando l'esecuzione dell'attività di statistica delle colonne ha esito positivo.
+ Gli eventi per `“detail_type”:“Glue Statistics Task Failed”` vengono generati quando l'esecuzione dell'attività di statistica delle colonne ha esito negativo.
+ Gli eventi per `"detail-type":"Glue Data Catalog Database State Change"` vengono generati per `CreateDatabase`, `DeleteDatabase`, `CreateTable`, `DeleteTable` e `BatchDeleteTable`. Ad esempio, se viene creata o eliminata una tabella, viene inviata una notifica a EventBridge. Si noti che non è possibile scrivere un programma che dipende dall'ordine o dall'esistenza di eventi di notifica, poiché potrebbero essere fuori sequenza o mancanti. Gli eventi vengono emessi secondo il principio del massimo sforzo. Nei dettagli della notifica:
+ `typeOfChange` contiene il nome dell'operazione API.
+ `databaseName` contiene il nome del database interessato.
+ `changedTables` contiene fino a 100 nomi di tabelle interessate per ogni notifica. Quando i nomi di tabella sono lunghi, potrebbero essere create più notifiche.
+ Gli eventi per `"detail-type":"Glue Data Catalog Table State Change"` vengono generati per `UpdateTable`, `CreatePartition`, `BatchCreatePartition`, `UpdatePartition`, `DeletePartition`, `BatchUpdatePartition` e `BatchDeletePartition`. Ad esempio, se una tabella o una partizione viene aggiornata, viene inviata una notifica a EventBridge. Si noti che non è possibile scrivere un programma che dipende dall'ordine o dall'esistenza di eventi di notifica, poiché potrebbero essere fuori sequenza o mancanti. Gli eventi vengono emessi secondo il principio del massimo sforzo. Nei dettagli della notifica:
+ `typeOfChange` contiene il nome dell'operazione API.
+ `databaseName` contiene il nome del database contenente le risorse interessate.
+ `tableName` contiene il nome della tabella interessata.
+ `changedPartitions` specifica fino a 100 partizioni interessate in una notifica. Quando i nomi di partizione sono lunghi, potrebbero essere create più notifiche.
Ad esempio, se ci sono due chiavi di partizione, `Year` e `Month`, `"2018,01", "2018,02"` modifica la partizione dove `"Year=2018" and "Month=01"` e la partizione dove `"Year=2018" and "Month=02"`.
```
{
"version":"0",
"id":"abcdef00-1234-5678-9abc-def012345678",
"detail-type":"Glue Data Catalog Table State Change",
"source":"aws.glue",
"account":"123456789012",
"time":"2017-09-07T18:57:21Z",
"region":"us-west-2",
"resources":["arn:aws:glue:us-west-2:123456789012:database/default/foo"],
"detail":{
"changedPartitions": [
"2018,01",
"2018,02"
],
"databaseName": "default",
"tableName": "foo",
"typeOfChange": "BatchCreatePartition"
}
}
```
Per ulteriori informazioni, consulta la [Amazon CloudWatch Events User Guide](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/). Per eventi specifici di AWS Glue, consulta [Eventi AWS Glue](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/EventTypes.html#glue-event-types).
# Risorse di monitoraggio AWS Glue
AWS Glue prevede dei limiti di servizio per proteggere i clienti da forniture eccessive e impreviste e da operazioni dannose volte ad aumentare le spese. I limiti proteggono anche il servizio. Accedendo alla console AWS Service Quota, i clienti possono visualizzare i limiti attuali delle risorse e richiederne un aumento (se del caso).
AWS Glueconsente di visualizzare l'utilizzo delle risorse del servizio in percentuale in Amazon CloudWatch e di configurare CloudWatch allarmi su di esso per monitorare l'utilizzo. Amazon CloudWatch fornisce il monitoraggio AWS delle risorse e delle applicazioni dei clienti in esecuzione sull'infrastruttura Amazon. I parametri sono gratuiti. Sono supportati i parametri seguenti:
+ Numero di flussi di lavoro per account
+ Numero di trigger per account
+ Numero di processi per account
+ Numero di esecuzioni processo simultanee per account
+ Numero di schemi per account
+ Numero di sessioni interattive per account
## Configurazione e utilizzo dei parametri delle risorse
Per utilizzare questa funzionalità, puoi accedere alla CloudWatch console Amazon per visualizzare le metriche e configurare gli allarmi. Le metriche si trovano nello spazio dei nomi AWS/Glue e rappresentano una percentuale del conteggio effettivo dell'utilizzo delle risorse diviso per la quota di risorse. Le CloudWatch metriche vengono inviate ai tuoi account, il che non comporta alcun costo per te. Ad esempio, se hai creato 10 flussi di lavoro e la tua quota di servizio ti consente di avere un massimo di 200 flussi di lavoro, l'utilizzo è 10/200 = 5% e nel grafico vedrai un punto dati di 5 come percentuale. Per maggiore specificità:
```
Namespace: AWS/Glue
Metric name: ResourceUsage
Type: Resource
Resource: Workflow (or Trigger, Job, JobRun, Blueprint, InteractiveSession)
Service: Glue
Class: None
```
![\[Parametri delle risorse\]](http://docs.aws.amazon.com/it_it/glue/latest/dg/images/resource_monitoring_1.png)
Per creare un allarme in base a una metrica nella CloudWatch console:
1. Una volta individuato il parametro, vai a **Parametri definiti**.
1. Fai clic su **Crea allarme** in **Operazioni**.
1. Configura l'allarme secondo necessità.
Emettiamo dei parametri ogni volta che l'utilizzo delle risorse cambia, ad esempio in caso di aumento o diminuzione. Ma se l'utilizzo delle risorse non cambia, emettiamo le metriche ogni ora, in modo da avere un grafico continuo. CloudWatch Per evitare la perdita di punti dati, sconsigliamo di configurare un periodo inferiore a 1 ora.
Puoi anche configurare gli allarmi usando AWS CloudFormation come nell'esempio seguente. In questo esempio, quando l'utilizzo delle risorse del flusso di lavoro raggiunge l'80%, viene attivato un allarme per inviare un messaggio all'argomento SNS esistente, a cui è possibile abbonarsi per ricevere notifiche.
```
{
"Type": "AWS::CloudWatch::Alarm",
"Properties": {
"AlarmName": "WorkflowUsageAlarm",
"ActionsEnabled": true,
"OKActions": [],
"AlarmActions": [
"arn:aws:sns:af-south-1:085425700061:Default_CloudWatch_Alarms_Topic"
],
"InsufficientDataActions": [],
"MetricName": "ResourceUsage",
"Namespace": "AWS/Glue",
"Statistic": "Maximum",
"Dimensions": [{
"Name": "Type",
"Value": "Resource"
},
{
"Name": "Resource",
"Value": "Workflow"
},
{
"Name": "Service",
"Value": "Glue"
},
{
"Name": "Class",
"Value": "None"
}
],
"Period": 3600,
"EvaluationPeriods": 1,
"DatapointsToAlarm": 1,
"Threshold": 80,
"ComparisonOperator": "GreaterThanThreshold",
"TreatMissingData": "notBreaching"
}
}
```
# Registrazione delle chiamate AWS Glue API con AWS CloudTrail
AWS Glueè integrato con AWS CloudTrail, un servizio che fornisce una registrazione delle azioni intraprese da un utente, un ruolo o un AWS servizio in. AWS Glue CloudTrail acquisisce tutte le chiamate API AWS Glue come eventi. Le chiamate acquisite includono le chiamate dalla console di AWS Glue e le chiamate di codice alle operazioni delle API AWS Glue. Se crei un trail, puoi abilitare la distribuzione continua di CloudTrail eventi a un bucket Amazon S3, inclusi gli eventi per. AWS Glue Se non configuri un percorso, puoi comunque visualizzare gli eventi più recenti nella CloudTrail console nella cronologia degli **eventi**. Utilizzando le informazioni raccolte da CloudTrail, puoi determinare a quale richiesta è stata inviataAWS Glue, l'indirizzo IP da cui è stata effettuata la richiesta, chi ha effettuato la richiesta, quando è stata effettuata e dettagli aggiuntivi.
Per ulteriori informazioni CloudTrail, consulta la [Guida AWS CloudTrail per l'utente](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
## AWS Glueinformazioni in CloudTrail
CloudTrail è abilitato sul tuo AWS account al momento della creazione dell'account. Quando si verifica un'attività inAWS Glue, tale attività viene registrata in un CloudTrail evento insieme ad altri eventi AWS di servizio nella **cronologia degli eventi**. Puoi visualizzare, cercare e scaricare gli eventi recenti nel tuo AWS account. Per ulteriori informazioni, consulta [Visualizzazione degli eventi con la cronologia degli CloudTrail eventi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Per una registrazione continua degli eventi nel tuo AWS account, inclusi gli eventi diAWS Glue, crea un percorso. Un *trail* consente di CloudTrail inviare file di log a un bucket Amazon S3. Per impostazione predefinita, quando crei un percorso nella console, il percorso si applica a tutte le AWS regioni. Il trail registra gli eventi di tutte le regioni della AWS partizione e consegna i file di log al bucket Amazon S3 specificato. Inoltre, puoi configurare altri AWS servizi per analizzare ulteriormente e agire in base ai dati sugli eventi raccolti nei log. CloudTrail Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Creare un percorso per il tuo account AWS](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail servizi e integrazioni supportati](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configurazione delle notifiche Amazon SNS per CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Ricezione di file di CloudTrail registro da più regioni](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) e [ricezione di file di CloudTrail registro da](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html) più account
Tutte AWS Glue le azioni vengono registrate CloudTrail e documentate in. [AWS Glue API](aws-glue-api.md) Ad esempio, le chiamate a `CreateTable` e `CreateDatabase` le `CreateScript` azioni generano voci nei file di CloudTrail registro.
Ogni evento o voce di log contiene informazioni sull’utente che ha generato la richiesta. Le informazioni di identità consentono di determinare quanto segue:
+ Se la richiesta è stata effettuata con le credenziali dell'utente IAM o root.
+ Se la richiesta è stata effettuata con le credenziali di sicurezza temporanee per un ruolo o un utente federato.
+ Se la richiesta è stata effettuata da un altro AWS servizio.
Per ulteriori informazioni, consulta [Elemento CloudTrail userIdentity](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
Tuttavia, CloudTrail non registra tutte le informazioni relative alle chiamate. Ad esempio, non registra determinate informazioni sensibili, come quelle `ConnectionProperties` utilizzate nelle richieste di connessione, e registra `null` invece delle risposte restituite da quanto segue: APIs
```
BatchGetPartition GetCrawlers GetJobs GetTable
CreateScript GetCrawlerMetrics GetJobRun GetTables
GetCatalogImportStatus GetDatabase GetJobRuns GetTableVersions
GetClassifier GetDatabases GetMapping GetTrigger
GetClassifiers GetDataflowGraph GetObjects GetTriggers
GetConnection GetDevEndpoint GetPartition GetUserDefinedFunction
GetConnections GetDevEndpoints GetPartitions GetUserDefinedFunctions
GetCrawler GetJob GetPlan
```
## Informazioni sulle voci dei file di log di AWS Glue
Un trail è una configurazione che consente la distribuzione di eventi come file di log in un bucket Amazon S3 specificato dall'utente. CloudTrail i file di registro contengono una o più voci di registro. Un evento rappresenta una singola richiesta proveniente da qualsiasi fonte e include informazioni sull'azione richiesta, la data e l'ora dell'azione, i parametri della richiesta e così via. CloudTrail i file di registro non sono una traccia ordinata dello stack delle chiamate API pubbliche, quindi non vengono visualizzati in un ordine specifico.
L'esempio seguente mostra una voce di CloudTrail registro che illustra l'`DeleteCrawler`azione.
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "johndoe"
},
"eventTime": "2017-10-11T22:29:49Z",
"eventSource": "glue.amazonaws.com",
"eventName": "DeleteCrawler",
"awsRegion": "us-east-1",
"sourceIPAddress": "72.21.198.64",
"userAgent": "aws-cli/1.11.148 Python/3.6.1 Darwin/16.7.0 botocore/1.7.6",
"requestParameters": {
"name": "tes-alpha"
},
"responseElements": null,
"requestID": "b16f4050-aed3-11e7-b0b3-75564a46954f",
"eventID": "e73dd117-cfd1-47d1-9e2f-d1271cad838c",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```
Questo esempio mostra una voce di CloudTrail registro che illustra un'`CreateConnection`azione.
```
{
"eventVersion": "1.05",
"userIdentity": {
"type": "IAMUser",
"principalId": "AKIAIOSFODNN7EXAMPLE",
"arn": "arn:aws:iam::123456789012:user/johndoe",
"accountId": "123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "johndoe"
},
"eventTime": "2017-10-13T00:19:19Z",
"eventSource": "glue.amazonaws.com",
"eventName": "CreateConnection",
"awsRegion": "us-east-1",
"sourceIPAddress": "72.21.198.66",
"userAgent": "aws-cli/1.11.148 Python/3.6.1 Darwin/16.7.0 botocore/1.7.6",
"requestParameters": {
"connectionInput": {
"name": "test-connection-alpha",
"connectionType": "JDBC",
"physicalConnectionRequirements": {
"subnetId": "subnet-323232",
"availabilityZone": "us-east-1a",
"securityGroupIdList": [
"sg-12121212"
]
}
}
},
"responseElements": null,
"requestID": "27136ebc-afac-11e7-a7d6-ab217e5c3f19",
"eventID": "e8b3baeb-c511-4597-880f-c16210c60a4a",
"eventType": "AwsApiCall",
"recipientAccountId": "123456789012"
}
```