Requisitos previos Permisos necesarios Introducción Consideraciones

Ejecute cargas de trabajo interactivas con EMR Serverless a través de un terminal Apache Livy

Con las EMR versiones 6.14.0 y posteriores de Amazon, puede crear y habilitar un punto de conexión Apache Livy al mismo tiempo crear una aplicación EMR sin servidor y ejecutar cargas de trabajo interactivas a través de sus blocs de notas autohospedados o con un cliente personalizado. Un terminal Apache Livy ofrece las siguientes ventajas:

Puedes conectarte de forma segura a un terminal Apache Livy a través de los cuadernos de Jupyter y gestionar las cargas de trabajo de Apache Spark con la interfaz de Apache Livy. REST
Utilice las REST API operaciones de Apache Livy para aplicaciones web interactivas que utilizan datos de las cargas de trabajo de Apache Spark.

Requisitos previos

Para utilizar un terminal Apache Livy con EMR Serverless, debe cumplir los siguientes requisitos:

Complete los pasos que se indican en Introducción a Amazon EMR Serverless.
Para ejecutar cargas de trabajo interactivas a través de los puntos de conexión de Apache Livy, necesita ciertos permisos y funciones. Para obtener más información, consulte Permisos necesarios para las cargas de trabajo interactivas.

Permisos necesarios

Además de los permisos necesarios para acceder a EMR Serverless, también debe añadir los siguientes permisos a su IAM función para acceder a un punto final de Apache Livy y ejecutar aplicaciones:

emr-serverless:AccessLivyEndpoints— concede permiso para acceder y conectarse a la aplicación habilitada para Livy que usted especifique como. Resource Necesita este permiso para ejecutar REST API las operaciones disponibles en el punto final de Apache Livy.
iam:PassRole— concede permiso para acceder al rol de IAM ejecución al crear la sesión de Apache Livy. EMRServerless utilizará esta función para ejecutar sus cargas de trabajo.
emr-serverless:GetDashboardForJobRun— concede permiso para generar los enlaces a la interfaz de usuario y al registro de controladores de Spark Live y proporciona acceso a los registros como parte de los resultados de la sesión de Apache Livy.


{
    "Version": "2012-10-17",
    "Statement": [{
            "Sid": "EMRServerlessInteractiveAccess",
            "Effect": "Allow",
            "Action": "emr-serverless:AccessLivyEndpoints",
            "Resource": "arn:aws:emr-serverless:<AWS_REGION>:account:/applications/*"
        },
        {
            "Sid": "EMRServerlessRuntimeRoleAccess",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "execution-role-ARN",
            "Condition": {
                "StringLike": {
                    "iam:PassedToService": "emr-serverless.amazonaws.com"
                }
            }
        },
        {
            "Sid": "EMRServerlessDashboardAccess",
            "Effect": "Allow",
            "Action": "emr-serverless:GetDashboardForJobRun",
            "Resource": "arn:aws:emr-serverless:<AWS_REGION>:account:/applications/*"
        }
    ]
}

Introducción

Para crear una aplicación compatible con Apache Livy, ejecuta el siguiente comando.


 aws emr-serverless create-application \
--name my-application-name \ 
--type 'application-type' \
 --release-label <Amazon EMR-release-version>
--interactive-configuration '{"livyEndpointEnabled": true}'

Una vez que EMR Serverless haya creado la aplicación, iníciela para que el punto final de Apache Livy esté disponible.
```
 aws emr-serverless start-application \
 --application-id application-id
```
Utilice el siguiente comando para comprobar el estado de su aplicación. Una vez que el estado pase a serSTARTED, podrá acceder al punto final de Apache Livy.
```
aws emr-serverless get-application \
--region <AWS_REGION> --application-id >application_id>
```

Utilice lo siguiente URL para acceder al punto final:


https://_<application-id>_.livy.emr-serverless-services._<AWS_REGION>_.amazonaws.com

Una vez que el punto final esté listo, puede enviar las cargas de trabajo en función de su caso de uso. Debe firmar todas las solicitudes que se envíen al punto final con el SIGv4 protocolo y pasar un encabezado de autorización. Puede usar los siguientes métodos para ejecutar cargas de trabajo:

HTTPcliente: debe enviar sus API operaciones de punto final de Apache Livy con un cliente personalizadoHTTP.
Núcleo de Sparkmagic: debe ejecutar el núcleo de Sparkmagic de forma local y enviar consultas interactivas con los cuadernos de Jupyter.

HTTPclientes

Para crear una sesión de Apache Livy, debe introducir emr-serverless.session.executionRoleArn el conf parámetro del cuerpo de la solicitud. El siguiente ejemplo es un ejemplo de POST /sessions solicitud.


