Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso de Apache Livy con Amazon EMR en EKS
<a name="job-runs-apache-livy"></a>

Con las versiones 7.1.0 y posteriores de Amazon EMR, puede utilizar Apache Livy para enviar trabajos en Amazon EMR en EKS. Mediante Apache Livy, puede configurar su propio punto de conexión REST de Apache Livy y usarlo para implementar y administrar aplicaciones de Spark en sus clústeres de Amazon EKS. Una vez que haya instalado Livy en su clúster de Amazon EKS, puede utilizar el punto de conexión de Livy para enviar las aplicaciones de Spark a su servidor de Livy. El servidor administra el ciclo de vida de las aplicaciones de Spark.

**nota**  
Amazon EMR calcula los precios de Amazon EKS en función de la vCPU y el consumo de memoria. Este cálculo se aplica a los pods de controladores y ejecutores. Este cálculo comienza cuando usted descarga la imagen de la aplicación de Amazon EMR hasta que finaliza el pod de Amazon EKS y se redondea al segundo más cercano.

**Topics**
+ [Configuración de Apache Livy para Amazon EMR en EKS](job-runs-apache-livy-setup.md)
+ [Introducción a Apache Livy en Amazon EMR en EKS](job-runs-apache-livy-install.md)
+ [Ejecución de una aplicación de Spark con Apache Livy para Amazon EMR en EKS](job-runs-apache-livy-run-spark.md)
+ [Desinstalación de Apache Livy con Amazon EMR en EKS](job-runs-apache-livy-uninstall.md)
+ [Seguridad de Apache Livy con Amazon EMR en EKS](job-runs-apache-livy-security.md)
+ [Propiedades de instalación de Apache Livy en las versiones de Amazon EMR en EKS.](job-runs-apache-livy-installation-properties.md)
+ [Solucione los errores comunes de formato de las variables de entorno](job-runs-apache-livy-troubleshooting.md)

# Configuración de Apache Livy para Amazon EMR en EKS
<a name="job-runs-apache-livy-setup"></a>

Antes de poder instalar Apache Livy en el clúster de Amazon EKS, debe instalar y configurar un conjunto de herramientas con requisitos previos. Estas incluyen AWS CLI, que es una herramienta de línea de comandos básica para trabajar con AWS recursos, herramientas de línea de comandos para trabajar con Amazon EKS y un controlador que se utiliza en este caso de uso para hacer que la aplicación de clúster esté disponible en Internet y enrutar el tráfico de la red.
+ **[Instale o actualice a la versión más reciente de AWS CLI: si ya la](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)** ha instalado AWS CLI, confirme que tiene la última versión.
+ **[Configure kubectl y eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) **: eksctl es una herramienta de línea de comandos que se utiliza para comunicarse con Amazon EKS.
+ **[Instale Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)**: el administrador de paquetes Helm para Kubernetes le ayuda a instalar y administrar aplicaciones en el clúster de Kubernetes. 
+ **[Introducción a Amazon EKS: eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) **: siga los pasos para crear un nuevo clúster de Kubernetes con nodos en Amazon EKS.
+ **[Seleccione una etiqueta de versión de Amazon EMR](docker-custom-images-tag.md)**: el Apache Livy es compatible con las versiones 7.1.0 y superiores de Amazon EMR.
+ **[Instale el controlador ALB: el controlador](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html)** ALB administra los clústeres de AWS Elastic Load Balancing para Kubernetes. Crea un AWS Network Load Balancer (NLB) al crear un Kubernetes Ingress mientras se configura Apache Livy.

# Introducción a Apache Livy en Amazon EMR en EKS
<a name="job-runs-apache-livy-install"></a>

Siga los pasos que se describen a continuación para instalar Apache Livy. Incluyen la configuración del administrador de paquetes, la creación de un espacio de nombres para ejecutar las cargas de trabajo de Spark, la instalación de Livy, la configuración del equilibrio de carga y los pasos de verificación. Tiene que completar estos pasos para ejecutar un trabajo por lotes con Spark.

1. Si aún no lo ha hecho, configure [Apache Livy para Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html).

