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 sessioni interattive con Amazon EMR Serverless tramite Spark Connect Con la versione di Amazon EMR `emr-7.13.0` e successive, puoi connetterti a un'applicazione Amazon EMR Serverless da PySpark client autogestiti come VS Code e notebook Jupyter utilizzando la sessione EMR Serverless con Apache Spark Connect. PyCharm APIs Spark Connect utilizza un'architettura client-server che disaccoppia il codice dell'applicazione dal processo del driver Spark. Sviluppi ed esegui il debug PySpark del codice nel tuo IDE locale mentre le operazioni Spark vengono eseguite sull'elaborazione EMR Serverless. Spark Connect offre i seguenti vantaggi: + Connect a EMR Serverless da qualsiasi PySpark client, inclusi notebook VS Code e PyCharm Jupyter. + Imposta punti di interruzione e analizza il PySpark codice nel tuo IDE mentre esegui in remoto su dati su scala di produzione. DataFrames Una sessione Spark Connect è una connessione gestita tra il PySpark client locale e un driver Spark in esecuzione su Amazon EMR Serverless. Quando avvii una sessione, EMR Serverless effettua il provisioning di un driver Spark e di esecutori per tuo conto. Il client locale invia DataFrame le operazioni SQL al driver, che le esegue in remoto. La sessione persiste finché non viene terminata o non raggiunge il timeout di inattività, quindi puoi eseguire più query in modo interattivo senza riavviare Spark. Ogni sessione ha il proprio URL dell'endpoint e il token di autenticazione che usi per connetterti. ## Autorizzazioni richieste Oltre alle autorizzazioni necessarie per accedere ad Amazon EMR Serverless, aggiungi anche le seguenti autorizzazioni al tuo ruolo IAM per accedere a un endpoint Spark Connect e gestire le sessioni Spark Connect: `emr-serverless:StartSession` Concede l'autorizzazione a creare una sessione Spark Connect sull'applicazione specificata come. `Resource` `emr-serverless:GetSessionEndpoint` Concede l'autorizzazione a recuperare l'URL dell'endpoint Spark Connect e il token di autenticazione per una sessione. `emr-serverless:GetSession` Concede l'autorizzazione per ottenere lo stato di una sessione. `emr-serverless:ListSessions` Concede l'autorizzazione a elencare le sessioni su un'applicazione. `emr-serverless:TerminateSession` Concede l'autorizzazione a terminare una sessione. `iam:PassRole` Concede l'autorizzazione ad accedere al ruolo di esecuzione IAM durante la creazione della sessione Spark Connect. Amazon EMR Serverless utilizza questo ruolo per eseguire i carichi di lavoro. `emr-serverless:GetResourceDashboard` Concede l'autorizzazione a generare l'URL dell'interfaccia utente Spark e fornisce l'accesso ai log della sessione. ``` { "Version": "2012-10-17", "Statement": [ { "Sid": "EMRServerlessApplicationLevelAccess", "Effect": "Allow", "Action": [ "emr-serverless:StartSession", "emr-serverless:ListSessions" ], "Resource": [ "arn:aws:emr-serverless:{{region}}:{{account-id}}:/applications/{{application-id}}" ] }, { "Sid": "EMRServerlessSessionLevelAccess", "Effect": "Allow", "Action": [ "emr-serverless:GetSession", "emr-serverless:GetSessionEndpoint", "emr-serverless:TerminateSession", "emr-serverless:GetResourceDashboard" ], "Resource": [ "arn:aws:emr-serverless:{{region}}:{{account-id}}:/applications/{{application-id}}/sessions/*" ] }, { "Sid": "EMRServerlessRuntimeRoleAccess", "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::{{account-id}}:role/{{EMRServerlessExecutionRole}}" ], "Condition": { "StringLike": { "iam:PassedToService": "emr-serverless.amazonaws.com" } } } ] } ``` ## Lavorare con sessioni interattive Per creare un'applicazione compatibile con Spark Connect e connetterti ad essa, segui questi passaggi. **Per avviare una sessione Spark Connect** 1. Crea un'applicazione con sessioni Spark Connect. ``` aws emr-serverless create-application \ --type "SPARK" \ --name "spark-connect-app" \ --release-label emr-7.13.0 \ --interactive-configuration '{"sessionEnabled": true}' ``` 1. Dopo che Amazon EMR Serverless ha creato l'applicazione, avviala se non hai abilitato l'avvio automatico per accettare le sessioni Spark Connect. ``` aws emr-serverless start-application \ --application-id {{APPLICATION_ID}} ``` 1. Usa il seguente comando per verificare lo stato della tua applicazione. Dopo che lo stato diventa`STARTED`, avvia una sessione. ``` aws emr-serverless get-application \ --application-id {{APPLICATION_ID}} ``` 1. Inizia una sessione con un ruolo di esecuzione IAM che concede l'accesso ai tuoi dati. ``` aws emr-serverless start-session \ --application-id {{APPLICATION_ID}} \ --execution-role-arn arn:aws:iam::{{account-id}}:role/{{EMRServerlessExecutionRole}} ``` 1. Monitora lo stato della sessione utilizzando l'`get-session`API e attendi che la sessione sia attiva `STARTED` o in `IDLE` uno stato. ``` aws emr-serverless get-session \ --application-id {{APPLICATION_ID}} \ --session-id {{SESSION_ID}} ``` 1. Recupera l'endpoint Spark Connect e il token di autenticazione. L'URL dell'endpoint restituito da `GetSessionEndpoint` non include un numero di porta. Quando si crea l'URL di `sc://` connessione, è necessario aggiungere, ad `:443` esempio. `sc://` {{hostname}} `:443/;use_ssl=true;x-aws-proxy-auth=` {{token}} Senza di essa, il PySpark client utilizza per impostazione predefinita la porta 15002, che non è raggiungibile su EMR Serverless. ``` aws emr-serverless get-session-endpoint \ --application-id {{APPLICATION_ID}} \ --session-id {{SESSION_ID}} ``` La risposta include l'URL dell'endpoint e un token di autenticazione: ``` { "endpoint": "{{ENDPOINT_URL}}", "authToken": "{{AUTH_TOKEN}}", "authTokenExpiresAt": "{{AUTH_TOKEN_EXPIRY_TIME}}" } ``` 1. Quando l'endpoint è pronto, connettiti da un PySpark client. Installa il PySpark client che corrisponde alla versione Spark sulla tua applicazione EMR Serverless e l' AWS SDK per Python. ``` # Match the PySpark version to your EMR Serverless release version (3.5.6 for emr-7.13.0) pip install pyspark[connect]==3.5.6 pip install boto3 ``` Di seguito è riportato un esempio di script Python per avviare una sessione e inviare richieste direttamente all'endpoint della sessione: ``` import boto3 import time from pyspark.sql import SparkSession from pyspark.sql.functions import col client = boto3.client('emr-serverless', region_name='{{REGION}}') APPLICATION_ID = '{{APPLICATION_ID}}' EXECUTION_ROLE = 'arn:aws:iam::{{account-id}}:role/{{EMRServerlessExecutionRole}}' # Start the session response = client.start_session( applicationId=APPLICATION_ID, executionRoleArn=EXECUTION_ROLE ) session_id = response['sessionId'] print(f"Session {session_id} starting...") # Wait for the session to be ready while True: response = client.get_session( applicationId=APPLICATION_ID, sessionId=session_id ) state = response['session']['state'] print(f"Session state: {state}") if state in ('STARTED', 'IDLE'): break if state in ('FAILED', 'TERMINATED'): raise Exception(f"Session failed: {response['session'].get('stateDetails', 'Unknown error')}") time.sleep(5) # Retrieve the Spark Connect endpoint and authentication token response = client.get_session_endpoint( applicationId=APPLICATION_ID, sessionId=session_id ) # Construct the authenticated remote URL auth_token = response['authToken'] endpoint_url = response['endpoint'] connect_url = endpoint_url.replace("https://", "sc://", 1) + ":443/;use_ssl=true;" connect_url += f"x-aws-proxy-auth={auth_token}" # Start the Spark session spark = SparkSession.builder.remote(connect_url).getOrCreate() print(f"Connected. Spark version: {spark.version}") # Run SQL spark.sql("SELECT 1+1 AS result").show() # Run DataFrame operations df = spark.range(100).withColumn("squared", col("id") * col("id")) df.show(10) print(f"Count: {df.count()}") # Stop the Spark session (disconnects the client only) spark.stop() # Terminate the EMR Serverless session to stop billing. # spark.stop() only closes the local client connection. The remote session # continues running and incurring charges until you explicitly terminate it # or it reaches the idle timeout. client.terminate_session( applicationId=APPLICATION_ID, sessionId=session_id ) print(f"Session {session_id} terminated.") ``` Per accedere all'interfaccia utente live di Spark o allo Spark History Server per una sessione, usa l'API. `GetResourceDashboard` ``` response = client.get_resource_dashboard( applicationId=APPLICATION_ID, resourceId=session_id, resourceType='SESSION' ) response['url'] ``` Mentre una sessione è attiva, l'URL apre l'interfaccia utente live di Apache Spark per il monitoraggio in tempo reale di query, fasi ed esecutori. Al termine di una sessione, Spark History Server rimane disponibile per l'analisi post-sessione tramite la console Amazon EMR Serverless. ## Considerazioni e limitazioni Considera quanto segue quando esegui carichi di lavoro interattivi tramite Spark Connect. + Spark Connect è supportato con la versione Serverless `emr-7.13.0` di Amazon EMR e successive. + Spark Connect è supportato solo per il motore Apache Spark. + Spark Connect supporta DataFrame e SQL APIs in PySpark. I sistemi basati su RDD APIs non sono supportati. + I token di autenticazione sono limitati nel tempo a 1 ora. Quando un token scade, le chiamate gRPC falliscono con un errore di autenticazione. Chiama `GetSessionEndpoint` per ottenere un nuovo token e creane uno nuovo `SparkSession` con il token aggiornato. + Le sessioni terminano dopo un timeout di inattività configurabile. Il timeout predefinito è impostato su 1 ora. + Per impostazione predefinita, ogni sessione ha un limite rigido di 24 ore, dopodiché si interrompe automaticamente anche se sta eseguendo attivamente un'attività. + Per impostazione predefinita, ogni applicazione EMR Serverless supporta fino a 25 sessioni simultanee. Per richiedere un aumento del limite, contatta l' AWS assistenza. + Per impostazione predefinita, `autoStopConfig` è attiva per le applicazioni. L'applicazione si interrompe automaticamente dopo 15 minuti senza sessioni attive o esecuzioni di lavoro. Puoi modificare questa configurazione come parte della tua `create-application` `update-application` richiesta. + Per una migliore esperienza di avvio, configura la capacità preinizializzata per driver ed esecutori. + È necessario abilitare AutoStart o avviare manualmente l'applicazione prima di iniziare una sessione EMR Serverless. + La PySpark versione installata localmente deve corrispondere alla versione di Apache Spark sull'applicazione Amazon EMR Serverless (3.5.6 per). `emr-7.13.0` Cause di mancata corrispondenza della versione o comportamento imprevisto. `ImportError` + Il controllo granulare degli accessi tramite Lake Formation non è supportato per le sessioni Spark Connect. + La Trusted Identity Propagation non è supportata per le sessioni interattive con Spark Connect. + Lo storage serverless su EMR Serverless non è supportato per le sessioni interattive con Spark Connect. + Non sono previsti costi aggiuntivi per l'utilizzo di Spark Connect. Paghi solo per le risorse di elaborazione EMR Serverless (vCPU, memoria e storage) consumate durante la sessione. + La configurazione Spark `spark.connect.grpc.binding.address` è riservata da EMR Serverless e non può essere sostituita dagli utenti. + Il PySpark pacchetto che installi localmente deve corrispondere alla versione Spark sulla tua applicazione EMR Serverless. Una mancata corrispondenza della versione causa errori di connessione. Python UDFs (`@udf`,`spark.udf.register`) richiede anche che la versione minore locale di Python corrisponda al worker, altrimenti fallisce. `PYTHON_VERSION_MISMATCH` Le funzioni e le DataFrame operazioni SQL integrate non richiedono una corrispondenza della versione di Python. + Per passare le configurazioni Spark con`start-session`, impostale sotto `runtimeConfiguration` nel parametro. `--configuration-overrides` L'`start-job-run`API utilizza `applicationConfiguration` invece.