{    
    "kind": "pyspark",
    "heartbeatTimeoutInSecond": 60, 
    "conf": {
        "emr-serverless.session.executionRoleArn": "<executionRoleArn>"
    }
}

En la siguiente tabla se describen todas las API operaciones de Apache Livy disponibles.

APIoperación	Descripción
GET/sesiones	Devuelve una lista de todas las sesiones interactivas activas.
POST/sesiones	Crea una nueva sesión interactiva mediante spark o pyspark.
GET/sessions/ <`sessionId`>	Devuelve la información de la sesión.
GET/sessions/ <`sessionId`/sesiones/estado	Devuelve el estado de la sesión.
DELETE/sessiones/ <`sessionId`>	Detiene y elimina la sesión.
GET/sessions/ <`sessionId`/sesiones/declaraciones	Devuelve todas las declaraciones de una sesión.
POST/sessions/ <`sessionId`/sesiones/declaraciones	Ejecuta una declaración en una sesión.
GET/sessions/ <`sessionId`/sesiones/declaraciones/<`statementId`>	Devuelve los detalles de la declaración especificada en una sesión.
POST/sessions/ <`sessionId`/sesiones/declaraciones/<`statementId`>/declaraciones/cancelar	Cancela la declaración especificada en esta sesión.

Envío de solicitudes al punto final de Apache Livy

También puede enviar solicitudes directamente al punto final de Apache Livy desde un HTTP cliente. De este modo, podrá ejecutar código de forma remota para sus casos de uso fuera de un bloc de notas.

Antes de empezar a enviar solicitudes al punto final, asegúrate de haber instalado las siguientes bibliotecas:


pip3 install botocore awscrt requests

El siguiente es un ejemplo de script de Python para enviar HTTP solicitudes directamente a un punto final:


from botocore import crt
import requests 
from botocore.awsrequest import AWSRequest
from botocore.credentials import Credentials
import botocore.session
import json, pprint, textwrap

endpoint = 'https://<application_id>.livy.emr-serverless-services-<AWS_REGION>.amazonaws.com'
headers = {'Content-Type': 'application/json'}

session = botocore.session.Session()
signer = crt.auth.CrtS3SigV4Auth(session.get_credentials(), 'emr-serverless', '<AWS_REGION>')


### Create session request

data = {'kind': 'pyspark', 'heartbeatTimeoutInSecond': 60, 'conf': { 'emr-serverless.session.executionRoleArn': 'arn:aws:iam::123456789012:role/role1'}}

request = AWSRequest(method='POST', url=endpoint + "/sessions", data=json.dumps(data), headers=headers)

request.context["payload_signing_enabled"] = False

signer.add_auth(request)

prepped = request.prepare()

r = requests.post(prepped.url, headers=prepped.headers, data=json.dumps(data))

pprint.pprint(r.json())


### List Sessions Request

request = AWSRequest(method='GET', url=endpoint + "/sessions", headers=headers)

request.context["payload_signing_enabled"] = False

signer.add_auth(request)

prepped = request.prepare()

r2 = requests.get(prepped.url, headers=prepped.headers)
pprint.pprint(r2.json())


### Get session state

session_url = endpoint + r.headers['location']

request = AWSRequest(method='GET', url=session_url, headers=headers)

request.context["payload_signing_enabled"] = False

signer.add_auth(request)

prepped = request.prepare()

r3 = requests.get(prepped.url, headers=prepped.headers)

pprint.pprint(r3.json())


### Submit Statement

data = {
      'code': "1 + 1"
}

statements_url = endpoint + r.headers['location'] + "/statements"

request = AWSRequest(method='POST', url=statements_url, data=json.dumps(data), headers=headers)

request.context["payload_signing_enabled"] = False

signer.add_auth(request)

prepped = request.prepare()

r4 = requests.post(prepped.url, headers=prepped.headers, data=json.dumps(data))

pprint.pprint(r4.json())

### Check statements results

specific_statement_url = endpoint + r4.headers['location']

request = AWSRequest(method='GET', url=specific_statement_url, headers=headers)

request.context["payload_signing_enabled"] = False

signer.add_auth(request)

prepped = request.prepare()

r5 = requests.get(prepped.url, headers=prepped.headers)

pprint.pprint(r5.json())


### Delete session


session_url = endpoint + r.headers['location']

request = AWSRequest(method='DELETE', url=session_url, headers=headers)

request.context["payload_signing_enabled"] = False

signer.add_auth(request)

prepped = request.prepare()

r6 = requests.delete(prepped.url, headers=prepped.headers)

pprint.pprint(r6.json())

Núcleo de Sparkmagic

