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à. # 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. [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/FnHCoTuDLXU/0.jpg)](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.