Autorisations requises Travailler avec des sessions interactives Considérations et restrictions

Organisez des sessions interactives avec Amazon EMR Serverless via Spark Connect

Avec les versions Amazon EMR emr-7.13.0 et ultérieures, vous pouvez vous connecter à une application Amazon EMR Serverless à partir de PySpark clients autogérés tels que VS Code et les blocs-notes Jupyter à l'aide de la session PyCharm EMR Serverless avec Apache Spark Connect. APIs Spark Connect utilise une architecture client-serveur qui dissocie le code de votre application du processus du pilote Spark. Vous développez et déboguez PySpark du code dans votre IDE local pendant que les opérations Spark s'exécutent sur le calcul sans serveur EMR. Spark Connect offre les avantages suivants :

Connectez-vous à EMR Serverless depuis n'importe quel PySpark client, y compris les ordinateurs portables VS Code et PyCharm Jupyter.
Définissez des points d'arrêt et parcourez le PySpark code étape par étape dans votre IDE tout en DataFrames exécutant à distance des données de production.

Une session Spark Connect est une connexion gérée entre votre PySpark client local et un pilote Spark exécuté sur Amazon EMR Serverless. Lorsque vous démarrez une session, EMR Serverless fournit un pilote Spark et des exécuteurs en votre nom. Votre client local envoie DataFrame des opérations SQL au pilote, qui les exécute à distance. La session persiste jusqu'à ce que vous la terminiez ou qu'elle atteigne le délai d'inactivité. Vous pouvez donc exécuter plusieurs requêtes de manière interactive sans redémarrer Spark. Chaque session possède son propre URL de point de terminaison et son propre jeton d'authentification que vous utilisez pour vous connecter.

Autorisations requises

Outre les autorisations requises pour accéder à Amazon EMR Serverless, ajoutez également les autorisations suivantes à votre rôle IAM pour accéder à un point de terminaison Spark Connect et gérer les sessions Spark Connect :

emr-serverless:StartSession: Accorde l'autorisation de créer une session Spark Connect sur l'application que vous spécifiez commeResource.
emr-serverless:GetSessionEndpoint: Accorde l'autorisation de récupérer l'URL du point de terminaison Spark Connect et le jeton d'authentification pour une session.
emr-serverless:GetSession: Accorde l'autorisation d'obtenir le statut d'une session.
emr-serverless:ListSessions: Accorde l'autorisation de répertorier les sessions sur une application.
emr-serverless:TerminateSession: Accorde l'autorisation de mettre fin à une session.
iam:PassRole: Accorde l'autorisation d'accéder au rôle d'exécution IAM lors de la création de la session Spark Connect. Amazon EMR Serverless utilise ce rôle pour exécuter vos charges de travail.
emr-serverless:GetResourceDashboard: Accorde l'autorisation de générer l'URL de l'interface utilisateur Spark et donne accès aux journaux de la session.


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

Travailler avec des sessions interactives

Pour créer une application compatible avec Spark Connect et vous y connecter, procédez comme suit.

Pour démarrer une session Spark Connect

Créez une application avec des sessions Spark Connect.


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

Une fois qu'Amazon EMR Serverless a créé votre application, démarrez-la si vous n'avez pas activé le démarrage automatique pour accepter les sessions Spark Connect.
```
aws emr-serverless start-application \
  --application-id APPLICATION_ID
```
Utilisez la commande suivante pour vérifier le statut de votre demande. Une fois le statut atteintSTARTED, démarrez une session.
```
aws emr-serverless get-application \
  --application-id APPLICATION_ID
```

Démarrez une session avec un rôle d'exécution IAM qui accorde l'accès à vos données.


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

