Permissões obrigatórias Trabalhando com sessões interativas Considerações e limitações

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 comoResource.
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

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}'

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
```
Use o comando a seguir para verificar o status do seu aplicativo. Depois que o status se tornarSTARTED, inicie uma sessão.
```
aws emr-serverless get-application \
  --application-id APPLICATION_ID
```

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

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
```
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"
}
```
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 posterioresemr-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 comstart-session, defina-as abaixo runtimeConfiguration no --configuration-overrides parâmetro. applicationConfigurationEm vez disso, a start-job-run API usa.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Alocação de custos em nível de trabalho

Execução de workloads interativas