Esegui carichi di lavoro interattivi con EMR Serverless tramite un endpoint Apache Livy

Con le EMR versioni 6.14.0 e successive di Amazon, puoi creare e abilitare un endpoint Apache Livy mentre crei un'applicazione EMR Serverless ed eseguire 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 di Apache Livy. REST

• Usa le operazioni Apache Livy per applicazioni web interattive che utilizzano i dati dei carichi di lavoro Apache Spark. REST API

Prerequisiti

Per utilizzare un endpoint Apache Livy con EMR Serverless, devi soddisfare i seguenti requisiti:

• Completa la procedura descritta in Guida introduttiva ad Amazon EMR 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.

Autorizzazioni richieste

Oltre alle autorizzazioni richieste per accedere a EMR Serverless, devi aggiungere anche le seguenti autorizzazioni al tuo IAM ruolo 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 REST API le operazioni disponibili dall'endpoint Apache Livy.

• iam:PassRole— concede l'autorizzazione ad accedere al ruolo di IAM esecuzione durante la creazione della sessione Apache Livy. EMRServerless utilizzerà questo ruolo per eseguire i tuoi 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.

{
    "Version": "2012-10-17",
    "Statement": [{
            "Sid": "EMRServerlessInteractiveAccess",
            "Effect": "Allow",
            "Action": "emr-serverless:AccessLivyEndpoints",
            "Resource": "arn:aws:emr-serverless:<AWS_REGION>:account:/applications/*"
        },
        {
            "Sid": "EMRServerlessRuntimeRoleAccess",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "execution-role-ARN",
            "Condition": {
                "StringLike": {
                    "iam:PassedToService": "emr-serverless.amazonaws.com"
                }
            }
        },
        {
            "Sid": "EMRServerlessDashboardAccess",
            "Effect": "Allow",
            "Action": "emr-serverless:GetDashboardForJobRun",
            "Resource": "arn:aws:emr-serverless:<AWS_REGION>:account:/applications/*"
        }
    ]
}

Nozioni di base

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 <Amazon EMR-release-version>
   --interactive-configuration '{"livyEndpointEnabled": true}'

2. 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 statoSTARTED, puoi accedere all'endpoint Apache Livy.

   aws emr-serverless get-application \
   --region <AWS_REGION> --application-id >application_id>

3. Usa quanto segue URL per accedere all'endpoint:

   https://_<application-id>_.livy.emr-serverless-services._<AWS_REGION>_.amazonaws.com

Una volta che l'endpoint è pronto, puoi inviare carichi di lavoro in base al tuo caso d'uso. È necessario firmare ogni richiesta all'endpoint con il SIGv4 protocollo e inserire un'intestazione di autorizzazione. È possibile utilizzare i seguenti metodi per eseguire carichi di lavoro:

• HTTPclient: è necessario inviare le API operazioni relative agli endpoint Apache Livy con un client personalizzato. HTTP

• Kernel Sparkmagic: è necessario eseguire localmente il kernel sparkmagic e inviare query interattive con i notebook Jupyter.

HTTPclienti

Per creare una sessione di Apache Livy, devi inserire emr-serverless.session.executionRoleArn il conf parametro del corpo della richiesta. L'esempio seguente è un esempio POST /sessions di richiesta.

{    
    "kind": "pyspark",
    "heartbeatTimeoutInSecond": 60, 
    "conf": {
        "emr-serverless.session.executionRoleArn": "<executionRoleArn>"
    }
}

La tabella seguente descrive tutte le operazioni di Apache Livy API disponibili.

APIoperazione	Descrizione
GET/sessioni	Restituisce un elenco di tutte le sessioni interattive attive.
POST/sessioni	Crea una nuova sessione interattiva tramite spark o pyspark.
GET/sessioni/ <sessionId>	Restituisce le informazioni sulla sessione.
GET/sessions/ <sessionId/sessions//stato	Restituisce lo stato della sessione.
DELETE/sessions/ <sessionId>	Interrompe ed elimina la sessione.
GET/sessioni/ <sessionId/sessions//dichiarazioni	Restituisce tutte le istruzioni di una sessione.
POST/sessioni/ <sessionId/sessions//dichiarazioni	Esegue un'istruzione in una sessione.
GET/sessioni/ <sessionId/sessions//dichiarazioni/<statementId>	Restituisce i dettagli dell'istruzione specificata in una sessione.
POST/sessions/ <sessionId/sessions//dichiarazioni/<statementId>/dichiarazioni//annulla	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 HTTP richieste 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://<application_id>.livy.emr-serverless-services-<AWS_REGION>.amazonaws.com'
headers = {'Content-Type': 'application/json'}

session = botocore.session.Session()
signer = crt.auth.CrtS3SigV4Auth(session.get_credentials(), 'emr-serverless', '<AWS_REGION>')


### 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 credenziali nell'istanza in cui vuoi installare sparkmagic

1. Installa sparkmagic seguendo i passaggi di installazione. Nota che devi solo eseguire i primi quattro passaggi.

2. Il kernel sparkmagic supporta autenticatori personalizzati, quindi puoi integrare un autenticatore con il kernel sparkmagic in modo che ogni richiesta venga firmata. SIGv4

3. EMRInstalla l'autenticatore personalizzato Serverless.

   pip install emr-serverless-customauth

4. Ora fornisci il percorso dell'autenticatore personalizzato e dell'endpoint URL 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://<application-id>.livy.emr-serverless-services.<AWS_REGION>.amazonaws.com",
       "auth": "Custom_Auth"
     },
   
     "kernel_scala_credentials" : {
       "username": "",
       "password": "",
       "url": "https://<application-id>.livy.emr-serverless-services.<AWS_REGION>.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
   }

5. Avvia Jupyter lab. Dovrebbe utilizzare l'autenticazione personalizzata che hai impostato nell'ultimo passaggio.

6. 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"
       }
   }

   <your code>//Run your code to start the session

Internamente, ogni istruzione richiama ciascuna delle API operazioni di Apache Livy tramite l'endpoint Apache Livy configurato. URL È 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.

• EMRServerless 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, puoi configurare un'identità di origine quando assumi le credenziali. In questo caso, EMR Serverless applica l'isolamento a livello di sessione in base sia al principale chiamante che all'identità di origine. Per ulteriori informazioni sull'identità di origine, consulta Monitoraggio e controllo delle azioni intraprese con i ruoli presunti.

• Gli endpoint Apache Livy sono supportati dalle 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, si consiglia 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 CPU servizio v sufficiente nel Account AWS per eseguire carichi di lavoro interattivi con l'endpoint Apache Livy. Consigliamo almeno 24 v. CPU

• Il timeout di sessione predefinito di Apache Livy è di 1 ora. Se non si eseguono istruzioni per un'ora, Apache Livy elimina la sessione e rilascia il driver e gli esecutori. Non è possibile modificare questa configurazione.

• 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.