Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Organisez des sessions interactives avec Amazon EMR sur EKS via Spark Connect

Avec Amazon EMR sur les versions EKS emr-7.14.0 et versions ultérieures (ou emr-spark-8.1.0 ultérieures), vous pouvez vous connecter à un point de terminaison Spark Connect géré à partir de PySpark clients autogérés tels que VS CodePyCharm, et Jupyter des blocs-notes. 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 votre cluster EKS via Amazon EMR sur EKS. Spark Connect offre les avantages suivants :

Un point de terminaison Spark Connect est un point de terminaison géré sur votre cluster virtuel qui héberge un serveur Spark Connect. Lorsque vous créez un point de terminaison Spark Connect, Amazon EMR sur EKS fournit un pilote Spark avec un serveur gRPC sur votre cluster EKS. Votre PySpark client local envoie DataFrame des opérations SQL au pilote via le point de terminaison gRPC. Pour interagir avec le terminal, vous obtenez des informations d'identification de session à l'aide de l'GetManagedEndpointSessionCredentialsAPI. Chaque terminal prend en charge plusieurs sessions simultanées.

Conditions préalables

Avant de créer un point de terminaison Spark Connect, assurez-vous de disposer des éléments suivants.

Les exigences suivantes sont spécifiques aux terminaux Spark Connect :

Vous avez également besoin de la norme Amazon EMR sur les ressources EKS suivante. Si vous exécutez déjà des tâches sur Amazon EMR sur EKS, il est probable que les tâches suivantes soient en place :

Autorisations requises

Ajoutez les autorisations suivantes à votre rôle IAM pour créer un endpoint Spark Connect et interagir avec celui-ci :

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "EMRContainersEndpointAccess",
            "Effect": "Allow",
            "Action": [
                "emr-containers:CreateManagedEndpoint",
                "emr-containers:DescribeManagedEndpoint",
                "emr-containers:DeleteManagedEndpoint",
                "emr-containers:ListManagedEndpoints",
                "emr-containers:GetManagedEndpointSessionCredentials"
            ],
            "Resource": [
                "arn:aws:emr-containers:region:account-id:/virtualclusters/virtual-cluster-id",
                "arn:aws:emr-containers:region:account-id:/virtualclusters/virtual-cluster-id/endpoints/*"
            ]
        },
        {
            "Sid": "PassRoleToEKSPodIdentity",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::account-id:role/ExecutionRole",
            "Condition": {
                "StringEquals": {
                    "iam:PassedToService": "pods.eks.amazonaws.com"
                },
                "ArnLike": {
                    "iam:AssociatedResourceARN": [
                        "arn:aws:eks:region:account-id:cluster/eks-cluster-name"
                    ]
                }
            }
        }
    ]
}

Création d'une configuration de sécurité

Les terminaux Spark Connect nécessitent une configuration de sécurité associée à votre cluster virtuel. La configuration de sécurité définit les paramètres d'authentification et d'autorisation pour le terminal et spécifie l'espace de noms système dans lequel s'exécute l'infrastructure Spark Connect.

Créez une configuration de sécurité avec un espace de noms système :

aws emr-containers create-security-configuration \
  --name "security-config-name" \
  --security-configuration-data '{
    "authenticationConfiguration": {
      "identityCenterConfiguration": {
        "enableIdentityCenter": false
      }
    }
  }' \
  --container-provider '{
    "type": "EKS",
    "id": "eks-cluster-name",
    "info": {
      "eksInfo": {
        "namespace": "system-namespace"
      }
    }
  }'

namespaceDans la configuration de sécurité, il y a l'espace de noms du système dans lequel s'exécutent les composants de l'infrastructure Spark Connect. Il est distinct de l'espace de noms utilisateur spécifié lors de la création du cluster virtuel.

Création d'un cluster virtuel avec Spark Connect activé

Créez un cluster virtuel associé à la configuration de sécurité. Vous devez définir true et sessionEnabled fournir les informations securityConfigurationId de l'étape précédente.

