As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Execute sessões interativas com o Amazon EMR Serverless por meio do Spark Connect Com a versão do Amazon EMR `emr-7.13.0` e versões posteriores, você pode se conectar a um aplicativo Amazon EMR Serverless a partir de PySpark clientes autogerenciados, como VS Code PyCharm e notebooks Jupyter, usando a sessão do EMR Serverless com o Apache Spark Connect. APIs O Spark Connect usa uma arquitetura cliente-servidor que separa o código do aplicativo do processo do driver do Spark. Você desenvolve e depura o PySpark código em seu IDE local enquanto as operações do Spark são executadas na computação EMR Serverless. O Spark Connect oferece os seguintes benefícios: + Conecte-se ao EMR Serverless a partir de qualquer PySpark cliente, incluindo o VS Code e os notebooks PyCharm Jupyter. + Defina pontos de interrupção e analise o PySpark código em seu IDE enquanto DataFrames executa remotamente dados em escala de produção. Uma sessão do Spark Connect é uma conexão gerenciada entre seu PySpark cliente local e um driver do Spark em execução no Amazon EMR Serverless. Quando você inicia uma sessão, o EMR Serverless provisiona um driver e executores do Spark em seu nome. Seu cliente local envia DataFrame operações SQL para o driver, e o driver as executa remotamente. A sessão persiste até que você a encerre ou atinja o tempo limite de inatividade, para que você possa executar várias consultas interativamente sem reiniciar o Spark. Cada sessão tem seu próprio URL de endpoint e token de autenticação que você usa para se conectar. ## Permissões obrigatórias Além das permissões necessárias para acessar o Amazon EMR Serverless, adicione também as seguintes permissões à sua função do IAM para acessar um endpoint do Spark Connect e gerenciar as sessões do Spark Connect: `emr-serverless:StartSession` Concede permissão para criar uma sessão do Spark Connect no aplicativo que você especifica como`Resource`. `emr-serverless:GetSessionEndpoint` Concede permissão para recuperar o URL do endpoint e o token de autenticação do Spark Connect para uma sessão. `emr-serverless:GetSession` Concede permissão para obter o status de uma sessão. `emr-serverless:ListSessions` Concede permissão para listar sessões em um aplicativo. `emr-serverless:TerminateSession` Concede permissão para encerrar uma sessão. `iam:PassRole` Concede permissão para acessar a função de execução do IAM ao criar a sessão do Spark Connect. O Amazon EMR Serverless usa essa função para executar suas cargas de trabalho. `emr-serverless:GetResourceDashboard` Concede permissão para gerar a URL da interface do usuário do Spark e fornece acesso aos registros da sessão. ``` { "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" } } } ] } ``` ## Trabalhando com sessões interativas Para criar um aplicativo compatível com o Spark Connect e se conectar a ele, siga estas etapas. **Para iniciar uma sessão do Spark Connect** 1. Crie um aplicativo com sessões do Spark Connect. ``` aws emr-serverless create-application \ --type "SPARK" \ --name "spark-connect-app" \ --release-label emr-7.13.0 \ --interactive-configuration '{"sessionEnabled": true}' ``` 1. Depois que o Amazon EMR Serverless criar seu aplicativo, inicie o aplicativo se você não tiver ativado o início automático para aceitar as sessões do Spark Connect. ``` aws emr-serverless start-application \ --application-id {{APPLICATION_ID}} ``` 1. Use o comando a seguir para verificar o status do seu aplicativo. Depois que o status se tornar`STARTED`, inicie uma sessão. ``` aws emr-serverless get-application \ --application-id {{APPLICATION_ID}} ``` 1. Inicie uma sessão com uma função de execução do IAM que concede acesso aos seus dados. ``` aws emr-serverless start-session \ --application-id {{APPLICATION_ID}} \ --execution-role-arn arn:aws:iam::{{account-id}}:role/{{EMRServerlessExecutionRole}} ``` 1. Monitore o estado da sessão usando a `get-session` API e aguarde até que a sessão entre em `STARTED` nosso `IDLE` estado. ``` aws emr-serverless get-session \ --application-id {{APPLICATION_ID}} \ --session-id {{SESSION_ID}} ``` 1. Recupere o endpoint e o token de autenticação do Spark Connect. O URL do endpoint retornado por `GetSessionEndpoint` não inclui um número de porta. Ao criar o URL de `sc://` conexão, você deve acrescentar `:443` — por exemplo,. `sc://` {{hostname}} `:443/;use_ssl=true;x-aws-proxy-auth=` {{token}} Sem ela, o PySpark cliente usa como padrão a porta 15002, que não pode ser acessada no EMR Serverless. ``` aws emr-serverless get-session-endpoint \ --application-id {{APPLICATION_ID}} \ --session-id {{SESSION_ID}} ``` A resposta inclui o URL do endpoint e um token de autenticação: ``` { "endpoint": "{{ENDPOINT_URL}}", "authToken": "{{AUTH_TOKEN}}", "authTokenExpiresAt": "{{AUTH_TOKEN_EXPIRY_TIME}}" } ``` 1. Depois que o endpoint estiver pronto, conecte-se a partir de um PySpark cliente. Instale o PySpark cliente que corresponda à versão do Spark em seu aplicativo EMR Serverless e o AWS SDK para 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 ``` Veja a seguir um exemplo de script Python para iniciar uma sessão e enviar solicitações diretamente para o endpoint da sessão: ``` 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.") ``` Para acessar a interface ativa do Spark ou o Spark History Server para uma sessão, use a `GetResourceDashboard` API. ``` response = client.get_resource_dashboard( applicationId=APPLICATION_ID, resourceId=session_id, resourceType='SESSION' ) response['url'] ``` Enquanto uma sessão está ativa, a URL abre a interface ativa do Apache Spark para monitoramento em tempo real de consultas, estágios e executores. Após o término de uma sessão, o Spark History Server permanece disponível para análise pós-sessão por meio do console Amazon EMR Serverless. ## Considerações e limitações Considere o seguinte ao executar cargas de trabalho interativas por meio do Spark Connect. + O Spark Connect é compatível com a versão sem servidor do Amazon EMR e versões posteriores`emr-7.13.0`. + O Spark Connect é compatível somente com o mecanismo Apache Spark. + O Spark Connect suporta DataFrame e usa SQL APIs . PySpark Os baseados em RDD não APIs são suportados. + Os tokens de autenticação são limitados a 1 hora. Quando um token expira, as chamadas do gRPC falham com um erro de autenticação. Ligue `GetSessionEndpoint` para obter um novo token e criar um novo `SparkSession` com o token atualizado. + As sessões terminam após um tempo limite de inatividade configurável. O tempo limite padrão é definido para 1 hora. + Cada sessão tem um limite rígido de 24 horas por padrão, após o qual ela é encerrada automaticamente, mesmo que esteja executando ativamente uma tarefa. + Cada aplicativo EMR Serverless suporta até 25 sessões simultâneas por padrão. Para solicitar um aumento de limite, entre em contato com o AWS Support. + Por padrão, `autoStopConfig` está ativado para aplicativos. O aplicativo é interrompido automaticamente após 15 minutos sem sessões ativas ou execuções de trabalhos. Você pode alterar essa configuração como parte da solicitação `create-application` ou `update-application`. + Para obter a melhor experiência de inicialização, configure a capacidade pré-inicializada para drivers e executores. + Você deve ativar AutoStart ou iniciar manualmente seu aplicativo antes de iniciar uma sessão do EMR Serverless. + A PySpark versão instalada localmente deve corresponder à versão do Apache Spark em seu aplicativo Amazon EMR Serverless (versão 3.5.6 para). `emr-7.13.0` Uma incompatibilidade de versões causa `ImportError` ou comportamento inesperado. + O controle de acesso refinado por meio do Lake Formation não é suportado nas sessões do Spark Connect. + O Trusted Identity Propagation não é compatível com sessões interativas com o Spark Connect. + O armazenamento sem servidor no EMR Serverless não é compatível com sessões interativas com o Spark Connect. + Não há cobrança adicional pelo uso do Spark Connect. Você paga somente pelos recursos computacionais sem servidor do EMR (vCPU, memória e armazenamento) consumidos durante sua sessão. + A configuração do Spark `spark.connect.grpc.binding.address` é reservada pelo EMR Serverless e não pode ser substituída pelos usuários. + O PySpark pacote que você instala localmente deve corresponder à versão do Spark em seu aplicativo EMR Serverless. Uma incompatibilidade de versão causa erros de conexão. Python UDFs (`@udf`,`spark.udf.register`) também exige que a versão secundária local do Python corresponda à do trabalhador, ou falhará com ela. `PYTHON_VERSION_MISMATCH` As funções e DataFrame operações SQL integradas não exigem uma correspondência de versão do Python. + Para passar as configurações do Spark com`start-session`, defina-as abaixo `runtimeConfiguration` no `--configuration-overrides` parâmetro. `applicationConfiguration`Em vez disso, a `start-job-run` API usa.