Erforderliche Berechtigungen Arbeiten mit interaktiven Sitzungen Überlegungen und Einschränkungen

Führen Sie interaktive Sitzungen mit Amazon EMR Serverless über Spark Connect durch

Mit der Amazon EMR-Version emr-7.13.0 und höher können Sie von selbstverwalteten PySpark Clients wie VS Code und Jupyter-Notebooks aus mithilfe der EMR-Serverless-Sitzung mit Apache Spark PyCharm Connect eine Verbindung zu einer Amazon EMR Serverless-Anwendung herstellen. APIs Spark Connect verwendet eine Client-Server-Architektur, die Ihren Anwendungscode vom Spark-Treiberprozess entkoppelt. Sie entwickeln und debuggen PySpark Code in Ihrer lokalen IDE, während Spark-Operationen auf EMR Serverless Compute ausgeführt werden. Spark Connect bietet die folgenden Vorteile:

Stellen Sie von jedem PySpark Client aus, einschließlich VS Code- und Jupyter-Notebooks, eine Connect zu EMR Serverless her. PyCharm
Legen Sie Haltepunkte fest und gehen Sie Schritt für Schritt durch den PySpark Code in Ihrer IDE, während Sie Daten im Produktionsmaßstab remote bearbeiten DataFrames.

Eine Spark Connect-Sitzung ist eine verwaltete Verbindung zwischen Ihrem lokalen PySpark Client und einem Spark-Treiber, der auf Amazon EMR Serverless läuft. Wenn Sie eine Sitzung starten, stellt EMR Serverless in Ihrem Namen einen Spark-Treiber und Executoren bereit. Ihr lokaler Client sendet DataFrame SQL-Operationen an den Treiber, und der Treiber führt sie remote aus. Die Sitzung bleibt bestehen, bis Sie sie beenden oder sie das Leerlauf-Timeout erreicht, sodass Sie mehrere Abfragen interaktiv ausführen können, ohne Spark neu starten zu müssen. Jede Sitzung hat ihre eigene Endpunkt-URL und ihr eigenes Authentifizierungstoken, das Sie für die Verbindung verwenden.

Erforderliche Berechtigungen

Zusätzlich zu den erforderlichen Berechtigungen für den Zugriff auf Amazon EMR Serverless fügen Sie Ihrer IAM-Rolle auch die folgenden Berechtigungen hinzu, um auf einen Spark Connect-Endpunkt zuzugreifen und Spark Connect-Sitzungen zu verwalten:

emr-serverless:StartSession: Erteilt die Erlaubnis, eine Spark Connect-Sitzung für die Anwendung zu erstellen, die Sie als angebenResource.
emr-serverless:GetSessionEndpoint: Erteilt die Erlaubnis, die Spark Connect-Endpunkt-URL und das Authentifizierungstoken für eine Sitzung abzurufen.
emr-serverless:GetSession: Erteilt die Erlaubnis, den Status einer Sitzung abzurufen.
emr-serverless:ListSessions: Erteilt die Berechtigung, Sitzungen in einer Anwendung aufzulisten.
emr-serverless:TerminateSession: Erteilt die Erlaubnis, eine Sitzung zu beenden.
iam:PassRole: Erteilt die Erlaubnis, beim Erstellen der Spark Connect-Sitzung auf die IAM-Ausführungsrolle zuzugreifen. Amazon EMR Serverless verwendet diese Rolle, um Ihre Workloads auszuführen.
emr-serverless:GetResourceDashboard: Erteilt die Erlaubnis zur Generierung der Spark-UI-URL und gewährt Zugriff auf die Protokolle für die Sitzung.


{
    "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"
                }
            }
        }
    ]
}

Arbeiten mit interaktiven Sitzungen

Gehen Sie wie folgt vor, um eine Spark Connect-fähige Anwendung zu erstellen und Connect zu ihr herzustellen.

Um eine Spark Connect-Sitzung zu starten

Erstellen Sie eine Anwendung mit Spark Connect-Sitzungen.


aws emr-serverless create-application \
  --type "SPARK" \
  --name "spark-connect-app" \
  --release-label emr-7.13.0 \
  --interactive-configuration '{"sessionEnabled": true}'

Nachdem Amazon EMR Serverless Ihre Anwendung erstellt hat, starten Sie die Anwendung, falls Sie den automatischen Start für die Annahme von Spark Connect-Sitzungen nicht aktiviert haben.
```
aws emr-serverless start-application \
  --application-id APPLICATION_ID
```
Verwenden Sie den folgenden Befehl, um den Status Ihrer Anwendung zu überprüfen. Wenn der Status lautetSTARTED, starten Sie eine Sitzung.
```
aws emr-serverless get-application \
  --application-id APPLICATION_ID
```

Starten Sie eine Sitzung mit einer IAM-Ausführungsrolle, die Zugriff auf Ihre Daten gewährt.


aws emr-serverless start-session \
  --application-id APPLICATION_ID \
  --execution-role-arn arn:aws:iam::account-id:role/EMRServerlessExecutionRole