aws emr-containers create-virtual-cluster \
  --name "virtual-cluster-name" \
  --container-provider '{
    "type": "EKS",
    "id": "eks-cluster-name",
    "info": {
      "eksInfo": {
        "namespace": "user-namespace"
      }
    }
  }' \
  --security-configuration-id SECURITY_CONFIGURATION_ID \
  --session-enabled true

Création d'un point de terminaison Spark Connect

Après avoir créé une configuration de sécurité, créez un point de terminaison géré par Spark Connect sur votre cluster virtuel.

aws emr-containers create-managed-endpoint \
  --virtual-cluster-id VIRTUAL_CLUSTER_ID \
  --name "spark-connect-endpoint" \
  --type "SPARK_CONNECT" \
  --release-label "emr-7.14.0-latest" \
  --execution-role-arn "arn:aws:iam::account-id:role/ExecutionRole" \
  --session-idle-timeout-in-minutes 60

L'exemple suivant inclut des remplacements de configuration Spark par une allocation dynamique et une configuration de surveillance pour exporter les journaux Spark vers Amazon S3 :

aws emr-containers create-managed-endpoint \
  --virtual-cluster-id VIRTUAL_CLUSTER_ID \
  --name "spark-connect-endpoint" \
  --type "SPARK_CONNECT" \
  --release-label "emr-7.14.0-latest" \
  --execution-role-arn "arn:aws:iam::account-id:role/ExecutionRole" \
  --session-idle-timeout-in-minutes 60 \
  --configuration-overrides '{
    "applicationConfiguration": [
      {
        "classification": "spark-defaults",
        "properties": {
          "spark.driver.memory": "4g",
          "spark.executor.memory": "4g",
          "spark.executor.cores": "2",
          "spark.executor.instances": "3",
          "spark.dynamicAllocation.enabled": "true",
          "spark.dynamicAllocation.minExecutors": "3",
          "spark.dynamicAllocation.maxExecutors": "5"
        }
      }
    ],
    "monitoringConfiguration": {
      "s3MonitoringConfiguration": {
        "logUri": "s3://your-bucket/spark-connect-logs/"
      },
      "persistentAppUI": "ENABLED"
    }
  }'

Surveillez l'état des terminaux :

aws emr-containers describe-managed-endpoint \
  --virtual-cluster-id VIRTUAL_CLUSTER_ID \
  --id ENDPOINT_ID

Attendez que l'état du terminal soit atteint ACTIVE avant de vous connecter.

Connectez-vous à un terminal Spark Connect

Une fois le terminal actif, obtenez les informations d'identification de session et connectez-vous depuis un PySpark client.

Le script Python suivant obtient l'URL du proxy d'authentification et le jeton de session, puis se connecte au point de terminaison Spark Connect :

import boto3
from pyspark.sql import SparkSession
from pyspark.sql.functions import col

REGION = 'REGION'
VIRTUAL_CLUSTER_ID = 'VIRTUAL_CLUSTER_ID'
ENDPOINT_ID = 'ENDPOINT_ID'
EXECUTION_ROLE = 'arn:aws:iam::account-id:role/ExecutionRole'

client = boto3.client('emr-containers', region_name=REGION)

# Get the auth proxy URL from DescribeManagedEndpoint
endpoint_response = client.describe_managed_endpoint(
    virtualClusterId=VIRTUAL_CLUSTER_ID,
    id=ENDPOINT_ID
)
auth_proxy_url = endpoint_response['endpoint']['authProxyUrl']

# Get session token
creds_response = client.get_managed_endpoint_session_credentials(
    virtualClusterIdentifier=VIRTUAL_CLUSTER_ID,
    endpointIdentifier=ENDPOINT_ID,
    executionRoleArn=EXECUTION_ROLE,
    credentialType='TOKEN'
)
token = creds_response['credentials']['token']

# Connect via Spark Connect using auth proxy URL and credentials token
connect_url = f"{auth_proxy_url}/;use_ssl=true;x-aws-proxy-auth={token}"
spark = SparkSession.builder.remote(connect_url).getOrCreate()
print(f"Connected. Spark version: {spark.version}")

# Run DataFrame operations
df = spark.range(100).withColumn("squared", col("id") * col("id"))
df.show(10)
print(f"Count: {df.count()}")

spark.stop()

Considérations et restrictions

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