Antes de instalar Sparkmagic, asegúrese de haber configurado AWS credenciales en la instancia en la que desea instalar sparkmagic

Instale sparkmagic siguiendo los pasos de instalación. Tenga en cuenta que solo necesita realizar los cuatro primeros pasos.
El núcleo de Sparkmagic admite autenticadores personalizados, por lo que puede integrar un autenticador con el núcleo de Sparkmagic para que todas las solicitudes estén firmadas. SIGv4
Instale el autenticador personalizado ServerlessEMR.
```
pip install emr-serverless-customauth
```

Ahora proporciona la ruta al autenticador personalizado y al punto final de Apache Livy URL en el archivo json de configuración de sparkmagic. Use el siguiente comando para abrir el archivo de configuración.


vim ~/.sparkmagic/config.json

A continuación se muestra un archivo de muestra config.json.


{
"kernel_python_credentials" : {
    "username": "",
    "password": "",
    "url": "https://<application-id>.livy.emr-serverless-services.<AWS_REGION>.amazonaws.com",
    "auth": "Custom_Auth"
  },

  "kernel_scala_credentials" : {
    "username": "",
    "password": "",
    "url": "https://<application-id>.livy.emr-serverless-services.<AWS_REGION>.amazonaws.com",
    "auth": "Custom_Auth"
  },
  "authenticators": {
    "None": "sparkmagic.auth.customauth.Authenticator",
    "Basic_Access": "sparkmagic.auth.basic.Basic",
    "Custom_Auth": "emr_serverless_customauth.customauthenticator.EMRServerlessCustomSigV4Signer"
  },
  "livy_session_startup_timeout_seconds": 600,
  "ignore_ssl_errors": false
}

Inicie Jupyter lab. Debe usar la autenticación personalizada que configuraste en el último paso.

A continuación, puede ejecutar los siguientes comandos del bloc de notas y su código para empezar.


%%info //Returns the information about the current sessions.


%%configure -f //Configure information specific to a session. We supply executionRoleArn in this example. Change it for your use case.
{
    "driverMemory": "4g",
    "conf": {
          "emr-serverless.session.executionRoleArn": "arn:aws:iam::123456789012:role/JobExecutionRole"
    }
}


<your code>//Run your code to start the session

Internamente, cada instrucción llama a cada una de las API operaciones de Apache Livy a través del punto final de Apache Livy configurado. URL A continuación, puede escribir las instrucciones de acuerdo con su caso de uso.

Consideraciones

Tenga en cuenta las siguientes consideraciones al ejecutar cargas de trabajo interactivas a través de los puntos finales de Apache Livy.

EMRServerless mantiene el aislamiento a nivel de sesión mediante el principal que realiza la llamada. El principal que llama y crea la sesión es el único que puede acceder a esa sesión. Para un aislamiento más detallado, puede configurar una identidad de origen al asumir las credenciales. En este caso, EMR Serverless aplica el aislamiento a nivel de sesión en función de la identidad principal de la persona que llama y de la fuente. Para obtener más información sobre la identidad de la fuente, consulte Supervisar y controlar las acciones realizadas con los roles asumidos.
Los puntos finales de Apache Livy son compatibles con las versiones 6.14.0 y superiores de EMR Serverless.
Los puntos finales de Apache Livy solo son compatibles con el motor Apache Spark.
Los puntos finales de Apache Livy son compatibles con Scala Spark y. PySpark
De forma predeterminada, autoStopConfig está habilitada en sus aplicaciones. Esto significa que las aplicaciones se cierran después de 15 minutos de estar inactivas. Puede cambiar esta configuración como parte de su create-application update-application solicitud.
Puede ejecutar hasta 25 sesiones simultáneas en una sola aplicación habilitada para terminales Apache Livy.
Para obtener la mejor experiencia de inicio, le recomendamos que configure la capacidad preinicializada para los controladores y los ejecutores.
Debe iniciar la aplicación manualmente antes de conectarse al punto final de Apache Livy.
Debe tener una cuota de CPU servicio v suficiente en su Cuenta de AWS para ejecutar cargas de trabajo interactivas con el punto final Apache Livy. Se recomienda utilizar al menos 24 V. CPU
El tiempo de espera predeterminado de la sesión de Apache Livy es de 1 hora. Si no ejecuta las sentencias durante una hora, Apache Livy borra la sesión y libera el controlador y los ejecutores. No puede cambiar esta configuración.
Solo las sesiones activas pueden interactuar con un punto final de Apache Livy. Una vez que la sesión finalice, se cancele o termine, no podrá acceder a ella a través del punto final de Apache Livy.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Ejecución de cargas de trabajo interactivas

Registro y monitorización