1. Autentique su cliente de Helm en el registro de Amazon ECR. Puede encontrar el `ECR-registry-account` valor correspondiente a sus [cuentas Región de AWS de registro de Amazon ECR por región](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

   ```
   aws ecr get-login-password \--region <AWS_REGION> | helm registry login \
   --username AWS \
   --password-stdin <ECR-registry-account>.dkr.ecr.<region-id>.amazonaws.com
   ```

1. Al configurar Livy, se crea una cuenta de servicio para el servidor de Livy y otra cuenta para la aplicación Spark. Para configurar IRSA para las cuentas de servicio, consulte [Configuración de los permisos de acceso con roles de IAM para las cuentas de servicio (IRSA)](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html). 

1. Cree un espacio de nombres para ejecutar sus cargas de trabajo de Spark.

   ```
   kubectl create ns <spark-ns>
   ```

1. Utilice el siguiente comando para instalar Livy.

   Este punto de conexión de Livy solo está disponible internamente para la VPC del clúster de EKS. Para habilitar el acceso más allá de la VPC, establezca `—-set loadbalancer.internal=false` en su comando de instalación de Helm.
**nota**  
De forma predeterminada, el SSL no está habilitado en este punto de conexión de Livy y el punto de conexión solo está visible dentro de la VPC del clúster de EKS. Si configura `loadbalancer.internal=false` y `ssl.enabled=false`, expone un punto de conexión inseguro al exterior de su VPC. Para configurar un punto de conexión Livy seguro, consulte [Configuración de un punto de conexión seguro de Apache Livy con TLS/SSL](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html). 

   ```
   helm install livy-demo \
     oci://895885662937.dkr.ecr.region-id.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-ns \
     --set image=ECR-registry-account.dkr.ecr.region-id.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=<spark-ns> \
     --create-namespace
   ```

   Debería ver la siguiente salida.

   ```
   NAME: livy-demo
   LAST DEPLOYED: Mon Mar 18 09:23:23 2024
   NAMESPACE: livy-ns
   STATUS: deployed
   REVISION: 1
   TEST SUITE: None
   NOTES:
   The Livy server has been installed.
   Check installation status:
   1. Check Livy Server pod is running
     kubectl --namespace livy-ns get pods -l "app.kubernetes.io/instance=livy-demo"
   2. Verify created NLB is in Active state and it's target groups are healthy (if loadbalancer.enabled is true)
   
   Access LIVY APIs:
       # Ensure your NLB is active and healthy
       # Get the Livy endpoint using command:
       LIVY_ENDPOINT=$(kubectl get svc -n livy-ns -l app.kubernetes.io/instance=livy-demo,emr-containers.amazonaws.com/type=loadbalancer -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}' |  awk '{printf "%s:8998\n", $0}')
       # Access Livy APIs using http://$LIVY_ENDPOINT or https://$LIVY_ENDPOINT (if SSL is enabled)
       # Note: While uninstalling Livy, makes sure the ingress and NLB are deleted after running the helm command to avoid dangling resources
   ```

   Los nombres de las cuentas de servicio predeterminados para el servidor de Livy y la sesión de Spark son `emr-containers-sa-livy` y `emr-containers-sa-spark-livy`. Para usar nombres personalizados, use los parámetros `serviceAccounts.name` y `sparkServiceAccount.name`.

   ```
   --set serviceAccounts.name=my-service-account-for-livy
   --set sparkServiceAccount.name=my-service-account-for-spark
   ```

1. Compruebe que haya instalado el gráfico de Helm.

   ```
   helm list -n livy-ns -o yaml
   ```

   El comando `helm list` debería devolver la información sobre el nuevo gráfico de Helm:

   ```
   app_version: 0.7.1-incubating
   chart: livy-emr-7.12.0
   name: livy-demo
   namespace: livy-ns
   revision: "1"
   status: deployed
   updated: 2024-02-08 22:39:53.539243 -0800 PST
   ```

1. Compruebe que el Equilibrador de carga de red esté activo.

   ```
   LIVY_NAMESPACE=<livy-ns>
   LIVY_APP_NAME=<livy-app-name>
   AWS_REGION=<AWS_REGION>
   
   # Get the NLB Endpoint URL
   NLB_ENDPOINT=$(kubectl --namespace $LIVY_NAMESPACE get svc -l "app.kubernetes.io/instance=$LIVY_APP_NAME,emr-containers.amazonaws.com/type=loadbalancer" -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}') 
   
   # Get all the load balancers in the account's region
   ELB_LIST=$(aws elbv2 describe-load-balancers --region $AWS_REGION)
   
   # Get the status of the NLB that matching the endpoint from the Kubernetes service
   NLB_STATUS=$(echo $ELB_LIST | grep -A 8 "\"DNSName\": \"$NLB_ENDPOINT\"" | awk '/Code/{print $2}/}/' | tr -d '"},\n')
   echo $NLB_STATUS
   ```

1. Ahora compruebe que el grupo objetivo del Equilibrador de carga de red esté en buen estado.

   ```
   LIVY_NAMESPACE=<livy-ns>
   LIVY_APP_NAME=<livy-app-name>
   AWS_REGION=<AWS_REGION>
   
   # Get the NLB endpoint
   NLB_ENDPOINT=$(kubectl --namespace $LIVY_NAMESPACE get svc -l "app.kubernetes.io/instance=$LIVY_APP_NAME,emr-containers.amazonaws.com/type=loadbalancer" -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}') 
   
   # Get all the load balancers in the account's region
   ELB_LIST=$(aws elbv2 describe-load-balancers --region $AWS_REGION)
   
   # Get the NLB ARN from the NLB endpoint
   NLB_ARN=$(echo $ELB_LIST | grep -B 1 "\"DNSName\": \"$NLB_ENDPOINT\"" | awk '/"LoadBalancerArn":/,/"/'| awk '/:/{print $2}' | tr -d \",)
   
   # Get the target group from the NLB. Livy setup only deploys 1 target group
   TARGET_GROUP_ARN=$(aws elbv2 describe-target-groups --load-balancer-arn $NLB_ARN --region $AWS_REGION | awk '/"TargetGroupArn":/,/"/'| awk '/:/{print $2}' | tr -d \",)
   
   # Get health of target group
   aws elbv2 describe-target-health --target-group-arn $TARGET_GROUP_ARN
   ```

   Aquí se incluye un resultado de ejemplo que muestra el estado del grupo objetivo:

   ```
   {
       "TargetHealthDescriptions": [
           {
               "Target": {
                   "Id": "<target IP>",
                   "Port": 8998,
                   "AvailabilityZone": "us-west-2d"
               },
               "HealthCheckPort": "8998",
               "TargetHealth": {
                   "State": "healthy"
               }
           }
       ]
   }
   ```

   Una vez que el estado de su NLB pase a estar `active` y su grupo objetivo esté `healthy`, podrá continuar. Puede que tarde unos minutos.

1. Recupere el punto de conexión de Livy de la instalación de Helm. El hecho de que su punto de conexión de Livy sea seguro o no depende de si ha habilitado el SSL.

   ```
   LIVY_NAMESPACE=<livy-ns>
    LIVY_APP_NAME=livy-app-name
    LIVY_ENDPOINT=$(kubectl get svc -n livy-ns -l app.kubernetes.io/instance=livy-app-name,emr-containers.amazonaws.com/type=loadbalancer -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}' |  awk '{printf "%s:8998\n", $0}')
    echo "$LIVY_ENDPOINT"
   ```

1. Recupere la cuenta de servicio de Spark de la instalación de Helm

   ```
   SPARK_NAMESPACE=spark-ns
   LIVY_APP_NAME=<livy-app-name>
   SPARK_SERVICE_ACCOUNT=$(kubectl --namespace $SPARK_NAMESPACE get sa -l "app.kubernetes.io/instance=$LIVY_APP_NAME" -o jsonpath='{.items[0].metadata.name}')
   echo "$SPARK_SERVICE_ACCOUNT"
   ```

   Debería ver algo similar al siguiente resultado:

   ```
   emr-containers-sa-spark-livy
   ```

1. Si has configurado `internalALB=true` para habilitar el acceso desde fuera de tu VPC, crea una EC2 instancia de Amazon y asegúrate de que el Network Load Balancer permita el tráfico de red procedente de la instancia. EC2 Debe hacerlo para que la instancia pueda acceder a su punto de conexión de Livy. Para obtener más información sobre cómo exponer su punto de conexión de forma segura fuera de su VPC, consulte [Configuración con un punto de conexión de Apache Livy segurocon TLS/SSL](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html).

1. Al instalar Livy, se crea la cuenta de servicio `emr-containers-sa-spark` para ejecutar las aplicaciones de Spark. Si tu aplicación de Spark utiliza AWS recursos como S3 o llama a operaciones de AWS API o CLI, debes vincular un rol de IAM con los permisos necesarios a tu cuenta de servicio de Spark. Para obtener más información, consulte [Configuración de los permisos de acceso con roles de IAM para las cuentas de servicio (IRSA).](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)

Apache Livy admite configuraciones adicionales que puede usar al instalar Livy. Para obtener más información, consulte Propiedades de instalación de Apache Livy en Amazon EMR en EKS.

# Ejecución de una aplicación de Spark con Apache Livy para Amazon EMR en EKS
<a name="job-runs-apache-livy-run-spark"></a>

Antes de poder ejecutar una aplicación de Spark con Apache Livy, asegúrese de haber completado los pasos de [Configuración de Apache Livy para Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) y la [Introducción a Apache Livy para Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html).

Puede usar Apache Livy para ejecutar dos tipos de aplicaciones:
+ Sesiones por lotes: un tipo de carga de trabajo de Livy para enviar trabajos por lotes a Spark.
+ Sesiones interactivas: un tipo de carga de trabajo de Livy que proporciona una interfaz visual y programática para ejecutar consultas de Spark.

**nota**  
Los pods controladores y ejecutores de sesiones diferentes pueden comunicarse entre sí. Los espacios de nombres no garantizan la seguridad entre los pods. Kubernetes no permite permisos selectivos en un subconjunto de pods dentro de un espacio de nombres determinado.

## Ejecución de sesiones por lotes
<a name="job-runs-apache-livy-run-spark-batch"></a>

Para enviar un trabajo por lotes, use el siguiente comando.

```
curl -s -k -H 'Content-Type: application/json' -X POST \
      -d '{
            "name": "my-session",
            "file": "entryPoint_location (S3 or local)",
            "args": ["argument1", "argument2", ...],
            "conf": {
                "spark.kubernetes.namespace": "<spark-namespace>",
                "spark.kubernetes.container.image": "public.ecr.aws/emr-on-eks/spark/emr-7.12.0:latest",
                "spark.kubernetes.authenticate.driver.serviceAccountName": "<spark-service-account>"
            }
          }' <livy-endpoint>/batches
```

Para monitorizar el trabajo por lotes, use el siguiente comando.

```
curl -s -k -H 'Content-Type: application/json' -X GET <livy-endpoint>/batches/my-session
```

## Ejecución de sesiones interactivas
<a name="job-runs-apache-livy-run-spark-interactive"></a>

Para ejecutar sesiones interactivas con Apache Livy, consulte los siguientes pasos.

1. Asegúrate de tener acceso a un cuaderno Jupyter autohospedado o gestionado, como un SageMaker cuaderno Jupyter con IA. Su cuaderno de Jupyter debe tener [sparkmagic](https://github.com/jupyter-incubator/sparkmagic/blob/master/README.md) instalado.

1. Cree un bucket para la configuración de Spark `spark.kubernetes.file.upload.path`. Asegúrese de que la cuenta de servicio de Spark tenga acceso de lectura y escritura al bucket. Para obtener más información sobre cómo configurar su cuenta de servicio de Spark, consulte Configuración de los permisos de acceso con roles de IAM para las cuentas de servicio (IRSA)

1. Cargue sparkmagic en el cuaderno de Jupyter con el comando `%load_ext sparkmagic.magics`.

1. Ejecute el comando `%manage_spark` para configurar su punto de conexión de Livy con el cuaderno de Jupyter. Seleccione la pestaña **Añadir puntos de conexión**, elija el tipo de autenticación configurado, añada el punto de conexión de Livy al cuaderno y, a continuación, elija **Añadir punto de conexión**.

1. Vuelva a ejecutar `%manage_spark` para crear el contexto de Spark y, a continuación, vaya a **Crear sesión**. Elija el punto de conexión de Livy, especifique un nombre de sesión único, elija un idioma y, a continuación, añada las siguientes propiedades.

   ```
   {
     "conf": {
       "spark.kubernetes.namespace": "livy-namespace",
       "spark.kubernetes.container.image": "public.ecr.aws/emr-on-eks/spark/emr-7.12.0:latest",
       "spark.kubernetes.authenticate.driver.serviceAccountName": "<spark-service-account>", 
       "spark.kubernetes.file.upload.path": "<URI_TO_S3_LOCATION_>"
     }
   }
   ```

1. Envíe la solicitud y espere a que cree el contexto de Spark.

1. Para monitorizar el estado de la sesión interactiva, ejecute el siguiente comando.

   ```
   curl -s -k -H 'Content-Type: application/json' -X GET livy-endpoint/sessions/my-interactive-session
   ```

## Monitorización de aplicaciones de Spark
<a name="job-runs-apache-livy-run-ui"></a>

Para monitorizar el progreso de sus aplicaciones de Spark con la IU de Livy, use el enlace `http://<livy-endpoint>/ui`.

# Desinstalación de Apache Livy con Amazon EMR en EKS
<a name="job-runs-apache-livy-uninstall"></a>

Siga los pasos a continuación para desinstalar Apache Livy.

1. Elimine la configuración de Livy con los nombres de su espacio de nombres y el nombre de la aplicación. En este ejemplo, el nombre de la aplicación es `livy-demo` y el espacio de nombres es `livy-ns`.

   ```
   helm uninstall livy-demo -n livy-ns
   ```

1. Al realizar la desinstalación, Amazon EMR en EKS elimina el servicio de Kubernetes en Livy, los balanceadores de carga y AWS los grupos de destino que creó durante la instalación. La eliminación de recursos puede tardar unos minutos. Asegúrese de que los recursos se eliminen antes de volver a instalar Livy en el espacio de nombres.

1. Elimina el espacio de nombres de Spark.

   ```
   kubectl delete namespace spark-ns
   ```

# Seguridad de Apache Livy con Amazon EMR en EKS
<a name="job-runs-apache-livy-security"></a>

Consulte los siguientes temas para obtener más información sobre la configuración de la seguridad de Apache Livy con Amazon EMR en EKS. Estas opciones incluyen el uso de la seguridad a nivel de capa de transporte, el control de acceso basado en roles, es decir, el acceso en función del rol de una persona dentro de una organización, y el uso de roles de IAM, que proporcionan acceso a los recursos en función de los permisos otorgados.

**Topics**
+ [Configuración de un punto de conexión de Apache Livy seguro con TLS/SSL](job-runs-apache-livy-secure-endpoint.md)
+ [Configuración de los permisos de las aplicaciones de Apache Livy y Spark con control de acceso basado en roles (RBAC)](job-runs-apache-livy-rbac.md)
+ [Configuración de los permisos de acceso con roles de IAM para las cuentas de servicio (IRSA)](job-runs-apache-livy-irsa.md)

# Configuración de un punto de conexión de Apache Livy seguro con TLS/SSL
<a name="job-runs-apache-livy-secure-endpoint"></a>

Consulte las siguientes secciones para obtener más información sobre la configuración de Apache Livy para Amazon EMR en EKS end-to-end con cifrado TLS y SSL.

## Configuración del cifrado TLS y SSL
<a name="job-runs-apache-livy-security-tls"></a>

Para configurar el cifrado SSL en su punto de conexión de Apache Livy, siga estos pasos.
+ [Instale el controlador CSI de Secrets Store y el proveedor de AWS secretos y configuración (ASCP)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_csi_driver.html): el controlador CSI de Secrets Store y el ASCP almacenan de forma segura los certificados JKS y las contraseñas de Livy que el pod del servidor Livy necesita para habilitar el SSL. También puede instalar solo el controlador CSI de Secrets Store y utilizar cualquier otro proveedor de secretos compatible.
+ [Cree un certificado ACM](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html): este certificado es necesario para proteger la conexión entre el cliente y el punto de conexión de ALB.
+ Configure un certificado JKS, una contraseña clave y una contraseña del almacén de claves, necesarios para proteger la conexión entre el AWS Secrets Manager terminal ALB y el servidor Livy.
+ Añada permisos a la cuenta de servicio de Livy para recuperar los secretos AWS Secrets Manager : el servidor de Livy necesita estos permisos para recuperar los secretos de ASCP y añadir las configuraciones de Livy para proteger el servidor de Livy. Para añadir permisos de IAM a la cuenta del servicio, consulte Configuración de los permisos de acceso con roles de IAM para las cuentas de servicio (IRSA).

### Configurar un certificado JKS con una clave y una contraseña de almacén de claves para AWS Secrets Manager
<a name="job-runs-apache-livy-jks-certificate"></a>

Siga estos pasos para configurar un certificado JKS con una clave y una contraseña de almacén de claves.

1. Genere un archivo de almacén de claves para el servidor de Livy.

   ```
   keytool -genkey -alias <host> -keyalg RSA -keysize 2048 –dname CN=<host>,OU=hw,O=hw,L=<your_location>,ST=<state>,C=<country> –keypass <keyPassword> -keystore <keystore_file> -storepass <storePassword> --validity 3650
   ```

1. Cree un certificado.

   ```
   keytool -export -alias <host> -keystore mykeystore.jks -rfc -file mycertificate.cert -storepass <storePassword>
   ```

1. Cree un archivo de almacén de confianza.

   ```
   keytool -import -noprompt -alias <host>-file <cert_file> -keystore <truststore_file> -storepass <truststorePassword>
   ```

1. Guarde el certificado JKS en. AWS Secrets Manager Sustituya `livy-jks-secret` por su secreto y `fileb://mykeystore.jks` por la ruta al certificado JKS de su almacén de claves.

   ```
   aws secretsmanager create-secret \ 
   --name livy-jks-secret \
   --description "My Livy keystore JKS secret" \
   --secret-binary fileb://mykeystore.jks
   ```

1. Guarde el almacén de claves y la contraseña de claves en Secrets Manager. Asegúrese de utilizar sus propios parámetros.

   ```
   aws secretsmanager create-secret \
   --name livy-jks-secret \
   --description "My Livy key and keystore password secret" \
   --secret-string "{\"keyPassword\":\"<test-key-password>\",\"keyStorePassword\":\"<test-key-store-password>\"}"
   ```

1. Cree un espacio de nombres del servidor de Livy con el siguiente comando.

   ```
   kubectl create ns <livy-ns>
   ```

1. Cree el objeto `ServiceProviderClass` para el servidor de Livy que tiene el certificado JKS y las contraseñas.

   ```
   cat >livy-secret-provider-class.yaml << EOF
   apiVersion: secrets-store.csi.x-k8s.io/v1
   kind: SecretProviderClass
   metadata:
     name: aws-secrets
   spec:
     provider: aws
     parameters:
       objects: |
           - objectName: "livy-jks-secret"
             objectType: "secretsmanager"
           - objectName: "livy-passwords"
             objectType: "secretsmanager"
                        
   EOF
   kubectl apply -f livy-secret-provider-class.yaml -n <livy-ns>
   ```

## Introducción a Apache Livy con SSL habilitado
<a name="job-runs-apache-livy-ssl-enabled-getting-started"></a>

Después de habilitar el SSL en su servidor de Livy, debe configurar la `serviceAccount` para tener acceso a los secretos `keyStore` y `keyPasswords` en AWS Secrets Manager.

1. Cree el espacio de nombres del servidor de Livy.

   ```
   kubectl create namespace <livy-ns>
   ```

1. Configure la cuenta de servicio Livy para tener acceso a los secretos en Secrets Manager. Para obtener más información sobre la configuración de IRSA, consulte [Configuración de los IRSA durante la instalación de Apache Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html#job-runs-apache-livy-irsa).

   ```
   aws ecr get-login-password \--region region-id | helm registry login \
   --username AWS \
   --password-stdin ECR-registry-account.dkr.ecr.region-id.amazonaws.com
   ```

1. Instale Livy. Para el gráfico de Helm: parámetro de versión, utilice su etiqueta de versión de Amazon EMR, como `7.1.0`. También debe sustituir el identificador de cuenta de registro de Amazon ECR y el identificador de región por los suyos propios. IDs Puede encontrar el `ECR-registry-account` valor correspondiente a sus [cuentas Región de AWS de registro de Amazon ECR por región](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

   ```
   helm install <livy-app-name> \
     oci://895885662937.dkr.ecr.region-id.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-namespace-name \
     --set image=<ECR-registry-account.dkr.ecr>.<region>.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=spark-namespace \
     --set ssl.enabled=true
     --set ssl.CertificateArn=livy-acm-certificate-arn
     --set ssl.secretProviderClassName=aws-secrets
     --set ssl.keyStoreObjectName=livy-jks-secret
     --set ssl.keyPasswordsObjectName=livy-passwords
     --create-namespace
   ```

1. Continúe con el paso 5 de la [Instalación de Apache Livy en Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html#job-runs-apache-livy-install).

# Configuración de los permisos de las aplicaciones de Apache Livy y Spark con control de acceso basado en roles (RBAC)
<a name="job-runs-apache-livy-rbac"></a>

Para implementar Livy, Amazon EMR en EKS crea una cuenta y un rol de servicio de servidor y un rol y una cuenta de servicio de Spark. Estos roles deben tener los permisos RBAC necesarios para finalizar la configuración y ejecutar las aplicaciones de Spark.

**Permisos RBAC para el rol y la cuenta de servicio del servidor**

Amazon EMR en EKS crea el rol y la cuenta de servicio de servidor de Livy para administrar sesiones de Livy para los trabajos de Spark y enrutar el tráfico hacia y desde los recursos de entrada y otros recursos.

El nombre predeterminado de esta cuenta de servicio es `emr-containers-sa-livy`. Debe tener los siguientes permisos.

```
rules:
- apiGroups:
  - ""
  resources:
  - "namespaces"
  verbs:
  - "get"
- apiGroups:
  - ""
  resources:
  - "serviceaccounts"
    "services"
    "configmaps"
    "events"
    "pods"
    "pods/log"
  verbs:
  - "get"
    "list"
    "watch"
    "describe"
    "create"
    "edit"
    "delete"
    "deletecollection"
    "annotate"
    "patch"
    "label"
 - apiGroups:
   - ""
   resources:
   - "secrets"
   verbs:
   - "create"
     "patch"
     "delete"
     "watch"
 - apiGroups:
   - ""
   resources:
   - "persistentvolumeclaims"
   verbs:
   - "get"
     "list"
     "watch"
     "describe"
     "create"
     "edit"
     "delete"
     "annotate"
     "patch"
     "label"
```

**Permisos RBAC para el rol y la cuenta de servicio de Spark**

Un pod controlador de Spark necesita una cuenta de servicio de Kubernetes en el mismo espacio de nombres que el pod. Esta cuenta de servicio necesita permisos para administrar los pods ejecutores y cualquier recurso que requiera el pod controlador. A menos que la cuenta de servicio predeterminada del espacio de nombres tenga los permisos necesarios, el controlador fallará y se cerrará. Los siguientes permisos RBAC son necesarios.

```
rules:
- apiGroups:
  - ""
    "batch"
    "extensions"
    "apps"
  resources:
  - "configmaps"
    "serviceaccounts"
    "events"
    "pods"
    "pods/exec"
    "pods/log"
    "pods/portforward"
    "secrets"
    "services"
    "persistentvolumeclaims"
    "statefulsets"
  verbs:
  - "create"
    "delete"
    "get"
    "list"
    "patch"
    "update"
    "watch"
    "describe"
    "edit"
    "deletecollection"
    "patch"
    "label"
```

# Configuración de los permisos de acceso con roles de IAM para las cuentas de servicio (IRSA)
<a name="job-runs-apache-livy-irsa"></a>

De forma predeterminada, el servidor Livy y los controladores y ejecutores de la aplicación Spark no tienen acceso a los recursos. AWS La cuenta de servicio del servidor y la cuenta de servicio Spark controlan el acceso a AWS los recursos de los pods del servidor Livy y de la aplicación Spark. Para conceder el acceso, debes asignar las cuentas de servicio a un rol de IAM que tenga los permisos necesarios AWS .

Puede configurar la asignación de IRSA antes de instalar Apache Livy, durante la instalación o después de finalizarla.

## Configuración de IRSA durante la instalación de Apache Livy (para la cuenta de servicio del servidor)
<a name="job-runs-apache-livy-irsa"></a>

**nota**  
Esta asignación solo es compatible con la cuenta de servicio del servidor.

1. Asegúrese de haber terminado la [configuración de Apache Livy para Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) y de que está realizando la [instalación de Apache Livy con Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html). 

1. Cree un espacio de nombres de Kubernetes para el servidor Livy. En este ejemplo, el nombre del espacio de nombres es `livy-ns`.

1. Crea una política de IAM que incluya los permisos Servicios de AWS para los que quieres que accedan tus pods. El siguiente ejemplo crea una política de IAM para obtener recursos de Amazon S3 para el punto de entrada de Spark.

   ```
   cat >my-policy.json <<EOF{
   "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-spark-entrypoint-bucket"
           }
       ]
   }
   EOF
   
   aws iam create-policy --policy-name my-policy --policy-document file://my-policy.json
   ```

1. Usa el siguiente comando para configurar tu Cuenta de AWS ID en una variable.

   ```
   account_id=$(aws sts get-caller-identity --query "Account" --output text)
   ```

1. Establezca el proveedor de identidades de OpenID Connect (OIDC) de su clúster en una variable de entorno.

   ```
   oidc_provider=$(aws eks describe-cluster --name my-cluster --region $AWS_REGION --query "cluster.identity.oidc.issuer" --output text | sed -e "s/^https:\/\///")
   ```

1. Establezca variables para el espacio de nombres y el nombre de la cuenta de servicio. Asegúrese de utilizar sus propios valores.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Cree un archivo de política de confianza con el comando siguiente. Si desea conceder el acceso al rol a todas las cuentas de servicio de un espacio de nombres, copie el siguiente comando y sustituya `StringEquals` por `StringLike`; sustituya, también, `$service_account` por `*`.

   ```
   cat >trust-relationship.json <<EOF
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::$account_id:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   EOF
   ```

1. Creación del rol.

   ```
   aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
   ```

1. Utilice el siguiente comando de instalación Helm para establecer el `serviceAccount.executionRoleArn` para asignar IRSA. A continuación, se muestra un ejemplo del comando de instalación Helm. Puede encontrar el `ECR-registry-account` valor correspondiente a sus [cuentas Región de AWS de registro de Amazon ECR por región](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

   ```
   helm install livy-demo \
     oci://895885662937.dkr.ecr.us-west-2.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-ns \
     --set image=ECR-registry-account.dkr.ecr.region-id.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=spark-ns \
     --set serviceAccount.executionRoleArn=arn:aws:iam::123456789012:role/my-role
   ```

## Asignación del IRSA a una cuenta de servicio de Spark
<a name="job-runs-apache-livy-irsa-spark"></a>

Antes de asignar el IRSA a una cuenta de servicio de Spark, asegúrese de haber realizado los siguientes pasos:
+ Asegúrese de haber terminado la [configuración de Apache Livy para Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) y de que está realizando la [instalación de Apache Livy con Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html). 
+ Debe tener un proveedor de OpenID Connect (OIDC) de IAM para su clúster. Para ver si ya tiene este proveedor o cómo crear uno, consulte [Crear un proveedor de OIDC de IAM para su clúster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html).
+ Asegúrese de que tiene la versión 0.171.0 o posterior de la CLI de `eksctl` instalada o AWS CloudShell. Para instalar o actualizar `eksctl`, consulte [Instalación](https://eksctl.io/installation/) en la `eksctl` documentación.

Siga estos pasos para asignar el IRSA a su cuenta de servicio de Spark:

1. Ejecute el comando siguiente para obtener la cuenta de servicio de Spark.

   ```
   SPARK_NAMESPACE=<spark-ns>
   LIVY_APP_NAME=<livy-app-name>
   kubectl --namespace $SPARK_NAMESPACE describe sa -l "app.kubernetes.io/instance=$LIVY_APP_NAME" | awk '/^Name:/ {print $2}'
   ```

1. Establezca variables para el espacio de nombres y el nombre de la cuenta de servicio.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Use el siguiente comando para crear un archivo de política de confianza para el rol de IAM. El siguiente ejemplo da permiso a todas las cuentas de servicio dentro del espacio de nombres para utilizar el rol. Para ello, sustituya `StringEquals` por `StringLike`; sustituya, también, `$service_account` por \$1.

   ```
   cat >trust-relationship.json <<EOF
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::$account_id:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   EOF
   ```

1. Creación del rol.

   ```
   aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
   ```

1. Asigne el servidor o la cuenta de servicio de Spark con el siguiente comando `eksctl`. Asegúrese de utilizar sus propios valores.

   ```
    eksctl create iamserviceaccount --name spark-sa \
    --namespace spark-namespace --cluster livy-eks-cluster \
    --attach-role-arn arn:aws:iam::0123456789012:role/my-role \
    --approve --override-existing-serviceaccounts
   ```

# Propiedades de instalación de Apache Livy en las versiones de Amazon EMR en EKS.
<a name="job-runs-apache-livy-installation-properties"></a>

La instalación de Apache Livy le permite seleccionar una versión del gráfico de Helm de Livy. El gráfico de Helm ofrece una variedad de propiedades para personalizar su experiencia de instalación y configuración. Estas propiedades son compatibles con las versiones 7.1.0 y posteriores de Amazon EMR en EKS.

**Topics**
+ [Propiedades de instalación de Amazon EMR 7.1.0](#job-runs-apache-livy-installation-properties-710)

## Propiedades de instalación de Amazon EMR 7.1.0
<a name="job-runs-apache-livy-installation-properties-710"></a>

La tabla siguiente describe todas las propiedades de Livy compatibles. Al instalar Apache Livy, puede elegir la versión del gráfico de Helm de Livy. Para establecer una propiedad durante la instalación, utilice el comando `--set <property>=<value>`.


| Propiedad | Description (Descripción) | Predeterminado | 
| --- | --- | --- | 
| imagen | El URI de la versión de Amazon EMR del servidor Livy. Se trata de una configuración obligatoria. | "" | 
| sparkNamespace | Espacio de nombres para ejecutar sesiones de Spark de Livy. Por ejemplo, especifique "livy". Se trata de una configuración obligatoria. | "" | 
| nameOverride | Proporcione un nombre en lugar de livy. El nombre se establece como una etiqueta para todos los recursos de Livy | "livy" | 
| fullnameOverride | Proporcione un nombre para usarlo en lugar de los nombres completos de los recursos. | "" | 
| ssl.enabled | Habilita el end-to-end SSL desde el punto final de Livy al servidor de Livy. | FALSO | 
| ssl.certificateArn | Si el SSL está habilitado, este es el ARN del certificado ACM para el NLB creado por el servicio. | "" | 
| ssl. secretProviderClassNombre | Si el SSL está habilitado, este es el nombre de clase del proveedor secreto para proteger el NLB para la conexión del servidor Livy con SSL. | "" | 
| ssl. keyStoreObjectNombre | Si el SSL está habilitado, este es el nombre del objeto del certificado del almacén de claves de la clase de proveedor secreto. | "" | 
| ssl. keyPasswordsObjectNombre | Si el SSL está activado, este es el nombre de objeto del secreto que contiene el almacén de claves y la contraseña de claves. | "" | 
| rbac.create | Si es verdadero, crea recursos RBAC. | FALSO | 
| serviceAccount.create | Si es verdadero, crea una cuenta de servicio de Livy. | TRUE | 
| serviceAccount.name | El nombre de la cuenta de servicio que se utilizará para Livy. Si no establece esta propiedad ni crea una cuenta de servicio, Amazon EMR en EKS generará automáticamente un nombre mediante la propiedad de anulación de fullname. | "emr-containers-sa-livy" | 
| Cuenta de servicio. executionRoleArn | El ARN del rol de ejecución de la cuenta de servicio de Livy. | "" | 
| sparkServiceAccount.crear | SI es verdadero, crea la cuenta de servicio de Spark en .Release.Namespace | TRUE | 
| sparkServiceAccount.name | El nombre de la cuenta de servicio que se utilizará para Spark. Si no establece esta propiedad ni crea una cuenta de servicio Spark, Amazon EMR en EKS generará automáticamente un nombre mediante la propiedad fullnameOverride con el sufijo -spark-livy. | «emr-containers-sa-spark-livy» | 
| service.name | Nombre del servicio de Livy | "emr-containers-livy" | 
| service.annotations | Anotaciones del servicio de Livy | \$1\$1 | 
| loadbalancer.enabled | Si se debe crear un equilibrador de carga para el servicio Livy utilizado para exponer el punto de conexión de Livy fuera del clúster de Amazon EKS. | FALSE | 
| loadbalancer.internal | Si se debe configurar el punto de conexión de Livy como interno en la VPC o externo. Si se establece esta propiedad en `FALSE` se expone el punto de conexión a fuentes externas a la VPC. Recomendamos proteger el punto de conexión con TLS/SSL. Para obtener más información, consulte [Configuración del cifrado TLS y SSL](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-security.html#job-runs-apache-livy-security-tls). | FALSE | 
| imagePullSecrets | La lista de nombres imagePullSecret que se utilizarán para extraer la imagen de Livy de los repositorios privados. | [] | 
| recursos | Las solicitudes de recursos y los límites de los contenedores de Livy. | \$1\$1 | 
| nodeSelector | Los nodos para los que programar los pods de Livy. | \$1\$1 | 
| toleraciones | Una lista que contiene las tolerancias de los pods de Livy a definir. | [] | 
| afinidad | Las reglas de afinidad de los pods de Livy. | \$1\$1 | 
| persistence.enabled | Si es verdadero, habilita la persistencia de los directorios de sesiones. | FALSO | 
| persistence.subPath | La subruta de PVC que se monta en los directorios de las sesiones. | "" | 
| persistence.existingClaim | El PVC a utilizar en lugar de crear uno nuevo. | \$1\$1 | 
| persistence.storageClass | La clase de almacenamiento a utilizar. Para definir este parámetro, utilice el formato storageClassName: <storageClass>. Si este parámetro se establece en "-", se deshabilita el aprovisionamiento dinámico. Si establece este parámetro en nulo o no especifica nada, Amazon EMR en EKS no establece un storageClassName y usa el aprovisionador predeterminado. | "" | 
| persistence.accessMode | El modo de acceso al PVC. | ReadWriteOnce | 
| persistence.size | El tamaño del PVC. | 20 Gi | 
| persistence.annotations | Anotaciones adicionales para el PVC. | \$1\$1 | 
| env.\$1 | Envs adicionales para establecer en el contenedor de Livy. Para obtener más información, consulte [Introducción de sus propias configuraciones de Livy y Spark durante la instalación de Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-troubleshooting.html). | \$1\$1 | 
| envFrom.\$1 | Envs adicionales para establecer Livy desde un mapa de configuración o secreto. | [] | 
| livyConf.\$1 | Entradas livy.conf adicionales para establecer desde un mapa de configuración o secreto de Kubernetes montado. | \$1\$1 | 
| sparkDefaultsConf.\$1 | Entradas spark-defaults.conf adicionales para establecer desde un mapa de configuración o secreto de Kubernetes montado. | \$1\$1 | 

# Solucione los errores comunes de formato de las variables de entorno
<a name="job-runs-apache-livy-troubleshooting"></a>

Al introducir las configuraciones de Livy y Spark, hay formatos de variables de entorno que no son compatibles y pueden provocar errores. El procedimiento le guía por una serie de pasos que le ayudan a garantizar que utiliza los formatos correctos.

**Introducción de sus propias configuraciones de Livy y Spark durante la instalación de Livy**

Puede configurar cualquier variable de entorno de Apache Livy o Apache Spark con la propiedad Helm `env.*`. Siga los pasos que se indican a continuación para convertir la configuración de ejemplo `example.config.with-dash.withUppercase` a un formato de variable de entorno compatible.

1. Sustituya las letras mayúsculas por un 1 y la letra en minúscula. Por ejemplo, `example.config.with-dash.withUppercase` se convierte en `example.config.with-dash.with1uppercase`.

1. Sustituya los guiones (-) por 0. Por ejemplo, `example.config.with-dash.with1uppercase` se convierte en `example.config.with0dash.with1uppercase`.

1. Sustituya los puntos (.) por guiones bajos (\$1). Por ejemplo, `example.config.with0dash.with1uppercase` se convierte en `example_config_with0dash_with1uppercase`.

1. Sustituya todas las letras minúsculas por letras mayúsculas.

1. Añada el prefijo `LIVY_` al nombre de la variable.

1. Utilice la variable al instalar Livy a través del diagrama de Helm con el formato --set env. *YOUR\$1VARIABLE\$1NAME*.valor= *yourvalue*

Por ejemplo, para establecer las configuraciones de `livy.server.recovery.state-store = filesystem` y `spark.kubernetes.executor.podNamePrefix = my-prefix`, use estas propiedades de Helm:

```
—set env.LIVY_LIVY_SERVER_RECOVERY_STATE0STORE.value=filesystem
—set env.LIVY_SPARK_KUBERNETES_EXECUTOR_POD0NAME0PREFIX.value=myprefix
```