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.

# 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
   ```