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à. # Registrazione di log e monitoraggio Il monitoraggio è una parte importante del mantenimento dell'affidabilità, della disponibilità e delle prestazioni delle applicazioni e dei lavori EMR Serverless. È necessario raccogliere i dati di monitoraggio da tutte le parti delle soluzioni EMR Serverless in modo che gli errori multipoint possano essere risolti più facilmente se si verificano. **Topics** + [Archiviazione dei registri](logging.md) + [Registri rotanti](rotating-logs.md) + [Crittografia dei log](jobs-log-encryption.md) + [Configurazione delle proprietà di Apache Log4j2 per Amazon EMR Serverless](log4j2.md) + [Monitoraggio EMR Serverless](metrics.md) + [Automazione di EMR Serverless con Amazon EventBridge](using-eventbridge.md) # Archiviazione dei registri Per monitorare l'avanzamento del lavoro su EMR Serverless e risolvere i problemi relativi ai lavori, scegli in che modo EMR Serverless archivia e gestisce i registri delle applicazioni. Quando invii un job run, specifica lo storage gestito, Amazon S3 e Amazon CloudWatch come opzioni di registrazione. Con CloudWatch, specifica i tipi e le posizioni di registro che desideri utilizzare o accetta i tipi e le posizioni predefiniti. Per ulteriori informazioni sui CloudWatch log, fare riferimento a[Registrazione per EMR Serverless con Amazon CloudWatch](#jobs-log-storage-cw). Per quanto riguarda lo storage gestito e la registrazione S3, la tabella seguente elenca le posizioni dei log e la disponibilità dell'interfaccia utente che puoi aspettarti se scegli [lo storage gestito](#jobs-log-storage-managed-storage), i [bucket Amazon S3](#jobs-log-storage-s3-buckets) o entrambi. | Opzione | Registri degli eventi | Registri di container | Interfaccia utente dell'applicazione | | --- | --- | --- | --- | | Archiviazione gestita | Archiviata in uno storage gestito | Archiviata in un sistema di storage gestito | Supportata | | Storage gestito e bucket S3 | Archiviati in entrambi i posti | Memorizzato in un bucket S3 | Supportata | | Bucket Amazon S3 | Memorizzato nel bucket S3 | Memorizzato nel bucket S3 | Non supportato 1 | 1 Ti consigliamo di mantenere selezionata l'opzione **Archiviazione gestita**. In caso contrario, non è possibile utilizzare l'applicazione integrata UIs. ## Registrazione per EMR Serverless con storage gestito Per impostazione predefinita, EMR Serverless archivia i log delle applicazioni in modo sicuro nello storage gestito di Amazon EMR per un massimo di 30 giorni. **Nota** Se disattivi l'opzione predefinita, Amazon EMR non può risolvere i tuoi lavori per tuo conto. Esempio: non è possibile accedere a Spark-UI dalla console serverless EMR. **Per disattivare questa opzione da EMR Studio, deseleziona la casella di controllo **Consenti di AWS conservare i log per 30 giorni** nella sezione **Impostazioni aggiuntive** della pagina Invia lavoro.** Per disattivare questa opzione da AWS CLI, utilizza la `managedPersistenceMonitoringConfiguration` configurazione quando invii l'esecuzione di un lavoro. ``` { "monitoringConfiguration": { "managedPersistenceMonitoringConfiguration": { "enabled": false } } } ``` Se la tua applicazione EMR Serverless si trova in una sottorete privata con endpoint VPC per Amazon S3 e alleghi una policy di endpoint per controllare l'accesso, aggiungi le seguenti autorizzazioni per EMR Serverless per archiviare e servire i log delle applicazioni. Sostituisci `Resource` con i `AppInfo` bucket della tabella delle regioni disponibili in [Politiche di esempio per sottoreti private che accedono ad Amazon S3](https://docs.aws.amazon.com/emr/latest/ManagementGuide/private-subnet-iampolicy.html#private-subnet-iampolicy-regions). ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "EMRServerlessManagedLogging", "Effect": "Allow", "Action": [ "s3:PutObject", "s3:PutObjectAcl" ], "Resource": [ "arn:aws:s3:::prod.us-east-1.appinfo.src", "arn:aws:s3:::prod.us-east-1.appinfo.src/*" ], "Condition": { "StringEquals": { "aws:PrincipalServiceName": "emr-serverless.amazonaws.com", "aws:SourceVpc": "vpc-12345678" } } } ] } ``` ------ Inoltre, utilizza la chiave `aws:SourceVpc` condition per assicurarti che la richiesta passi attraverso il VPC a cui è collegato l'endpoint VPC. ## Registrazione per EMR Serverless con bucket Amazon S3 Prima che i job possano inviare dati di log ad Amazon S3, includi le seguenti autorizzazioni nella politica di autorizzazione per il ruolo di runtime del job. Sostituisci `amzn-s3-demo-logging-bucket` con il nome del bucket di accesso. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:PutObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/*" ], "Sid": "AllowS3Putobject" } ] } ``` ------ Per configurare un bucket Amazon S3 per archiviare i log di AWS CLI, utilizza la `s3MonitoringConfiguration` configurazione all'avvio di un job. A tale scopo, fornisci quanto segue `--configuration-overrides` nella configurazione. ``` { "monitoringConfiguration": { "s3MonitoringConfiguration": { "logUri": "s3://amzn-s3-demo-logging-bucket/logs/" } } } ``` Per i processi batch che non hanno i nuovi tentativi abilitati, EMR Serverless invia i log al seguente percorso: ``` '/applications//jobs/' ``` I log dei driver Spark sono archiviati nel seguente percorso da EMR Serverless ``` '/applications//jobs//SPARK_DRIVER/' ``` I log di Spark Executor vengono archiviati nel seguente percorso da EMR Serverless ``` '/applications//jobs//SPARK_EXECUTOR/' ``` Il è un numero intero. Le versioni 7.1.0 e successive di EMR Serverless supportano i tentativi di riprovare per processi di streaming e processi batch. Se si esegue un lavoro con i nuovi tentativi abilitati, EMR Serverless aggiunge automaticamente un numero di tentativo al prefisso del percorso di registro, in modo da poter distinguere e tracciare meglio i log. ``` '/applications//jobs//attempts//' ``` ## Registrazione per EMR Serverless con Amazon CloudWatch Quando invii un lavoro a un'applicazione EMR Serverless, scegli Amazon CloudWatch come opzione per archiviare i log delle applicazioni. Ciò consente di utilizzare funzionalità di analisi dei CloudWatch log come CloudWatch Logs Insights e Live Tail. Puoi anche trasmettere i log da altri sistemi, CloudWatch ad esempio OpenSearch per ulteriori analisi. EMR Serverless fornisce la registrazione in tempo reale dei registri dei driver. Puoi accedere ai log in tempo reale con la funzionalità CloudWatch live tail o tramite CloudWatch i comandi di coda della CLI. Per impostazione predefinita, la CloudWatch registrazione è disabilitata per EMR Serverless. Per abilitarlo, usa la configurazione in. [AWS CLI](#jobs-log-storage-cw-cli) **Nota** Amazon CloudWatch pubblica i log in tempo reale, quindi richiede più risorse ai lavoratori. Se scegli una capacità di manodopera ridotta, l'impatto sulla durata del lavoro potrebbe aumentare. Se abiliti CloudWatch la registrazione, ti suggeriamo di scegliere una maggiore capacità di lavoro. È anche possibile che la pubblicazione dei log rallenti se la frequenza delle transazioni al secondo (TPS) è troppo bassa per. `PutLogEvents` La configurazione di CloudWatch limitazione è globale per tutti i servizi, incluso EMR Serverless. Per ulteriori informazioni, consulta [Come posso determinare la limitazione nei miei registri](https://repost.aws/knowledge-center/cloudwatch-logs-throttling)? CloudWatch *su re:post.AWS * ### Autorizzazioni richieste per la registrazione con CloudWatch Prima che i tuoi lavori possano inviare dati di registro ad Amazon CloudWatch, includi le seguenti autorizzazioni nella politica di autorizzazione per il ruolo Job Runtime. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "logs:DescribeLogGroups" ], "Resource": [ "arn:aws:logs:*:123456789012:*" ], "Sid": "AllowLOGSDescribeloggroups" }, { "Effect": "Allow", "Action": [ "logs:PutLogEvents", "logs:CreateLogGroup", "logs:CreateLogStream", "logs:DescribeLogStreams" ], "Resource": [ "arn:aws:logs:*:123456789012:log-group:my-log-group-name:*" ], "Sid": "AllowLOGSPutlogevents" } ] } ``` ------ ### AWS CLI Per configurare Amazon per CloudWatch archiviare i log per EMR Serverless da, utilizza AWS CLI la configurazione `cloudWatchLoggingConfiguration` all'avvio di un job. A tale scopo, fornisci le seguenti modifiche di configurazione. Facoltativamente, fornisci anche il nome del gruppo di log, il nome del prefisso del flusso di log, i tipi di registro e una chiave di crittografia ARN. Se non specifichi i valori opzionali, CloudWatch pubblica i log in un gruppo di log predefinito`/aws/emr-serverless`, con il flusso di log predefinito. `/applications/applicationId/jobs/jobId/worker-type` Le versioni 7.1.0 e successive di EMR Serverless supportano i tentativi di riprovare per processi di streaming e processi batch. Se sono stati abilitati i nuovi tentativi per un lavoro, EMR Serverless aggiunge automaticamente un numero di tentativo al prefisso del percorso di registro, in modo da poter distinguere e tracciare meglio i log. ``` '/applications//jobs//attempts//worker-type' ``` Di seguito viene illustrata la configurazione minima richiesta per attivare Amazon CloudWatch Logging con le impostazioni predefinite per EMR Serverless: ``` { "monitoringConfiguration": { "cloudWatchLoggingConfiguration": { "enabled": true } } } ``` L'esempio seguente mostra tutte le configurazioni obbligatorie e opzionali che specificano quando si attiva Amazon CloudWatch Logging per EMR Serverless. I `logTypes` valori supportati sono elencati anche nel seguente esempio. ``` { "monitoringConfiguration": { "cloudWatchLoggingConfiguration": { "enabled": true, // Required "logGroupName": "Example_logGroup", // Optional "logStreamNamePrefix": "Example_logStream", // Optional "encryptionKeyArn": "key-arn", // Optional "logTypes": { "SPARK_DRIVER": ["stdout", "stderr"] //List of values } } } } ``` Per impostazione predefinita, EMR Serverless pubblica solo i log dei driver su cui stdout e stderr. CloudWatch Se desideri altri log, specifica il ruolo del contenitore e i tipi di log corrispondenti con il campo. `logTypes` L'elenco seguente mostra i tipi di worker supportati che specificano la `logTypes` configurazione: **Spark** + `SPARK_DRIVER : ["STDERR", "STDOUT"]` + `SPARK_EXECUTOR : ["STDERR", "STDOUT"]` **Hive** + `HIVE_DRIVER : ["STDERR", "STDOUT", "HIVE_LOG", "TEZ_AM"]` + `TEZ_TASK : ["STDERR", "STDOUT", "SYSTEM_LOGS"]` # Registri rotanti Amazon EMR Serverless può ruotare i log delle applicazioni Spark e i log degli eventi. La rotazione dei log aiuta a risolvere il problema dei processi di lunga durata che generano file di registro di grandi dimensioni che possono occupare tutto lo spazio su disco. La rotazione dei log consente di risparmiare spazio su disco e riduce il numero di errori dei processi, poiché non rimane più spazio sul disco. La rotazione dei log è abilitata di default ed è disponibile solo per i job Spark. **Registri degli eventi di Spark** **Nota** La rotazione dei log degli eventi Spark è disponibile su tutte le etichette di rilascio di Amazon EMR. Invece di generare un singolo file di registro degli eventi, EMR Serverless ruota il registro degli eventi a intervalli di tempo regolari e rimuove i file di registro degli eventi più vecchi. La rotazione dei log non influisce sui log caricati nel bucket S3. **Registri delle applicazioni Spark** **Nota** La rotazione dei log delle applicazioni Spark è disponibile su tutte le etichette di rilascio di Amazon EMR. EMR Serverless ruota anche i log delle applicazioni Spark per driver ed esecutori, come i file e. `stdout` `stderr` È possibile accedere ai file di registro più recenti scegliendo i collegamenti di registro in Studio utilizzando i collegamenti Spark History Server e Live UI. I file di registro sono le versioni troncate dei log più recenti. Per fare riferimento ai log ruotati precedenti, specifica una posizione Amazon S3 durante l'archiviazione dei log. Per ulteriori informazioni, consulta [Logging for EMR Serverless con bucket Amazon S3](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/logging.html#jobs-log-storage-s3-buckets). Puoi trovare i file di log più recenti nella seguente posizione. EMR Serverless aggiorna i file ogni 15 secondi. Questi file possono variare da 0 MB a 128 MB. ``` /applications//jobs//SPARK_DRIVER/stderr.gz ``` La seguente posizione contiene i file ruotati più vecchi. Ogni file è di 128 MB. ``` /applications//jobs//SPARK_DRIVER/archived/stderr_.gz ``` Lo stesso comportamento si applica anche agli esecutori Spark. Questa modifica è applicabile solo alla registrazione di S3. La rotazione dei log non introduce alcuna modifica ai flussi di log caricati su Amazon CloudWatch. Le versioni 7.1.0 e successive di EMR Serverless supportano i tentativi di riprovare per lo streaming e i job in batch. Se hai abilitato i tentativi di riprovare con il tuo processo, EMR Serverless aggiunge un prefisso al percorso di registro per tali lavori in modo da poter tracciare e distinguere meglio i log l'uno dall'altro. Questo percorso contiene tutti i log ruotati. ``` '/applications//jobs//attempts//'. ``` # Crittografia dei log ## Crittografia dei log EMR Serverless con storage gestito Per crittografare i log nello storage gestito con la tua chiave KMS, utilizza la `managedPersistenceMonitoringConfiguration` configurazione quando invii l'esecuzione di un lavoro. ``` { "monitoringConfiguration": { "managedPersistenceMonitoringConfiguration" : { "encryptionKeyArn": "key-arn" } } } ``` ## Crittografia dei log EMR Serverless con bucket Amazon S3 Per crittografare i log nel tuo bucket Amazon S3 con la tua chiave KMS, usa la configurazione quando `s3MonitoringConfiguration` invii un job run. ``` { "monitoringConfiguration": { "s3MonitoringConfiguration": { "logUri": "s3://amzn-s3-demo-logging-bucket/logs/", "encryptionKeyArn": "key-arn" } } } ``` ## Crittografia dei log EMR Serverless con Amazon CloudWatch Per crittografare i log in Amazon CloudWatch con la tua chiave KMS, usa la `cloudWatchLoggingConfiguration` configurazione quando invii un job run. ``` { "monitoringConfiguration": { "cloudWatchLoggingConfiguration": { "enabled": true, "encryptionKeyArn": "key-arn" } } } ``` ## Autorizzazioni richieste per la crittografia dei log **Topics** + [Autorizzazioni utente richieste](#jobs-log-encryption-permissions-user) + [Autorizzazioni delle chiavi di crittografia per Amazon S3 e storage gestito](#jobs-log-encryption-permissions-s3) + [Autorizzazioni per le chiavi di crittografia per Amazon CloudWatch](#jobs-log-encryption-permissions-cw) ### Autorizzazioni utente richieste L'utente che invia il lavoro o visualizza i log dell'applicazione UIs deve disporre delle autorizzazioni per utilizzare la chiave. Puoi specificare le autorizzazioni nella politica delle chiavi KMS o nella politica IAM per l'utente, il gruppo o il ruolo. Se l'utente che invia il lavoro non dispone delle autorizzazioni della chiave KMS, EMR Serverless rifiuta l'invio dell'esecuzione del lavoro. **Esempio di politica chiave** La seguente politica chiave fornisce le autorizzazioni per `kms:GenerateDataKey` e`kms:Decrypt`: ``` { "Effect": "Allow", "Principal":{ "AWS": "arn:aws:iam::111122223333:user/user-name" }, "Action": [ "kms:GenerateDataKey", "kms:Decrypt" ], "Resource": "*" } ``` **Policy IAM di esempio** La seguente politica IAM fornisce le autorizzazioni per `kms:GenerateDataKey` e: `kms:Decrypt` ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kms:GenerateDataKey", "kms:Decrypt" ], "Resource": [ "arn:aws:kms:*:123456789012:key/12345678-1234-1234-1234-123456789012" ], "Sid": "AllowKMSGeneratedatakey" } ] } ``` ------ Per avviare l'interfaccia utente Spark o Tez, concedi ai tuoi utenti, gruppi o ruoli le autorizzazioni per accedere all'`emr-serverless:GetDashboardForJobRun`API come segue: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "emr-serverless:GetDashboardForJobRun" ], "Resource": [ "*" ], "Sid": "AllowEMRSERVERLESSGetdashboardforjobrun" } ] } ``` ------ ### Autorizzazioni delle chiavi di crittografia per Amazon S3 e storage gestito Quando crittografi i log con la tua chiave di crittografia nello storage gestito o nei bucket S3, configura le autorizzazioni delle chiavi KMS come segue. Il `emr-serverless.amazonaws.com` principale deve disporre delle seguenti autorizzazioni nella politica per la chiave KMS: ``` { "Effect": "Allow", "Principal":{ "Service": "emr-serverless.amazonaws.com" }, "Action": [ "kms:Decrypt", "kms:GenerateDataKey" ], "Resource": "*" "Condition": { "StringLike": { "aws:SourceArn": "arn:aws:emr-serverless:region:aws-account-id:/applications/application-id" } } } ``` Come best practice di sicurezza, ti suggeriamo di aggiungere una chiave di `aws:SourceArn` condizione alla politica delle chiavi KMS. La chiave di condizione globale IAM `aws:SourceArn` aiuta a garantire che EMR Serverless utilizzi la chiave KMS solo per l'ARN di un'applicazione. Il ruolo di job runtime deve disporre delle seguenti autorizzazioni nella sua policy IAM: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "kms:GenerateDataKey", "kms:Decrypt" ], "Resource": [ "arn:aws:kms:*:123456789012:key/12345678-1234-1234-1234-123456789012" ], "Sid": "AllowKMSGeneratedatakey" } ] } ``` ------ ### Autorizzazioni per le chiavi di crittografia per Amazon CloudWatch Per associare l'ARN della chiave KMS al tuo gruppo di log, utilizza la seguente politica IAM per il ruolo di job runtime. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "logs:AssociateKmsKey" ], "Resource": [ "arn:aws:logs:*:123456789012:log-group:my-log-group-name:*" ], "Sid": "AllowLOGSAssociatekmskey" } ] } ``` ------ Configura la politica delle chiavi KMS per concedere le autorizzazioni KMS ad Amazon: CloudWatch ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Id": "key-default-1", "Statement": [ { "Effect": "Allow", "Action": [ "kms:Decrypt", "kms:GenerateDataKey" ], "Resource": [ "*" ], "Condition": { "ArnLike": { "kms:EncryptionContext:aws:logs:arn": "arn:aws:logs:*:123456789012:*" } }, "Sid": "AllowKMSDecrypt" } ] } ``` ------ # Configurazione delle proprietà di Apache Log4j2 per Amazon EMR Serverless Questa pagina descrive come configurare le [proprietà personalizzate di Apache Log4j 2.x](https://logging.apache.org/log4j/2.x/) per i lavori EMR Serverless su. `StartJobRun` Se si desidera configurare le classificazioni Log4j a livello di applicazione, fare riferimento a. [Configurazione predefinita dell'applicazione per EMR Serverless](default-configs.md) ## Configurazione delle proprietà di Spark Log4j2 per Amazon EMR Serverless Con le versioni 6.8.0 e successive di Amazon EMR, puoi personalizzare le proprietà di [Apache Log4j 2.x](https://logging.apache.org/log4j/2.x/) per specificare configurazioni di log dettagliate. Ciò semplifica la risoluzione dei problemi dei job Spark su EMR Serverless. Per configurare queste proprietà, usa le classificazioni e. `spark-driver-log4j2` `spark-executor-log4j2` **Topics** + [Classificazioni Log4j2 per Spark](#log4j2-spark-class) + [Esempio di configurazione Log4j2 per Spark](#log4j2-spark-example) + [Log4j2 in esempi di job Spark](#log4j2-spark-jobs) + [Considerazioni su Log4j2 per Spark](#log4j2-spark-considerations) ### Classificazioni Log4j2 per Spark Per personalizzare le configurazioni dei log di Spark, usa le seguenti classificazioni con. [https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_ConfigurationOverrides.html#emrserverless-Type-ConfigurationOverrides-applicationConfiguration](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_ConfigurationOverrides.html#emrserverless-Type-ConfigurationOverrides-applicationConfiguration) Per configurare le proprietà di Log4j 2.x, usa quanto segue. [https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_Configuration.html#emrserverless-Type-Configuration-properties](https://docs.aws.amazon.com/emr-serverless/latest/APIReference/API_Configuration.html#emrserverless-Type-Configuration-properties) **`spark-driver-log4j2`** Questa classificazione imposta i valori nel `log4j2.properties` file per il driver. **`spark-executor-log4j2`** Questa classificazione imposta i valori nel `log4j2.properties` file per l'esecutore. ### Esempio di configurazione Log4j2 per Spark L'esempio seguente mostra come inviare un job Spark con per personalizzare le configurazioni di Log4j2 `applicationConfiguration` per il driver e l'esecutore Spark. Per configurare le classificazioni Log4j a livello di applicazione anziché al momento dell'invio del lavoro, consulta. [Configurazione predefinita dell'applicazione per EMR Serverless](default-configs.md) ``` aws emr-serverless start-job-run \ --application-id application-id \ --execution-role-arn job-role-arn \ --job-driver '{ "sparkSubmit": { "entryPoint": "/usr/lib/spark/examples/jars/spark-examples.jar", "entryPointArguments": ["1"], "sparkSubmitParameters": "--class org.apache.spark.examples.SparkPi --conf spark.executor.cores=4 --conf spark.executor.memory=20g --conf spark.driver.cores=4 --conf spark.driver.memory=8g --conf spark.executor.instances=1" } }' --configuration-overrides '{ "applicationConfiguration": [ { "classification": "spark-driver-log4j2", "properties": { "rootLogger.level":"error", // will only display Spark error logs "logger.IdentifierForClass.name": "classpath for setting logger", "logger.IdentifierForClass.level": "info" } }, { "classification": "spark-executor-log4j2", "properties": { "rootLogger.level":"error", // will only display Spark error logs "logger.IdentifierForClass.name": "classpath for setting logger", "logger.IdentifierForClass.level": "info" } } ] }' ``` ### Log4j2 in esempi di job Spark I seguenti esempi di codice mostrano come creare un'applicazione Spark mentre inizializzi una configurazione Log4j2 personalizzata per l'applicazione. ------ #### [ Python ] **Example - Utilizzo di Log4j2 per un lavoro Spark con Python** ``` import os import sys from pyspark import SparkConf, SparkContext from pyspark.sql import SparkSession app_name = "PySparkApp" if __name__ == "__main__": spark = SparkSession\ .builder\ .appName(app_name)\ .getOrCreate() spark.sparkContext._conf.getAll() sc = spark.sparkContext log4jLogger = sc._jvm.org.apache.log4j LOGGER = log4jLogger.LogManager.getLogger(app_name) LOGGER.info("pyspark script logger info") LOGGER.warn("pyspark script logger warn") LOGGER.error("pyspark script logger error") // your code here spark.stop() ``` Per personalizzare Log4j2 per il driver quando esegui un job Spark, usa la seguente configurazione: ``` { "classification": "spark-driver-log4j2", "properties": { "rootLogger.level":"error", // only display Spark error logs "logger.PySparkApp.level": "info", "logger.PySparkApp.name": "PySparkApp" } } ``` ------ #### [ Scala ] **Example - Utilizzo di Log4j2 per un job Spark con Scala** ``` import org.apache.log4j.Logger import org.apache.spark.sql.SparkSession object ExampleClass { def main(args: Array[String]): Unit = { val spark = SparkSession .builder .appName(this.getClass.getName) .getOrCreate() val logger = Logger.getLogger(this.getClass); logger.info("script logging info logs") logger.warn("script logging warn logs") logger.error("script logging error logs") // your code here spark.stop() } } ``` Per personalizzare Log4j2 per il driver quando esegui un job Spark, usa la seguente configurazione: ``` { "classification": "spark-driver-log4j2", "properties": { "rootLogger.level":"error", // only display Spark error logs "logger.ExampleClass.level": "info", "logger.ExampleClass.name": "ExampleClass" } } ``` ------ ### Considerazioni su Log4j2 per Spark Le seguenti proprietà Log4j2.x non sono configurabili per i processi Spark: + `rootLogger.appenderRef.stdout.ref` + `appender.console.type` + `appender.console.name` + `appender.console.target` + `appender.console.layout.type` + `appender.console.layout.pattern` [Per informazioni dettagliate sulle proprietà di Log4j2.x configurate, consulta il file su. `log4j2.properties.template`](https://github.com/apache/spark/blob/v3.3.0/conf/log4j2.properties.template) GitHub # Monitoraggio EMR Serverless Questa sezione illustra i modi per monitorare le applicazioni e i lavori Serverless di Amazon EMR. **Topics** + [Monitoraggio delle applicazioni e dei lavori EMR Serverless](app-job-metrics.md) + [Monitora i parametri di Spark con Amazon Managed Service for Prometheus](monitor-with-prometheus.md) + [Metriche di utilizzo EMR Serverless](monitoring-usage.md) # Monitoraggio delle applicazioni e dei lavori EMR Serverless Con Amazon CloudWatch Metrics for EMR Serverless, puoi ricevere parametri di CloudWatch 1 minuto e accedere a dashboard per CloudWatch accedere alle near-real-time operazioni e alle prestazioni delle tue applicazioni EMR Serverless. EMR Serverless invia metriche a ogni minuto. CloudWatch EMR Serverless emette queste metriche a livello di applicazione, nonché di mansione, tipo di lavoratore e livelli. capacity-allocation-type Per iniziare, utilizza il modello di CloudWatch dashboard EMR Serverless fornito nell'archivio [EMR GitHub Serverless](https://github.com/aws-samples/emr-serverless-samples/tree/main/cloudformation/emr-serverless-cloudwatch-dashboard/) e distribuiscilo. **Nota** I [carichi di lavoro interattivi EMR Serverless](interactive-workloads.md) hanno solo il monitoraggio a livello di applicazione abilitato e hanno una nuova dimensione di tipo di lavoratore,. `Spark_Kernel` [Per monitorare ed eseguire il debug dei carichi di lavoro interattivi, accedi ai log e all'interfaccia utente di Apache Spark dall'area di lavoro di EMR Studio.](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-debug.html#emr-studio-debug-serverless) ## Monitoraggio delle metriche **Importante** Stiamo ristrutturando la visualizzazione delle nostre metriche per aggiungere `ApplicationName` e `JobName` come dimensioni. Per la versione 7.10 e successive, le metriche precedenti non verranno più aggiornate. Per le versioni EMR precedenti alla 7.10, le metriche precedenti sono ancora disponibili. **Dimensioni attuali** La tabella seguente descrive le dimensioni EMR Serverless disponibili all'interno dello spazio dei nomi. `AWS/EMR Serverless` **Dimensioni per le metriche EMR Serverless** | Dimensione | Description | | --- | --- | | ApplicationId | Filtri per tutte le metriche di un'applicazione EMR Serverless utilizzando l'ID dell'applicazione. | | ApplicationName | Filtri per tutte le metriche di un'applicazione EMR Serverless utilizzando il nome. **Se il nome non viene fornito o contiene caratteri non ASCII, viene pubblicato come [Non specificato].** | | JobId | Filtri per tutte le metriche di un server EMR senza l'ID di esecuzione del lavoro. | | JobName | Filtri per tutte le metriche di un job EMR Serverless eseguito utilizzando il nome. **Se il nome non viene fornito o contiene caratteri non ASCII, viene pubblicato come [Non specificato].** | | WorkerType | Filtri per tutte le metriche di un determinato tipo di lavoratore. Ad esempio, puoi filtrare per `SPARK_DRIVER` e `SPARK_EXECUTORS` per i job Spark. | | CapacityAllocationType | Filtri per tutte le metriche di un determinato tipo di allocazione della capacità. Ad esempio, puoi filtrare per la capacità preinizializzata e `PreInitCapacity` `OnDemandCapacity` per tutto il resto. | ## Monitoraggio a livello di applicazione Puoi monitorare l'utilizzo della capacità a livello di applicazione EMR Serverless con i parametri di Amazon. CloudWatch Puoi anche configurare un singolo display per monitorare l'utilizzo della capacità delle applicazioni in una dashboard. CloudWatch **Metriche delle applicazioni EMR Serverless** | Metrica | Description | Unità | Dimensione | | --- | --- | --- | --- | | MaxCPUAllowed | La CPU massima consentita per l'applicazione. | VPCU | ApplicationId, ApplicationName | | MaxMemoryAllowed | La memoria massima in GB consentita per l'applicazione. | Gigabyte (GB) | ApplicationId, ApplicationName | | MaxStorageAllowed | Lo spazio di archiviazione massimo in GB consentito per l'applicazione. | Gigabyte (GB) | ApplicationId, ApplicationName | | CPUAllocated | Il numero totale di v CPUs allocato. | VPCU | ApplicationId, ApplicationName, WorkerType, CapacityAllocationType | | IdleWorkerCount | Il numero totale di lavoratori inattivi. | Conteggio | ApplicationId, ApplicationName, WorkerType, CapacityAllocationType | | MemoryAllocated | Memoria totale in GB allocata. | Gigabyte (GB) | ApplicationId, ApplicationName, WorkerType, CapacityAllocationType | | PendingCreationWorkerCount | Il numero totale di lavoratori in attesa di creazione. | Conteggio | ApplicationId, ApplicationName, WorkerType, CapacityAllocationType | | RunningWorkerCount | Il numero totale di lavoratori utilizzati dall'applicazione. | Conteggio | ApplicationId, ApplicationName, WorkerType, CapacityAllocationType | | StorageAllocated | Lo spazio di archiviazione totale su disco in GB allocato. | Gigabyte (GB) | ApplicationId, ApplicationName, WorkerType, CapacityAllocationType | | TotalWorkerCount | Il numero totale di lavoratori disponibili. | Conteggio | ApplicationId, ApplicationName, WorkerType, CapacityAllocationType | ## Monitoraggio a livello di mansione Amazon EMR Serverless invia i seguenti parametri a livello di processo ogni minuto. Amazon CloudWatch Puoi accedere ai valori delle metriche per le esecuzioni aggregate dei processi in base allo stato di esecuzione del processo. *L'unità per ciascuna metrica è il conteggio.* **Metriche a livello di job EMR Serverless** | Metrica | Description | Dimensione | | --- | --- | --- | | SubmittedJobs | Il numero di lavori in uno stato Inviato. | ApplicationId, ApplicationName | | PendingJobs | Il numero di lavori in uno stato In sospeso. | ApplicationId, ApplicationName | | ScheduledJobs | Il numero di lavori in uno stato Pianificato. | ApplicationId, ApplicationName | | RunningJobs | Il numero di lavori in uno stato In esecuzione. | ApplicationId, ApplicationName | | SuccessJobs | Il numero di lavori in uno stato di successo. | ApplicationId, ApplicationName | | FailedJobs | Il numero di lavori in uno stato Non riuscito. | ApplicationId, ApplicationName | | CancellingJobs | Il numero di lavori in uno stato di annullamento. | ApplicationId, ApplicationName | | CancelledJobs | Il numero di lavori in uno stato annullato. | ApplicationId, ApplicationName | È possibile monitorare le metriche specifiche del motore per l'esecuzione e il completamento dei job EMR Serverless con un'applicazione specifica del motore. UIs Quando si accede all'interfaccia utente per un processo in esecuzione, l'interfaccia utente live dell'applicazione viene visualizzata con aggiornamenti in tempo reale. Quando si accede all'interfaccia utente per un lavoro completato, viene visualizzata l'interfaccia utente persistente dell'app. **Esecuzione di processi** Per eseguire lavori EMR Serverless, accedi a un'interfaccia in tempo reale che fornisce metriche specifiche del motore. Puoi utilizzare l'interfaccia utente di Apache Spark o l'interfaccia utente di Hive Tez per monitorare ed eseguire il debug dei lavori. Per accedervi UIs, usa la console EMR Studio o richiedi un endpoint URL sicuro con. AWS Command Line Interface **Lavori completati** Per i job EMR Serverless completati, usa lo Spark History Server o l'interfaccia utente Persistent Hive Tez per accedere ai dettagli, alle fasi, alle attività e alle metriche dei job Spark o Hive eseguiti. Per accedervi UIs, usa la console EMR Studio o richiedi un endpoint URL sicuro con. AWS Command Line Interface ## Monitoraggio a livello di Job Worker Amazon EMR Serverless invia ad Amazon i seguenti parametri a livello di job worker disponibili nel `AWS/EMRServerless` namespace e nel gruppo di metrici. `Job Worker Metrics` CloudWatch EMR Serverless raccoglie punti dati dai singoli lavoratori durante le esecuzioni dei lavori a livello di mansione, tipo di lavoratore e livello. capacity-allocation-type È possibile utilizzarlo `ApplicationId` come dimensione per monitorare più lavori che appartengono alla stessa applicazione. **Nota** Per visualizzare la CPU e la memoria totali utilizzate da un job EMR Serverless durante la visualizzazione delle metriche nella CloudWatch console Amazon, utilizza la statistica come somma e il periodo come 1 minuto. **Metriche EMR Serverless a livello di job worker** | Metrica | Description | Unità | Dimensione | | --- | --- | --- | --- | | WorkerCpuAllocated | Il numero totale di core vCPU allocati per i lavoratori durante l'esecuzione di un job. | VPCU | JobId, JobName, ApplicationId, ApplicationName, WorkerType e CapacityAllocationType | | WorkerCpuUsed | Il numero totale di core vCPU utilizzati dai lavoratori in un job run. | VPCU | JobId, JobName, ApplicationId, ApplicationName, WorkerType e CapacityAllocationType | | WorkerMemoryAllocated | Memoria totale in GB allocata per i lavoratori durante l'esecuzione di un processo. | Gigabyte (GB) | JobId, JobName, ApplicationId, ApplicationName, WorkerType e CapacityAllocationType | | WorkerMemoryUsed | Memoria totale in GB utilizzata dai lavoratori durante l'esecuzione di un processo. | Gigabyte (GB) | JobId, JobName, ApplicationId, ApplicationName, WorkerType e CapacityAllocationType | | WorkerEphemeralStorageAllocated | Il numero di byte di storage temporaneo allocato ai lavoratori durante l'esecuzione di un job. | Gigabyte (GB) | JobId, JobName, ApplicationId, ApplicationName, WorkerType e CapacityAllocationType | | WorkerEphemeralStorageUsed | Il numero di byte di storage temporaneo utilizzati dai lavoratori durante l'esecuzione di un processo. | Gigabyte (GB) | JobId, JobName, ApplicationId, ApplicationName, WorkerType e CapacityAllocationType | | WorkerStorageReadBytes | Il numero di byte letti dallo storage dai lavoratori durante l'esecuzione di un job. | Byte | JobId, JobName, ApplicationId, ApplicationName, WorkerType e CapacityAllocationType | | WorkerStorageWriteBytes | Il numero di byte scritti nello storage dai lavoratori durante l'esecuzione di un job. | Byte | JobId, JobName, ApplicationId, ApplicationName, WorkerType e CapacityAllocationType | I passaggi seguenti descrivono come accedere ai vari tipi di metriche. ------ #### [ Console ] **Per accedere all'interfaccia utente dell'applicazione con la console** 1. Accedi alla tua applicazione EMR Serverless su EMR Studio con le istruzioni in [Guida introduttiva](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/getting-started.html#gs-console) dalla console. 1. Per accedere all'applicazione UIs e ai log specifici del motore per un processo in esecuzione: 1. Scegli un lavoro con uno stato. `RUNNING` 1. Seleziona il lavoro nella pagina dei **dettagli della candidatura** o vai alla pagina dei **dettagli del lavoro** relativa al tuo lavoro. 1. Nel menu a discesa **Display UI**, scegli **Spark UI o Hive Tez UI** **per accedere all'interfaccia utente dell'**applicazione per il tuo tipo di lavoro. 1. **Per accedere ai log del motore Spark, vai alla scheda **Executors** nell'interfaccia utente Spark e scegli il link Logs per il driver.** Per accedere ai log del motore Hive, scegli il link Logs per il **DAG** appropriato nell'interfaccia utente di Hive Tez. 1. Per accedere all'applicazione e ai log specifici del motore per un lavoro completato: UIs 1. Scegli un lavoro con uno stato. `SUCCESS` 1. Seleziona il lavoro nella pagina dei **dettagli della candidatura** o vai alla pagina dei **dettagli del lavoro**. 1. Nel menu a discesa **Display UI**, scegli **Spark History Server** o **Persistent Hive Tez UI per accedere all'interfaccia utente** dell'applicazione per il tuo tipo di lavoro. 1. **Per accedere ai log del motore Spark, vai alla scheda **Executors** nell'interfaccia utente Spark e scegli il link Logs per il driver.** Per accedere ai log del motore Hive, scegli il link Logs per il **DAG** appropriato nell'interfaccia utente di Hive Tez. ------ #### [ AWS CLI ] **Per accedere all'interfaccia utente dell'applicazione con AWS CLI** + Per generare un URL da utilizzare per accedere all'interfaccia utente dell'applicazione per i lavori in esecuzione e completati, chiama l'`GetDashboardForJobRun`API. ``` aws emr-serverless get-dashboard-for-job-run / --application-id / --job-run-id ``` L'URL generato è valido per un'ora. ------ # Monitora i parametri di Spark con Amazon Managed Service for Prometheus Con le versioni 7.1.0 e successive di Amazon EMR, puoi integrare EMR Serverless con Amazon Managed Service for Prometheus per raccogliere i parametri di Apache Spark per lavori e applicazioni EMR Serverless. Questa integrazione è disponibile quando si invia un lavoro o si crea un'applicazione utilizzando la AWS console, l'API EMR Serverless o il. AWS CLI ## Prerequisiti Prima di poter fornire i parametri Spark ad Amazon Managed Service for Prometheus, completa i seguenti prerequisiti. + [Crea un'area di lavoro Amazon Managed Service per Prometheus.](https://docs.aws.amazon.com/prometheus/latest/userguide/AMP-onboard-create-workspace.html) Questo Workspace funge da endpoint di acquisizione. Prendi nota dell'URL visualizzato per **Endpoint** - URL di scrittura remota. È necessario specificare l'URL quando si crea l'applicazione EMR Serverless. + Per concedere l'accesso delle tue offerte di lavoro ad Amazon Managed Service for Prometheus a scopo di monitoraggio, aggiungi la seguente politica al tuo ruolo di esecuzione del lavoro. ``` { "Sid": "AccessToPrometheus", "Effect": "Allow", "Action": ["aps:RemoteWrite"], "Resource": "arn:aws:aps:::workspace/" } ``` ## Configurazione **Per utilizzare la AWS console per creare un'applicazione integrata con Amazon Managed Service for Prometheus** 1. Consulta la sezione [Guida introduttiva ad Amazon EMR Serverless](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/getting-started.html ) per creare un'applicazione. 1. Durante la creazione di un'applicazione, scegli **Usa impostazioni personalizzate**, quindi configura l'applicazione specificando le informazioni nei campi che desideri configurare. 1. In **Application logs and metrics**, scegli **Deliver engine metrics to Amazon Managed Service for Prometheus, quindi specifica l'URL di scrittura remota**. 1. **Specificate le altre impostazioni di configurazione desiderate, quindi scegliete Crea e avvia l'applicazione.** **Usa la nostra AWS CLI API serverless EMR** Puoi anche utilizzare l'API AWS CLI o EMR Serverless per integrare la tua applicazione EMR Serverless con Amazon Managed Service for Prometheus quando esegui i comandi o. `create-application` `start-job-run` ------ #### [ create-application ] ``` aws emr-serverless create-application \ --release-label emr-7.1.0 \ --type "SPARK" \ --monitoring-configuration '{ "prometheusMonitoringConfiguration": { "remoteWriteUrl": "https://aps-workspaces..amazonaws.com/workspaces//api/v1/remote_write" } }' ``` ------ #### [ start-job-run ] ``` aws emr-serverless start-job-run \ --application-id \ --execution-role-arn \ --job-driver '{ "sparkSubmit": { "entryPoint": "local:///usr/lib/spark/examples/src/main/python/pi.py", "entryPointArguments": ["10000"], "sparkSubmitParameters": "--conf spark.dynamicAllocation.maxExecutors=10" } }' \ --configuration-overrides '{ "monitoringConfiguration": { "prometheusMonitoringConfiguration": { "remoteWriteUrl": "https://aps-workspaces..amazonaws.com/workspaces//api/v1/remote_write" } } }' ``` ------ L'inclusione `prometheusMonitoringConfiguration` nel comando indica che EMR Serverless deve eseguire il job Spark con un agente che raccoglie le metriche Spark e le scrive sul tuo endpoint per Amazon Managed Service for `remoteWriteUrl` Prometheus. Puoi quindi utilizzare le metriche Spark in Amazon Managed Service for Prometheus per la visualizzazione, gli avvisi e l'analisi. ## Proprietà di configurazione avanzate EMR Serverless utilizza un componente all'interno di Spark denominato `PrometheusServlet` per raccogliere le metriche Spark e traduce i dati sulle prestazioni in dati compatibili con Amazon Managed Service for Prometheus. Per impostazione predefinita, EMR Serverless imposta i valori predefiniti in Spark e analizza le metriche del driver e dell'esecutore quando invii un lavoro utilizzando. `PrometheusMonitoringConfiguration` La tabella seguente descrive tutte le proprietà configurate quando si invia un job Spark che invia metriche ad Amazon Managed Service for Prometheus. | Proprietà Spark | Valore predefinito | Description | | --- | --- | --- | | spark.metrics.conf.\$1.sink.prometheusServlet.class | org.apache.spark.metrics.sink. PrometheusServlet | La classe utilizzata da Spark per inviare metriche ad Amazon Managed Service for Prometheus. Per ignorare il comportamento predefinito, specifica la tua classe personalizzata. | | spark.metrics.conf.\$1.source.jvm.class | org.apache.spark.metrics.source. JvmSource | La classe utilizzata da Spark per raccogliere e inviare metriche cruciali dalla macchina virtuale Java sottostante. Per interrompere la raccolta delle metriche JVM, disabilita questa proprietà impostandola su una stringa vuota, ad esempio. `""` Per ignorare il comportamento predefinito, specificate la vostra classe personalizzata. | | spark.metrics.conf.driver.sink.prometheusServlet.path | /metrics/prometheus | L'URL distinto che Amazon Managed Service for Prometheus utilizza per raccogliere le metriche dal driver. Per ignorare il comportamento predefinito, specifica il tuo percorso. Per interrompere la raccolta delle metriche dei driver, disattivate questa proprietà impostandola su una stringa vuota, ad esempio. `""` | | spark.metrics.conf.executor.sink.prometheusServlet.path | /metrics/executor/prometheus | L'URL distinto che Amazon Managed Service for Prometheus utilizza per raccogliere le metriche dell'esecutore. Per ignorare il comportamento predefinito, specifica il tuo percorso. Per interrompere la raccolta delle metriche degli esecutori, disabilitate questa proprietà impostandola su una stringa vuota, ad esempio. `""` | [Per ulteriori informazioni sulle metriche Spark, consulta le metriche di Apache Spark.](https://spark.apache.org/docs/3.5.0/monitoring.html#metrics) ## Considerazioni e limitazioni Quando utilizzi Amazon Managed Service for Prometheus per raccogliere metriche da EMR Serverless, considera le seguenti considerazioni e limitazioni. + Il supporto per l'utilizzo di Amazon Managed Service for Prometheus con EMR Serverless è disponibile solo Regioni AWS nei paesi in [cui Amazon](https://docs.aws.amazon.com/general/latest/gr/prometheus-service.html) Managed Service for Prometheus è generalmente disponibile. + Far sì che l'agente raccolga i parametri Spark su Amazon Managed Service for Prometheus richiede più risorse da parte dei lavoratori. Se si sceglie un worker di dimensioni inferiori, ad esempio un lavoratore vCPU, il tempo di esecuzione del lavoro potrebbe aumentare. + Il supporto per l'utilizzo di Amazon Managed Service for Prometheus con EMR Serverless è disponibile solo per le versioni 7.1.0 e successive di Amazon EMR. + Amazon Managed Service for Prometheus deve essere distribuito nello stesso account in cui esegui EMR Serverless per raccogliere i parametri. # Metriche di utilizzo EMR Serverless Puoi utilizzare i parametri di CloudWatch utilizzo di Amazon per fornire visibilità sulle risorse utilizzate dal tuo account. Utilizza queste metriche per visualizzare l'utilizzo del servizio su CloudWatch grafici e dashboard. Le metriche di utilizzo di EMR Serverless corrispondono a Service Quotas. È possibile configurare gli allarmi che avvisano quando l'uso si avvicina a una quota di servizio. Per ulteriori informazioni, consulta [Service Quotas e Amazon CloudWatch alarms](https://docs.aws.amazon.com/servicequotas/latest/userguide/configure-cloudwatch.html) nella *Service* Quotas User Guide. Per ulteriori informazioni sulle quote dei servizi EMR Serverless, fare riferimento a. [Punti finali e quote per EMR Serverless](endpoints-quotas.md) ## Metriche di utilizzo delle quote di servizio per EMR Serverless EMR Serverless pubblica le seguenti metriche di utilizzo delle quote di servizio nel namespace. `AWS/Usage` **** | Metrica | Description | | --- | --- | | `ResourceCount` | Il numero totale della risorsa specificata in esecuzione sul tuo account. La risorsa è definita dalle [dimensioni](#usage-metrics-dimensions) associate alla metrica. | ## Dimensioni per le metriche di utilizzo delle quote di servizio EMR Serverless È possibile utilizzare le seguenti dimensioni per perfezionare le metriche di utilizzo pubblicate da EMR Serverless. **** | Dimensione | Valore | Description | | --- | --- | --- | | `Service` | EMR Serverless | Il nome del file che contiene la risorsa. Servizio AWS | | `Type` | Risorsa | Il tipo di entità segnalata da EMR Serverless. | | `Resource` | VPCU | Il tipo di risorsa monitorata da EMR Serverless. | | `Class` | Nessuno | La classe di risorse monitorata da EMR Serverless. | # Automazione di EMR Serverless con Amazon EventBridge È possibile Amazon EventBridge utilizzarlo per automatizzare Servizi AWS e rispondere automaticamente agli eventi di sistema, ad esempio problemi di disponibilità delle applicazioni o modifiche delle risorse. EventBridge offre un flusso quasi in tempo reale di eventi di sistema che descrivono i cambiamenti nelle AWS risorse. Puoi compilare regole semplici che indichino quali eventi sono considerati di interesse per te e quali azioni automatizzate intraprendere quando un evento corrisponde a una regola. Con EventBridge, puoi automaticamente: + Invocare una funzione AWS Lambda + Inoltrare un evento ad Amazon Kinesis Data Streams + Attiva una macchina a stati AWS Step Functions + Notifica un argomento Amazon SNS o una coda Amazon SQS Ad esempio, se lo utilizzi EventBridge con EMR Serverless, puoi attivare una AWS Lambda funzione quando un processo ETL ha esito positivo o notificare un argomento di Amazon SNS quando un processo ETL fallisce. EMR Serverless emette quattro tipi di eventi: + Eventi di modifica dello stato dell'applicazione: eventi che generano ogni cambiamento di stato di un'applicazione. Per ulteriori informazioni sugli stati delle applicazioni, fare riferimento a[Stati dell'applicazione](applications.md#application-states). + Eventi di modifica dello stato del job run: eventi che generano ogni modifica di stato di un job run. Per ulteriori informazioni su, fare riferimento a. [Stati delle esecuzioni di processi](job-states.md) + Eventi di ripetizione del processo: eventi che generano ogni nuovo tentativo di un processo eseguito dalle versioni 7.1.0 e successive di Amazon EMR Serverless. + Eventi di aggiornamento sull'utilizzo delle risorse del lavoro: gli eventi che emettono aggiornamenti sull'utilizzo delle risorse per un processo vengono eseguiti a intervalli prossimi a 30 minuti. ## Esempi di eventi EMR Serverless EventBridge Gli eventi segnalati da EMR Serverless hanno un valore `aws.emr-serverless` assegnato a`source`, come illustrato negli esempi seguenti. **Evento di modifica dello stato dell'applicazione** L'evento di esempio seguente mostra un'applicazione nello `CREATING` stato. ``` { "version": "0", "id": "9fd3cf79-1ff1-b633-4dd9-34508dc1e660", "detail-type": "EMR Serverless Application State Change", "source": "aws.emr-serverless", "account": "123456789012", "time": "2022-05-31T21:16:31Z", "region": "us-east-1", "resources": [], "detail": { "applicationId": "00f1cbsc6anuij25", "applicationName": "3965ad00-8fba-4932-a6c8-ded32786fd42", "arn": "arn:aws:emr-serverless:us-east-1:111122223333:/applications/00f1cbsc6anuij25", "releaseLabel": "emr-6.6.0", "state": "CREATING", "type": "HIVE", "createdAt": "2022-05-31T21:16:31.547953Z", "updatedAt": "2022-05-31T21:16:31.547970Z", "autoStopConfig": { "enabled": true, "idleTimeout": 15 }, "autoStartConfig": { "enabled": true } } } ``` **Evento di modifica dello stato di Job run** L'evento di esempio seguente mostra l'esecuzione di un processo che passa da `SCHEDULED` uno `RUNNING` stato all'altro. ``` { "version": "0", "id": "00df3ec6-5da1-36e6-ab71-20f0de68f8a0", "detail-type": "EMR Serverless Job Run State Change", "source": "aws.emr-serverless", "account": "123456789012", "time": "2022-05-31T21:07:42Z", "region": "us-east-1", "resources": [], "detail": { "jobRunId": "00f1cbn5g4bb0c01", "applicationId": "00f1982r1uukb925", "arn": "arn:aws:emr-serverless:us-east-1:123456789012:/applications/00f1982r1uukb925/jobruns/00f1cbn5g4bb0c01", "releaseLabel": "emr-6.6.0", "state": "RUNNING", "previousState": "SCHEDULED", "createdBy": "arn:aws:sts::123456789012:assumed-role/TestRole-402dcef3ad14993c15d28263f64381e4cda34775/6622b6233b6d42f59c25dd2637346242", "updatedAt": "2022-05-31T21:07:42.299487Z", "createdAt": "2022-05-31T21:07:25.325900Z" } } ``` **Evento Job run Retry** Di seguito è riportato un esempio di evento Job Run Retry. ``` { "version": "0", "id": "00df3ec6-5da1-36e6-ab71-20f0de68f8a0", "detail-type": "EMR Serverless Job Run Retry", "source": "aws.emr-serverless", "account": "123456789012", "time": "2022-05-31T21:07:42Z", "region": "us-east-1", "resources": [], "detail": { "jobRunId": "00f1cbn5g4bb0c01", "applicationId": "00f1982r1uukb925", "arn": "arn:aws:emr-serverless:us-east-1:123456789012:/applications/00f1982r1uukb925/jobruns/00f1cbn5g4bb0c01", "releaseLabel": "emr-6.6.0", "createdBy": "arn:aws:sts::123456789012:assumed-role/TestRole-402dcef3ad14993c15d28263f64381e4cda34775/6622b6233b6d42f59c25dd2637346242", "updatedAt": "2022-05-31T21:07:42.299487Z", "createdAt": "2022-05-31T21:07:25.325900Z", //Attempt Details "previousAttempt": 1, "previousAttemptState": "FAILED", "previousAttemptCreatedAt": "2022-05-31T21:07:25.325900Z", "previousAttemptEndedAt": "2022-05-31T21:07:30.325900Z", "newAttempt": 2, "newAttemptCreatedAt": "2022-05-31T21:07:30.325900Z" } } ``` **Aggiornamento sull'utilizzo delle risorse Job** L'evento di esempio seguente mostra l'aggiornamento finale sull'utilizzo delle risorse per un processo che è passato allo stato terminale dopo l'esecuzione. ``` { "version": "0", "id": "00df3ec6-5da1-36e6-ab71-20f0de68f8a0", "detail-type": "EMR Serverless Job Resource Utilization Update", "source": "aws.emr-serverless", "account": "123456789012", "time": "2022-05-31T21:07:42Z", "region": "us-east-1", "resources": [ "arn:aws:emr-serverless:us-east-1:123456789012:/applications/00f1982r1uukb925/jobruns/00f1cbn5g4bb0c01" ], "detail": { "applicationId": "00f1982r1uukb925", "jobRunId": "00f1cbn5g4bb0c01", "attempt": 1, "mode": "BATCH", "createdAt": "2022-05-31T21:07:25.325900Z", "startedAt": "2022-05-31T21:07:26.123Z", "calculatedFrom": "2022-05-31T21:07:42.299487Z", "calculatedTo": "2022-05-31T21:07:30.325900Z", "resourceUtilizationFinal": true, "resourceUtilizationForInterval": { "vCPUHour": 0.023, "memoryGBHour": 0.114, "storageGBHour": 0.228 }, "billedResourceUtilizationForInterval": { "vCPUHour": 0.067, "memoryGBHour": 0.333, "storageGBHour": 0 }, "totalResourceUtilization": { "vCPUHour": 0.023, "memoryGBHour": 0.114, "storageGBHour": 0.228 }, "totalBilledResourceUtilization": { "vCPUHour": 0.067, "memoryGBHour": 0.333, "storageGBHour": 0 } } } ``` Il campo **StartedAt** sarà presente solo nel caso in cui il lavoro sia passato allo stato di esecuzione.