Überwachen Sie den Sitzungsstatus mithilfe der get-session API und warten Sie, bis sich die Sitzung im IDLE Status STARTED oder befindet.
```
aws emr-serverless get-session \
  --application-id APPLICATION_ID \
  --session-id SESSION_ID
```
Rufen Sie den Spark Connect-Endpunkt und das Authentifizierungstoken ab. Die von zurückgegebene Endpunkt-URL enthält GetSessionEndpoint keine Portnummer. Wenn Sie die sc:// Verbindungs-URL erstellen, müssen Sie sie anhängen :443 — zum Beispiel. sc:// hostname :443/;use_ssl=true;x-aws-proxy-auth= token Andernfalls verwendet der PySpark Client standardmäßig Port 15002, der auf EMR Serverless nicht erreichbar ist.
```
aws emr-serverless get-session-endpoint \
  --application-id APPLICATION_ID \
  --session-id SESSION_ID
```
Die Antwort enthält die Endpunkt-URL und ein Authentifizierungstoken:
```
{
  "endpoint": "ENDPOINT_URL",
  "authToken": "AUTH_TOKEN",
  "authTokenExpiresAt": "AUTH_TOKEN_EXPIRY_TIME"
}
```
Wenn der Endpunkt bereit ist, stellen Sie von einem PySpark Client aus eine Verbindung her. Installieren Sie den PySpark Client, der der Spark-Version entspricht, in Ihrer EMR Serverless-Anwendung und das AWS SDK für 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
```

Im Folgenden finden Sie ein Python-Python-Skript zum Starten einer Sitzung und zum Senden von Anfragen direkt an den Sitzungsendpunkt:


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.")

Verwenden Sie die GetResourceDashboard API, um für eine Sitzung auf die Live-Benutzeroberfläche von Spark oder den Spark History Server zuzugreifen.


response = client.get_resource_dashboard(
    applicationId=APPLICATION_ID,
    resourceId=session_id,
    resourceType='SESSION'
)
response['url']

Während eine Sitzung aktiv ist, öffnet die URL die Live-Benutzeroberfläche von Apache Spark für die Echtzeitüberwachung von Abfragen, Phasen und Executors. Nach dem Ende einer Sitzung steht der Spark History Server weiterhin für die Analyse nach der Sitzung über die Amazon EMR Serverless-Konsole zur Verfügung.

Überlegungen und Einschränkungen

Beachten Sie Folgendes, wenn Sie interaktive Workloads über Spark Connect ausführen.

Spark Connect wird mit der Version Amazon EMR Serverless emr-7.13.0 und höher unterstützt.
Spark Connect wird nur für die Apache Spark-Engine unterstützt.
Spark Connect unterstützt DataFrame und SQL APIs in PySpark. RDD-basierte APIs werden nicht unterstützt.
Authentifizierungstoken sind zeitlich auf 1 Stunde begrenzt. Wenn ein Token abläuft, schlagen gRPC-Aufrufe mit einem Authentifizierungsfehler fehl. Rufen Sie GetSessionEndpoint auf, um ein neues Token abzurufen und ein neues SparkSession mit dem aktualisierten Token zu erstellen.
Sitzungen enden nach einem konfigurierbaren Leerlauf-Timeout. Das Standard-Timeout ist auf 1 Stunde festgelegt.
Jede Sitzung hat standardmäßig ein festes Limit von 24 Stunden. Danach wird sie automatisch beendet, auch wenn sie aktiv eine Aufgabe ausführt.
Jede EMR Serverless-Anwendung unterstützt standardmäßig bis zu 25 gleichzeitige Sitzungen. Um eine Erhöhung des Limits zu beantragen, wenden Sie sich an den AWS Support.
autoStopConfigIst für Anwendungen standardmäßig aktiviert. Die Anwendung wird automatisch nach 15 Minuten ohne aktive Sitzungen oder Jobausführungen beendet. Sie können diese Konfiguration im Rahmen Ihrer create-application update-application PR-Anfrage ändern.
Für ein optimales Starterlebnis konfigurieren Sie die vorinitialisierte Kapazität für Treiber und Executoren.
Sie sollten Ihre Anwendung aktivieren AutoStart oder manuell starten, bevor Sie eine EMR Serverless-Sitzung starten.
Die lokal installierte PySpark Version muss mit der Apache Spark-Version in Ihrer Amazon EMR Serverless-Anwendung (3.5.6 für) übereinstimmen. emr-7.13.0 Ein Versionskonflikt führt zu unerwartetem VerhaltenImportError.
Eine detaillierte Zugriffskontrolle über Lake Formation wird für Spark Connect-Sitzungen nicht unterstützt.
Trusted Identity Propagation wird für interaktive Sitzungen mit Spark Connect nicht unterstützt.
Serverloser Speicher auf EMR Serverless wird für interaktive Sitzungen mit Spark Connect nicht unterstützt.
Für die Nutzung von Spark Connect fallen keine zusätzlichen Gebühren an. Sie zahlen nur für serverlose EMR-Rechenressourcen (vCPU, Arbeitsspeicher und Speicher), die während Ihrer Sitzung verbraucht werden.
Die Spark-Konfiguration spark.connect.grpc.binding.address ist für EMR Serverless reserviert und kann von Benutzern nicht überschrieben werden.
Das PySpark Paket, das Sie lokal installieren, muss mit der Spark-Version in Ihrer EMR Serverless-Anwendung übereinstimmen. Ein Versionskonflikt führt zu Verbindungsfehlern. Python UDFs (@udf,spark.udf.register) erfordert außerdem, dass die lokale Python-Nebenversion mit dem Worker übereinstimmt, andernfalls schlagen sie mit fehlPYTHON_VERSION_MISMATCH. Integrierte SQL-Funktionen und DataFrame -Operationen erfordern keine Python-Versionsübereinstimmung.
Um Spark-Konfigurationen mit zu übergebenstart-session, setzen Sie sie runtimeConfiguration im --configuration-overrides Parameter unter. Die start-job-run API verwendet applicationConfiguration stattdessen.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Kostenzuweisung auf Tätigkeitsebene

Ausführung interaktiver Workloads