Surveillez l'état de la session à l'aide de l'get-sessionAPI et attendez que la session soit active STARTED ou IDLE en cours.
```
aws emr-serverless get-session \
  --application-id APPLICATION_ID \
  --session-id SESSION_ID
```
Récupérez le point de terminaison et le jeton d'authentification Spark Connect. L'URL du point de terminaison renvoyée par GetSessionEndpoint n'inclut pas de numéro de port. Lorsque vous créez l'URL de sc:// connexion, vous devez ajouter:443, par exemple, sc:// hostname :443/;use_ssl=true;x-aws-proxy-auth=token. Sans ce port, le PySpark client utilise par défaut le port 15002, qui n'est pas accessible sur EMR Serverless.
```
aws emr-serverless get-session-endpoint \
  --application-id APPLICATION_ID \
  --session-id SESSION_ID
```
La réponse inclut l'URL du point de terminaison et un jeton d'authentification :
```
{
  "endpoint": "ENDPOINT_URL",
  "authToken": "AUTH_TOKEN",
  "authTokenExpiresAt": "AUTH_TOKEN_EXPIRY_TIME"
}
```
Une fois que le point de terminaison est prêt, connectez-vous depuis un PySpark client. Installez le PySpark client correspondant à la version de Spark sur votre application EMR Serverless, ainsi que le AWS SDK pour 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
```

Voici un exemple de script Python permettant de démarrer une session et d'envoyer des demandes directement au point de terminaison de session :


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

Pour accéder à l'interface utilisateur Spark en direct ou au serveur d'historique Spark pendant une session, utilisez l'GetResourceDashboardAPI.


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

Lorsqu'une session est active, l'URL ouvre l'interface utilisateur active d'Apache Spark pour une surveillance en temps réel des requêtes, des étapes et des exécuteurs. Après la fin d'une session, le serveur Spark History reste disponible pour une analyse post-session via la console Amazon EMR Serverless.

Considérations et restrictions

Tenez compte des points suivants lorsque vous exécutez des charges de travail interactives via Spark Connect.

Spark Connect est pris en charge avec les versions emr-7.13.0 Amazon EMR Serverless et ultérieures.
Spark Connect n'est pris en charge que pour le moteur Apache Spark.
Spark Connect prend en charge DataFrame et SQL APIs in PySpark. Les fichiers basés sur RDD ne APIs sont pas pris en charge.
Les jetons d'authentification sont limités à une heure. Lorsqu'un jeton expire, les appels gRPC échouent avec une erreur d'authentification. Appelez GetSessionEndpoint pour obtenir un nouveau jeton et créez-en un nouveau SparkSession avec le jeton mis à jour.
Les sessions se terminent après un délai d'inactivité configurable. Le délai d'expiration par défaut est fixé à 1 heure.
Chaque session a une limite stricte de 24 heures par défaut, après quoi elle s'arrête automatiquement même si elle exécute activement une tâche.
Chaque application EMR Serverless prend en charge jusqu'à 25 sessions simultanées par défaut. Pour demander une augmentation de limite, contactez le AWS Support.
Activé par défaut pour les applications. autoStopConfig L'application s'arrête automatiquement au bout de 15 minutes sans session active ni exécution de tâche. Vous pouvez modifier cette configuration dans le cadre de votre update-application demande create-application ou de votre demande.
Pour une expérience de démarrage optimale, configurez la capacité pré-initialisée pour les pilotes et les exécuteurs.
Vous devez activer AutoStart ou démarrer manuellement votre application avant de démarrer une session EMR Serverless.
La PySpark version installée localement doit correspondre à la version d'Apache Spark sur votre application Amazon EMR Serverless (3.5.6 pour). emr-7.13.0 Une incompatibilité de version entraîne ImportError un comportement inattendu.
Le contrôle d'accès détaillé via Lake Formation n'est pas pris en charge pour les sessions Spark Connect.
La propagation d'identités fiables n'est pas prise en charge pour les sessions interactives avec Spark Connect.
Le stockage sans serveur sur EMR Serverless n'est pas pris en charge pour les sessions interactives avec Spark Connect.
L'utilisation de Spark Connect est gratuite. Vous ne payez que pour les ressources de calcul EMR sans serveur (vCPU, mémoire et stockage) consommées au cours de votre session.
La configuration Spark spark.connect.grpc.binding.address est réservée par EMR Serverless et ne peut pas être remplacée par les utilisateurs.
Le PySpark package que vous installez localement doit correspondre à la version de Spark de votre application EMR Serverless. Une incompatibilité de version entraîne des erreurs de connexion. Python UDFs (@udf,spark.udf.register) nécessite également que la version mineure locale de Python corresponde au programme de travail, sinon elle échouePYTHON_VERSION_MISMATCH. Les fonctions et DataFrame opérations SQL intégrées ne nécessitent pas de correspondance de version de Python.
Pour transmettre des configurations Sparkstart-session, définissez-les runtimeConfiguration dans le --configuration-overrides paramètre. L'start-job-runAPI utilise à la applicationConfiguration place.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Répartition des coûts au niveau du poste

Exécution de charges de travail interactives