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à. # Esegui carichi di lavoro interattivi con EMR Serverless tramite un endpoint Apache Livy Con le versioni 6.14.0 e successive di Amazon EMR, crea e abilita un endpoint Apache Livy durante la creazione di un'applicazione EMR Serverless ed esegui carichi di lavoro interattivi tramite notebook ospitati autonomamente o con un client personalizzato. Un endpoint Apache Livy offre i seguenti vantaggi: + Puoi connetterti in modo sicuro a un endpoint Apache Livy tramite i notebook Jupyter e gestire i carichi di lavoro Apache Spark con l'interfaccia REST di Apache Livy. + Utilizza le operazioni dell'API REST di Apache Livy per applicazioni Web interattive che utilizzano i dati dei carichi di lavoro Apache Spark. ## Prerequisiti Per utilizzare un endpoint Apache Livy con EMR Serverless, soddisfi i seguenti requisiti: + Completa i passaggi descritti in [Guida introduttiva ad Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/getting-started.html) Serverless. + Per eseguire carichi di lavoro interattivi tramite gli endpoint Apache Livy, sono necessari determinati permessi e ruoli. Per ulteriori informazioni, consulta Autorizzazioni [richieste per carichi di lavoro interattivi.](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/interactive-workloads.html#interactive-permissions) ## Autorizzazioni richieste Oltre alle autorizzazioni necessarie per accedere a EMR Serverless, aggiungi anche le seguenti autorizzazioni al tuo ruolo IAM per accedere a un endpoint Apache Livy ed eseguire applicazioni: + `emr-serverless:AccessLivyEndpoints`— concede l'autorizzazione per accedere e connettersi all'applicazione abilitata per Livy specificata come. `Resource` È necessaria questa autorizzazione per eseguire le operazioni dell'API REST disponibili dall'endpoint Apache Livy. + `iam:PassRole`— concede l'autorizzazione ad accedere al ruolo di esecuzione IAM durante la creazione della sessione Apache Livy. EMR Serverless utilizzerà questo ruolo per eseguire i carichi di lavoro. + `emr-serverless:GetDashboardForJobRun`— concede l'autorizzazione a generare l'interfaccia utente di Spark Live e i link ai registri dei driver e fornisce l'accesso ai log come parte dei risultati della sessione di Apache Livy. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "EMRServerlessInteractiveAccess", "Effect": "Allow", "Action": [ "emr-serverless:AccessLivyEndpoints" ], "Resource": [ "arn:aws:emr-serverless:*:123456789012:/applications/*" ] }, { "Sid": "EMRServerlessRuntimeRoleAccess", "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::123456789012:role/EMRServerlessExecutionRole" ], "Condition": { "StringLike": { "iam:PassedToService": "emr-serverless.amazonaws.com" } } }, { "Sid": "EMRServerlessDashboardAccess", "Effect": "Allow", "Action": [ "emr-serverless:GetDashboardForJobRun" ], "Resource": [ "arn:aws:emr-serverless:*:123456789012:/applications/*" ] } ] } ``` ------ ## Nozioni di base Per creare un'applicazione compatibile con Apache Livy ed eseguirla, segui questi passaggi. 1. Per creare un'applicazione compatibile con Apache Livy, esegui il comando seguente. ``` aws emr-serverless create-application \ --name {{my-application-name}} \ --type '{{application-type}}' \ --release-label --interactive-configuration '{"livyEndpointEnabled": true}' ``` 1. Dopo che EMR Serverless ha creato l'applicazione, avviatela per rendere disponibile l'endpoint Apache Livy. ``` aws emr-serverless start-application \ --application-id {{application-id}} ``` Utilizzate il seguente comando per verificare lo stato della vostra applicazione. Una volta raggiunto lo stato`STARTED`, accedi all'endpoint Apache Livy. ``` aws emr-serverless get-application \ --region {{}} --application-id {{>application_id>}} ``` 1. Utilizza il seguente URL per accedere all'endpoint: ``` https://_{{}}_.livy.emr-serverless-services._{{}}_.amazonaws.com ``` Una volta che l'endpoint è pronto, invia i carichi di lavoro in base al tuo caso d'uso. È necessario firmare ogni richiesta all'endpoint con [il SIGv4 protocollo](https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html) e inserire un'intestazione di autorizzazione. È possibile utilizzare i seguenti metodi per eseguire carichi di lavoro: + Client HTTP: invia le operazioni dell'API degli endpoint Apache Livy con un client HTTP personalizzato. + Kernel Sparkmagic: esegui il kernel sparkmagic localmente e invia query interattive con i notebook Jupyter. ### Client HTTP Per creare una sessione di Apache Livy, inserisci il parametro del corpo della richiesta. `emr-serverless.session.executionRoleArn` `conf` L'esempio seguente è un esempio `POST /sessions` di richiesta. ``` { "kind": "pyspark", "heartbeatTimeoutInSecond": 60, "conf": { "emr-serverless.session.executionRoleArn": "{{}}" } } ``` La tabella seguente descrive tutte le operazioni dell'API Apache Livy disponibili. | Operazione API | Description | | --- | --- | | GET /sessions | Restituisce un elenco di tutte le sessioni interattive attive. | | POST /sessioni | Crea una nuova sessione interattiva tramite spark o pyspark. | | GET /sessions/ < > {{sessionId}} | Restituisce le informazioni sulla sessione. | | GET /sessions/ < >/state {{sessionId}} | Restituisce lo stato della sessione. | | ELIMINA /sessions/ < > {{sessionId}} | Interrompe ed elimina la sessione. | | GET /sessions/ < >/statements {{sessionId}} | Restituisce tutte le istruzioni di una sessione. | | POST /sessions/ < >/dichiarazioni {{sessionId}} | Esegue un'istruzione in una sessione. | | GET /sessions/ < >/statements/< > {{sessionId}} {{statementId}} | Restituisce i dettagli dell'istruzione specificata in una sessione. | | POST /sessions/ < >/statements/< >/cancel {{sessionId}} {{statementId}} | Annulla l'istruzione specificata in questa sessione. | #### Invio di richieste all'endpoint Apache Livy È inoltre possibile inviare richieste direttamente all'endpoint Apache Livy da un client HTTP. In questo modo è possibile eseguire in remoto il codice per i casi d'uso al di fuori di un notebook. Prima di iniziare a inviare richieste all'endpoint, assicurati di aver installato le seguenti librerie: ``` pip3 install botocore awscrt requests ``` Di seguito è riportato un esempio di script Python per inviare richieste HTTP direttamente a un endpoint: ``` from botocore import crt import requests from botocore.awsrequest import AWSRequest from botocore.credentials import Credentials import botocore.session import json, pprint, textwrap endpoint = 'https://{{}}.livy.emr-serverless-services.{{}}.amazonaws.com' headers = {'Content-Type': 'application/json'} session = botocore.session.Session() signer = crt.auth.CrtS3SigV4Auth(session.get_credentials(), 'emr-serverless', '{{}}') ### Create session request data = {'kind': 'pyspark', 'heartbeatTimeoutInSecond': 60, 'conf': { 'emr-serverless.session.executionRoleArn': 'arn:aws:iam::123456789012:role/role1'}} request = AWSRequest(method='POST', url=endpoint + "/sessions", data=json.dumps(data), headers=headers) request.context["payload_signing_enabled"] = False signer.add_auth(request) prepped = request.prepare() r = requests.post(prepped.url, headers=prepped.headers, data=json.dumps(data)) pprint.pprint(r.json()) ### List Sessions Request request = AWSRequest(method='GET', url=endpoint + "/sessions", headers=headers) request.context["payload_signing_enabled"] = False signer.add_auth(request) prepped = request.prepare() r2 = requests.get(prepped.url, headers=prepped.headers) pprint.pprint(r2.json()) ### Get session state session_url = endpoint + r.headers['location'] request = AWSRequest(method='GET', url=session_url, headers=headers) request.context["payload_signing_enabled"] = False signer.add_auth(request) prepped = request.prepare() r3 = requests.get(prepped.url, headers=prepped.headers) pprint.pprint(r3.json()) ### Submit Statement data = { 'code': "1 + 1" } statements_url = endpoint + r.headers['location'] + "/statements" request = AWSRequest(method='POST', url=statements_url, data=json.dumps(data), headers=headers) request.context["payload_signing_enabled"] = False signer.add_auth(request) prepped = request.prepare() r4 = requests.post(prepped.url, headers=prepped.headers, data=json.dumps(data)) pprint.pprint(r4.json()) ### Check statements results specific_statement_url = endpoint + r4.headers['location'] request = AWSRequest(method='GET', url=specific_statement_url, headers=headers) request.context["payload_signing_enabled"] = False signer.add_auth(request) prepped = request.prepare() r5 = requests.get(prepped.url, headers=prepped.headers) pprint.pprint(r5.json()) ### Delete session session_url = endpoint + r.headers['location'] request = AWSRequest(method='DELETE', url=session_url, headers=headers) request.context["payload_signing_enabled"] = False signer.add_auth(request) prepped = request.prepare() r6 = requests.delete(prepped.url, headers=prepped.headers) pprint.pprint(r6.json()) ``` ### Kernel Sparkmagic Prima di installare sparkmagic, assicurati di aver configurato AWS le credenziali nell'istanza in cui desideri installare sparkmagic 1. [Installa sparkmagic seguendo i passaggi di installazione.](https://github.com/jupyter-incubator/sparkmagic?tab=readme-ov-file#installation) Nota che esegui solo i primi quattro passaggi. 1. Il kernel sparkmagic supporta autenticatori personalizzati, quindi puoi integrare un autenticatore con il kernel sparkmagic in modo che ogni richiesta venga firmata. SIGv4 1. Installa l'autenticatore personalizzato EMR Serverless. ``` pip install emr-serverless-customauth ``` 1. Ora fornisci il percorso dell'autenticatore personalizzato e l'URL dell'endpoint Apache Livy nel file json di configurazione sparkmagic. Usa il seguente comando per aprire il file di configurazione. ``` vim ~/.sparkmagic/config.json ``` Di seguito è riportato un `config.json` file di esempio. ``` { "kernel_python_credentials" : { "username": "", "password": "", "url": "https://{{}}.livy.emr-serverless-services.{{}}.amazonaws.com", "auth": "Custom_Auth" }, "kernel_scala_credentials" : { "username": "", "password": "", "url": "https://{{}}.livy.emr-serverless-services.{{}}.amazonaws.com", "auth": "Custom_Auth" }, "authenticators": { "None": "sparkmagic.auth.customauth.Authenticator", "Basic_Access": "sparkmagic.auth.basic.Basic", "Custom_Auth": "emr_serverless_customauth.customauthenticator.EMRServerlessCustomSigV4Signer" }, "livy_session_startup_timeout_seconds": 600, "ignore_ssl_errors": false } ``` 1. Avvia Jupyter lab. Dovrebbe utilizzare l'autenticazione personalizzata impostata nell'ultimo passaggio. 1. Puoi quindi eseguire i seguenti comandi del notebook e il tuo codice per iniziare. ``` %%info //Returns the information about the current sessions. ``` ``` %%configure -f //Configure information specific to a session. We supply executionRoleArn in this example. Change it for your use case. { "driverMemory": "4g", "conf": { "emr-serverless.session.executionRoleArn": "arn:aws:iam::123456789012:role/{{JobExecutionRole}}" } } ``` ``` {{}}//Run your code to start the session ``` Internamente, ogni istruzione richiama tutte le operazioni dell'API Apache Livy tramite l'URL dell'endpoint Apache Livy configurato. È quindi possibile scrivere le istruzioni in base al caso d'uso. ## Considerazioni Prendi in considerazione le seguenti considerazioni quando esegui carichi di lavoro interattivi tramite endpoint Apache Livy. + EMR Serverless mantiene l'isolamento a livello di sessione utilizzando il caller principal. Il principale chiamante che crea la sessione è l'unico che può accedere a tale sessione. Per un isolamento più granulare, configura un'identità di origine quando assumi le credenziali. In questo caso, EMR Serverless applica l'isolamento a livello di sessione in base al principale chiamante e all'identità di origine. Per ulteriori informazioni sull'identità di origine, fare riferimento a [Monitoraggio e controllo](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_monitor.html#id_credentials_temp_control-access_monitor-specify-sourceid) delle azioni intraprese con i ruoli assunti. + Gli endpoint Apache Livy sono supportati con le versioni EMR Serverless 6.14.0 e successive. + Gli endpoint Apache Livy sono supportati solo per il motore Apache Spark. + Gli endpoint Apache Livy supportano Scala Spark e. PySpark + Per impostazione predefinita, `autoStopConfig` è abilitato nelle tue applicazioni. Ciò significa che le applicazioni si chiudono dopo 15 minuti di inattività. Puoi modificare questa configurazione come parte della tua `create-application` `update-application` richiesta. + È possibile eseguire fino a 25 sessioni simultanee su una singola applicazione abilitata per endpoint Apache Livy. + Per una migliore esperienza di avvio, suggeriamo di configurare la capacità preinizializzata per driver ed esecutori. + È necessario avviare manualmente l'applicazione prima di connettersi all'endpoint Apache Livy. + È necessario disporre di una quota di servizi vCPU sufficiente per Account AWS eseguire carichi di lavoro interattivi con l'endpoint Apache Livy. Suggeriamo almeno 24 vCPU. + Il timeout di sessione predefinito di Apache Livy è di 1 ora. Se non esegui le istruzioni per un'ora, Apache Livy elimina la sessione e rilascia il driver e gli executor. Dalla versione emr-7.8.0, questo valore può essere impostato specificando il `ttl` parametro come parte della `/sessions POST` richiesta Livy, ad esempio `2h` (ore), (minuti), (secondi), (`120m`millisecondi). `7200s` `7200000ms` **Nota** Questa configurazione non può essere modificata prima di emr-7.8.0. Di seguito è riportato un esempio di corpo della richiesta. `POST /sessions` ``` { "kind": "pyspark", "heartbeatTimeoutInSecond": 60, "conf": { "emr-serverless.session.executionRoleArn": "{{executionRoleArn}}" }, "ttl": "2h" } ``` + A partire dalla versione emr-7.8.0 di Amazon EMR per applicazioni con controllo granulare degli accessi tramite LakeFormation enabled, l'impostazione può essere disabilitata per sessione. Per ulteriori informazioni sull'abilitazione del controllo granulare degli accessi per un'applicazione EMR Serverless, fare riferimento [a Metodi per](emr-serverless-lf-enable.html#emr-serverless-lf-enable-config) il controllo granulare degli accessi. **Nota** Lake Formation non può essere abilitato per una sessione se non è stato abilitato per un'applicazione. Di seguito è riportato un esempio di corpo della `POST /sessions` richiesta. ``` { "kind": "pyspark", "heartbeatTimeoutInSecond": 60, "conf": { "emr-serverless.session.executionRoleArn": "{{executionRoleArn}}" }, "spark.emr-serverless.lakeformation.enabled" : "false" } ``` + Solo le sessioni attive possono interagire con un endpoint Apache Livy. Una volta terminata, annullata o terminata la sessione, non è possibile accedervi tramite l'endpoint Apache Livy.