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. # Ejecución de cargas de trabajo interactivas en Amazon EMR en EKS Un *punto de conexión interactivo* es una puerta de enlace que conecta Amazon EMR Studio con Amazon EMR en EKS para que pueda ejecutar cargas de trabajo interactivas. Puede usar puntos de conexión interactivos con EMR Studio para ejecutar análisis interactivos con conjuntos de datos en almacenes de datos como [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) y [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/). **Casos de uso** + Cree un script de ETL con la experiencia del IDE de EMR Studio. El IDE ingiere los datos en las instalaciones y los almacena en Amazon S3 después de las transformaciones para su posterior análisis. + Use cuadernos para explorar los conjuntos de datos y entrene un modelo de machine learning para detectar anomalías en los conjuntos de datos. + Cree scripts que generen informes diarios para aplicaciones analíticas, como los cuadros de mando empresariales. **Topics** + [Resumen de los puntos de conexión interactivos](how-it-works.md) + [Requisitos previos para crear un punto de conexión interactivo en Amazon EMR en EKS](prereqs-for-studio.md) + [Creación de un punto de conexión interactivo para su clúster virtual](create-managed-endpoint.md) + [Configuración de los ajustes de los puntos de conexión interactivos](managed-endpoint-parameters.md) + [Supervisión de puntos de conexión interactivos](managed-endpoints-customer-metrics.md) + [Uso de cuadernos Jupyter autoalojados](managed-endpoints-self-hosted.md) + [Obtener información sobre los puntos de conexión interactivos con comandos CLI](other-operations.md) # Resumen de los puntos de conexión interactivos Un *punto de conexión interactivo* proporciona la capacidad para que clientes interactivos como Amazon EMR Studio se conecten a clústeres de Amazon EMR en EKS para ejecutar cargas de trabajo interactivas. El punto de conexión interactivo está respaldado por una puerta de enlace de Jupyter Enterprise que proporciona la capacidad de administración remota del ciclo de vida de los kernels que necesitan los clientes interactivos. Los *kernels* son procesos específicos del lenguaje que interactúan con el cliente de Amazon EMR Studio basado en Jupyter para ejecutar cargas de trabajo interactivas. Los puntos de conexión interactivos admiten los siguientes kernels: + Python 3 + PySpark en Kubernetes + Apache Spark con Scala **nota** Los precios de Amazon EMR en EKS se aplican a los kernels y puntos de conexión interactivos. Para obtener más información, consulte la página [Precios de Amazon EMR en EKS](https://aws.amazon.com/emr/pricing/#Amazon_EMR_on_Amazon_EKS). Se requieren las siguientes entidades para que EMR Studio se conecte con Amazon EMR en EKS. + **Clúster virtual en Amazon EMR en EKS**: un *clúster virtual* es un espacio de nombres de Kubernetes con el que registra Amazon EMR. Amazon EMR utiliza clústeres virtuales para ejecutar trabajos y alojar puntos de conexión. Puede respaldar varios clústeres virtuales con el mismo clúster físico. Sin embargo, cada clúster virtual se asigna a un espacio de nombres de un clúster de Amazon EKS. Los clústeres virtuales no crean ningún recurso activo que contribuya a su factura o que requiera una administración del ciclo de vida externa al servicio. + **Punto de conexión interactivo de Amazon EMR en EKS**: un *punto de conexión interactivo* es un punto de conexión HTTPS al que los usuarios de EMR Studio pueden conectar un espacio de trabajo. Solo puede acceder a los puntos de conexión HTTPS desde EMR Studio y crearlos en una subred privada de Amazon Virtual Private Cloud (Amazon VPC) para su clúster de Amazon EKS. Los núcleos de Python y Spark Scala utilizan los permisos definidos en su función de ejecución de tareas de Amazon EMR en EKS para invocar otras. PySpark Servicios de AWS Todos los kernels y usuarios que se conectan al punto de conexión interactivo utilizan el rol que usted especificó al crear el punto de conexión. Le recomendamos que cree puntos de enlace independientes para los distintos usuarios y que los usuarios tengan funciones diferentes AWS Identity and Access Management (de IAM). + AWS Controlador **Application Load Balancer: el controlador AWS ** *Application Load Balancer administra Elastic Load Balancing* para un clúster de Amazon EKS Kubernetes. El controlador proporciona un equilibrador de carga de aplicación (ALB) al crear un recurso de Kubernetes Ingress. Un ALB expone un servicio de Kubernetes, como un punto de conexión interactivo, fuera del clúster de Amazon EKS, pero dentro de la misma Amazon VPC. Al crear un punto de conexión interactivo, también se implementa un recurso de Ingress que expone el punto de conexión interactivo mediante el ALB para que los clientes interactivos puedan conectarse a él. Solo necesita instalar un controlador AWS Application Load Balancer para cada clúster de Amazon EKS. En el siguiente diagrama, se muestra la arquitectura de puntos de conexión interactivos de Amazon EMR en EKS. Un clúster de Amazon EKS comprende la *computación* para ejecutar las cargas de trabajo analíticas y el *punto de conexión interactivo*. El controlador de equilibrador de carga de aplicación se ejecuta en el espacio de nombres `kube-system`; las cargas de trabajo y los puntos de conexión interactivos se ejecutan en el espacio de nombres que especifique al crear el clúster virtual. Al crear un punto de conexión interactivo, el plano de control de Amazon EMR en EKS crea la implementación del punto de conexión interactivo en el clúster de Amazon EKS. Además, el controlador del balanceador de carga crea una instancia de entrada al balanceador de AWS carga de aplicaciones. El equilibrador de carga de aplicación proporciona la interfaz externa para que clientes como EMR Studio se conecten al clúster de Amazon EMR y ejecuten cargas de trabajo interactivas. ![\[Diagrama de la arquitectura de puntos de conexión interactivos\]](http://docs.aws.amazon.com/es_es/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-managed-endpoints-architecture.png) # Requisitos previos para crear un punto de conexión interactivo en Amazon EMR en EKS En esta sección, se describen los requisitos previos para configurar un punto de conexión interactivo que EMR Studio pueda usar para conectarse a un clúster de Amazon EMR en EKS y ejecutar cargas de trabajo interactivas. ## AWS CLI Siga los pasos que se indican en [Instalar o actualizar a la versión más reciente de](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) () AWS CLI para instalar la última versión de AWS Command Line Interface ()AWS CLI. ## Instalación de eksctl Siga los pasos que se indican en [Instalar kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) para instalar la última versión de eksctl. Si utiliza Kubernetes 1.22 o una versión posterior para su clúster de Amazon EKS, utilice una versión de eksctl posterior a 0.117.0. ## Clúster Amazon EKS Cree un clúster de Amazon EKS. Registre el clúster como clúster virtual con Amazon EMR en EKS. A continuación, se detallan los requisitos y consideraciones para este clúster: + El clúster debe estar en la misma Amazon Virtual Private Cloud (VPC) que EMR Studio. + El clúster debe tener al menos una subred privada para activar los puntos de conexión interactivos, vincular los repositorios basados en Git y lanzar el equilibrador de carga de aplicación en modo privado. + Debe haber al menos una subred privada en común entre EMR Studio y el clúster de Amazon EKS que utilice para registrar el clúster virtual. Esto garantiza que el dispositivo de punto de conexión interactivo aparezca como una opción en sus espacios de trabajo de Studio y activa la conectividad desde Studio al equilibrador de carga de aplicación. Hay dos métodos entre los que puede elegir para conectar su Studio y su clúster de Amazon EKS: + Cree un clúster de Amazon EKS y asócielo a las subredes que pertenecen a EMR Studio. + Como alternativa, cree un EMR Studio y especifique las subredes privadas de su clúster de Amazon EKS. + Los ARM optimizados para Amazon EKS y Amazon Linux no AMIs son compatibles con Amazon EMR en los puntos de enlace interactivos de EKS. + Solo se [admiten los grupos de nodos gestionados por Amazon EKS y los](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html) nodos aprovisionados por Karpenter. ## Conceder acceso al clúster para Amazon EMR en EKS Siga los pasos de [Conceder acceso al clúster para Amazon EMR en EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html) para otorgar a Amazon EMR en EKS acceso a un espacio de nombres específico de su clúster. ## Activar los IRSA en el clúster de Amazon EKS Para activar los roles de IAM para las cuentas de servicio (IRSA) en el clúster de Amazon EKS, siga los pasos que se indican en [Habilitar roles de IAM para las cuentas de servicio (IRSA)](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html). ## Crear un rol de ejecución de trabajos de IAM Debe crear un rol de IAM para ejecutar cargas de trabajo en puntos de conexión interactivos de Amazon EMR. En esta documentación, nos referimos a este rol de IAM como *rol de ejecución de trabajos*. Este rol de IAM se asigna tanto al contenedor de punto de conexión interactivo como a los contenedores de ejecución reales que se crean al enviar trabajos con EMR Studio. El nombre de recurso de Amazon (ARN) de su rol de ejecución de trabajos de Amazon EMR en EKS. Hay dos pasos necesarios para esto: + [Cree un rol de IAM de ejecución de trabajos.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html) + [Actualice la política de confianza del rol de ejecución de trabajos.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-trust-policy.html) ## Otorgar a los usuarios acceso a Amazon EMR en EKS La entidad de IAM (usuario o rol) que lleva a cabo la solicitud para crear un punto de conexión interactivo también debe tener los siguientes permisos de Amazon EC2 y `emr-containers`. Siga los pasos descritos en [Otorgar a los usuarios acceso a Amazon EMR en EKS](setting-up-iam.md) para otorgar estos permisos que permiten a Amazon EMR en EKS crear, administrar y eliminar los grupos de seguridad que limitan el tráfico entrante al equilibrador de carga de su punto de conexión interactivo. Los siguientes permisos `emr-containers` permiten al usuario llevar a cabo operaciones básicas en puntos de conexión interactivos: ``` "ec2:CreateSecurityGroup", "ec2:DeleteSecurityGroup", "ec2:AuthorizeSecurityGroupEgress", "ec2:AuthorizeSecurityGroupIngress", "ec2:RevokeSecurityGroupEgress", "ec2:RevokeSecurityGroupIngress" "emr-containers:CreateManagedEndpoint", "emr-containers:ListManagedEndpoints", "emr-containers:DescribeManagedEndpoint", "emr-containers:DeleteManagedEndpoint" ``` ## Registrar el clúster de Amazon EKS con Amazon EMR Configure un clúster virtual y asígnelo al espacio de nombres del clúster de Amazon EKS en el que desee ejecutar sus trabajos. Para los clústeres AWS Fargate exclusivos, utilice el mismo espacio de nombres tanto para el clúster virtual Amazon EMR on EKS como para el perfil de Fargate. Para obtener información sobre la configuración de un clúster virtual de Amazon EMR en EKS, consulte [Registrar el clúster de Amazon EKS con Amazon EMR](setting-up-registration.md). ## Implemente el controlador AWS Load Balancer en el clúster de Amazon EKS Se necesita un AWS Application Load Balancer para su clúster de Amazon EKS. Solo tiene que configurar un controlador de equilibrador de carga de aplicación por clúster de Amazon EKS. Para obtener información sobre la configuración del controlador Load Balancer de AWS aplicaciones, consulte [Instalación del complemento Load AWS Balancer Controller en la](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) Guía del usuario de *Amazon EKS*. # Creación de un punto de conexión interactivo para su clúster virtual Este tema describe un par de formas de crear un punto final interactivo mediante la interfaz de línea de AWS comandos (AWS CLI) e incluye detalles sobre los parámetros de configuración disponibles. ## Crear un punto de conexión interactivo con el comando `create-managed-endpoint` Especifique los parámetros en el comando `create-managed-endpoint` de la siguiente manera. Amazon EMR en EKS admite la creación de puntos de conexión interactivos con las versiones 6.7.0 y posteriores de Amazon EMR. ``` aws emr-containers create-managed-endpoint \ ‐‐type JUPYTER_ENTERPRISE_GATEWAY \ ‐‐virtual‐cluster‐id 1234567890abcdef0xxxxxxxx \ ‐‐name example-endpoint-name \ ‐‐execution-role-arn arn:aws:iam::444455556666:role/JobExecutionRole \ ‐‐release-label emr-6.9.0-latest \ ‐‐configuration-overrides '{ "applicationConfiguration": [{ "classification": "spark-defaults", "properties": { "spark.driver.memory": "2G" } }], "monitoringConfiguration": { "cloudWatchMonitoringConfiguration": { "logGroupName": "log_group_name", "logStreamNamePrefix": "log_stream_prefix" }, "persistentAppUI": "ENABLED", "s3MonitoringConfiguration": { "logUri": "s3://my_s3_log_location" } } }' ``` Para obtener más información, consulte [Parámetros para crear un punto de conexión interactivo](#parameters-for-creating). ## Crear un punto de conexión interactivo con parámetros especificados en un archivo JSON 1. Cree un archivo `create-managed-endpoint-request.json` y especifique los parámetros necesarios para su punto de conexión, tal como se muestra en el siguiente archivo JSON: ``` { "name": "MY_TEST_ENDPOINT", "virtualClusterId": "MY_CLUSTER_ID", "type": "JUPYTER_ENTERPRISE_GATEWAY", "releaseLabel": "emr-6.9.0-latest", "executionRoleArn": "arn:aws:iam::444455556666:role/JobExecutionRole", "configurationOverrides": { "applicationConfiguration": [ { "classification": "spark-defaults", "properties": { "spark.driver.memory": "8G" } } ], "monitoringConfiguration": { "persistentAppUI": "ENABLED", "cloudWatchMonitoringConfiguration": { "logGroupName": "my_log_group", "logStreamNamePrefix": "log_stream_prefix" }, "s3MonitoringConfiguration": { "logUri": "s3://my_s3_log_location" } } } } ``` 1. Utilice el comando `create-managed-endpoint` con una ruta al archivo `create-managed-endpoint-request.json` que esté almacenado localmente o en Amazon S3. ``` aws emr-containers create-managed-endpoint \ ‐‐cli-input-json file://./create-managed-endpoint-request.json ‐‐region AWS-Region ``` ## Resultado de crear un punto de conexión interactivo Debería ver el siguiente resultado en el terminal. El resultado incluye el nombre y el identificador del nuevo punto de conexión interactivo: ``` { "id": "1234567890abcdef0", "name": "example-endpoint-name", "arn": "arn:aws:emr-containers:us-west-2:111122223333:/virtualclusters/444455556666/endpoints/444455556666", "virtualClusterId": "111122223333xxxxxxxx" } ``` La ejecución de `aws emr-containers create-managed-endpoint` crea un certificado autofirmado que permite la comunicación HTTPS entre EMR Studio y el servidor del punto de conexión interactivo. Si ejecuta `create-managed-endpoint` y no ha completado los requisitos previos, Amazon EMR devuelve un mensaje de error con las acciones que debe llevar a cabo para continuar. ## Parámetros para crear un punto de conexión interactivo **Topics** + [Parámetros obligatorios para los puntos de conexión interactivos](#parameters-for-creating-required) + [Parámetros opcionales para los puntos de conexión interactivos](#parameters-for-creating-optional) ### Parámetros obligatorios para los puntos de conexión interactivos Debe especificar los siguientes parámetros cuando cree un punto de conexión interactivo: **`‐‐type`** Utilice `JUPYTER_ENTERPRISE_GATEWAY`. Este es el único tipo admitido. **`‐‐virtual-cluster-id`** El identificador del clúster virtual que registró con Amazon EMR en EKS. **`‐‐name`** Un nombre descriptivo para el punto de conexión interactivo que ayuda a los usuarios de EMR Studio a seleccionarlo de la lista desplegable. **`‐‐execution-role-arn`** El nombre de recurso de Amazon (ARN) de su rol de ejecución de trabajos de IAM para Amazon EMR en EKS que se creó como parte de los requisitos previos. **`‐‐release-label`** La etiqueta de versión de la versión de Amazon EMR que se utilizará en el punto de conexión. Por ejemplo, `emr-6.9.0-latest`. Amazon EMR en EKS admite puntos de conexión interactivos con las versiones 6.7.0 y posteriores de Amazon EMR. ### Parámetros opcionales para los puntos de conexión interactivos De forma opcional, también puede especificar los parámetros siguientes al crear un punto de conexión interactivo: **`‐‐configuration-overrides`** Para anular las configuraciones predeterminadas de las aplicaciones, proporcione un objeto de configuración. Puede utilizar una sintaxis abreviada para proporcionar la configuración o hacer referencia al objeto de configuración en un archivo JSON. Los objetos de configuración se componen de una clasificación, propiedades y configuraciones anidadas opcionales. Las propiedades consisten en las configuraciones que desea anular en ese archivo. Es posible especificar varias clasificaciones para varias aplicaciones en un solo objeto JSON. Las clasificaciones de configuración disponibles varían en función de la versión de Amazon EMR en EKS. Para ver una lista de las clasificaciones de configuración que están disponibles para cada versión de lanzamiento de Amazon EMR en EKS, consulte [Versiones de Amazon EMR en EKS](emr-eks-releases.md). Además de las clasificaciones de configuración enumeradas para cada versión, los puntos de conexión interactivos incluyen la clasificación adicional `jeg-config`. Para obtener más información, consulte [Opciones de configuración de Jupyter Enterprise Gateway (JEG)](jeg-config-options.md). # Configuración de los ajustes de los puntos de conexión interactivos Esta sección contiene una serie de temas que abarcan diversas configuraciones de puntos de conexión interactivos y configuraciones de pods. Esto le permite supervisar y solucionar errores, enviar información de registro a Amazon S3 o a Amazon S3 o crear puntos de enlace interactivos en los que especifique plantillas de pods personalizadas. Amazon CloudWatch Logs **Topics** + [Supervisión de trabajos de Spark de](monitoring-spark-jobs.md) + [Especificar plantillas de pods personalizadas con puntos de conexión interactivos](custom-pod-templates.md) + [Implementación de un pod de JEG en un grupo de nodos](managed-endpoint-nodegroups-setup.md) + [Opciones de configuración de Jupyter Enterprise Gateway (JEG)](jeg-config-options.md) + [Modificar los parámetros PySpark de la sesión](modify-pyspark-parameters.md) + [Imagen de kernel personalizada con punto de conexión interactivo](custom-kernel.md) # Supervisión de trabajos de Spark de Para poder supervisar y solucionar los errores, configure los puntos de enlace interactivos de modo que los trabajos iniciados con el punto de conexión puedan enviar la información de registro a Amazon S3, Amazon CloudWatch Logs o a ambos. En las siguientes secciones, se describe cómo enviar los registros de las aplicaciones de Spark a Amazon S3 para los trabajos de Spark que lance con Amazon EMR en los puntos de conexión interactivos de EKS. **Configurar la política de IAM para los registros de Amazon S3** Para que los kernels puedan enviar datos de registro a Amazon S3, la política de permisos del rol de ejecución de trabajos debe incluir los siguientes permisos. Reemplace *amzn-s3-demo-destination-bucket* con el nombre de su bucket de registro. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:PutObject", "s3:GetObject", "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket", "arn:aws:s3:::amzn-s3-demo-bucket/*" ], "Sid": "AllowS3Putobject" } ] } ``` ------ **nota** Amazon EMR en EKS también puede crear un bucket de S3. Si no hay ningún bucket de S3 disponible, incluya el permiso `s3:CreateBucket` en la política de IAM. Una vez que haya otorgado a su rol de ejecución los permisos necesarios para enviar registros al bucket de S3, los datos de registro se envían a las siguientes ubicaciones de Amazon S3. Esto sucede cuando `s3MonitoringConfiguration` se pasa a la sección `monitoringConfiguration` de una solicitud `create-managed-endpoint`. + **Registros del controlador**: `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/spark-application-id-driver/(stderr.gz/stdout.gz)` + **Registros del ejecutor**: `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/executor-pod-name-exec-/(stderr.gz/stdout.gz)` **nota** Amazon EMR en EKS no carga los registros de los puntos de conexión a su bucket de S3. # Especificar plantillas de pods personalizadas con puntos de conexión interactivos Puede crear puntos de conexión interactivos en los que especifique plantillas de pods personalizadas para los controladores y ejecutores. Las *plantillas de pods* son especificaciones que determinan cómo ejecutar cada pod. Puede usar archivos de plantillas de pods para definir las configuraciones de los pods controladores o ejecutores que las configuraciones de Spark no admiten. Actualmente, las plantillas de pods son compatibles con las versiones 6.3.0 y posteriores de Amazon EMR. Para obtener más información sobre las plantillas de pods, consulte [Uso de plantillas de pods](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/pod-templates.html) en la *Guía de desarrollo de Amazon EMR en EKS*. En el ejemplo siguiente, se muestra cómo crear un punto de conexión interactivo con plantillas de pods: ``` aws emr-containers create-managed-endpoint \ --type JUPYTER_ENTERPRISE_GATEWAY \ --virtual-cluster-id virtual-cluster-id \ --name example-endpoint-name \ --execution-role-arn arn:aws:iam::aws-account-id:role/EKSClusterRole \ --release-label emr-6.9.0-latest \ --configuration-overrides '{ "applicationConfiguration": [ { "classification": "spark-defaults", "properties": { "spark.kubernetes.driver.podTemplateFile": "path/to/driver/template.yaml", "spark.kubernetes.executor.podTemplateFile": "path/to/executor/template.yaml" } }] }' ``` # Implementación de un pod de JEG en un grupo de nodos La colocación del pod de JEG (Jupyter Enterprise Gateway) es una característica que permite implementar un punto de conexión interactivo en un grupo de nodos específico. Con esta característica, puede configurar ajustes como `instance type` para el punto de conexión interactivo. ## Asociación de un pod de JEG a un grupo de nodos administrado La siguiente propiedad de configuración le permite especificar el nombre de un grupo de nodos administrado en el clúster de Amazon EKS en el que se implementará el pod de JEG. ``` //payload --configuration-overrides '{ "applicationConfiguration": [ { "classification": "endpoint-configuration", "properties": { "managed-nodegroup-name": NodeGroupName } } ] }' ``` Un grupo de nodos debe tener la etiqueta de Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` adjuntada a todos los nodos que forman parte del grupo de nodos. Para enumerar todos los nodos de un grupo de nodos que tienen esta etiqueta, use el siguiente comando: ``` kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` Si el resultado del comando anterior no devuelve los nodos que forman parte del grupo de nodos administrado, significa que no hay nodos en el grupo de nodos que tengan la etiqueta de Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` adjunta. En este caso, siga los pasos que se indican a continuación para adjuntar esa etiqueta a los nodos del grupo de nodos. 1. Use el comando siguiente para agregar la etiqueta de Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` a todos los nodos de un grupo de nodos administrado: `NodeGroupName` ``` kubectl label nodes --selector eks:nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` 1. Compruebe que los nodos estén etiquetados correctamente con el siguiente comando: ``` kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` Un grupo de nodos administrado debe estar asociado al grupo de seguridad de un clúster de Amazon EKS, lo que suele ocurrir si ha creado el clúster y el grupo de nodos administrado mediante `eksctl`. Puede verificarlo en la AWS consola mediante los siguientes pasos. 1. Vaya a su clúster en la consola de Amazon EKS. 1. Vaya a la pestaña de redes del clúster y anote su grupo de seguridad. 1. Vaya a la pestaña de procesamiento del clúster y haga clic en el nombre del grupo de nodos administrado. 1. En la pestaña **Detalles** del grupo de nodos administrado, compruebe que el grupo de seguridad del clúster que indicó anteriormente aparezca en **Grupos de seguridad**. Si el grupo de nodos administrado no está asociado al grupo de seguridad del clúster de Amazon EKS, debe adjuntar la etiqueta `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` al grupo de seguridad del grupo de nodos. Siga estos pasos para adjuntar la etiqueta. 1. Vaya a la consola de Amazon EC2 y haga clic en los grupos de seguridad del panel de navegación izquierdo. 1. Para seleccionar el grupo de seguridad del grupo de nodos administrado, haga clic en la casilla de verificación. 1. En la pestaña **Etiquetas**, agregue la etiqueta `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` con el botón **Administrar etiquetas**. ## Asociación de un pod de JEG a un grupo de nodos autoadministrado La siguiente propiedad de configuración le permite especificar el nombre de un grupo de nodos autoadministrado o no administrado en el clúster de Amazon EKS en el que se implementará el pod de JEG. ``` //payload --configuration-overrides '{ "applicationConfiguration": [ { "classification": "endpoint-configuration", "properties": { "self-managed-nodegroup-name": NodeGroupName } } ] }' ``` El grupo de nodos debe tener la etiqueta de Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` adjunta a todos los nodos que forman parte del grupo de nodos. Para enumerar todos los nodos de un grupo de nodos que tienen esta etiqueta, use el comando siguiente: ``` kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` Si el resultado del comando anterior no devuelve los nodos que forman parte del grupo de nodos autoadministrado, significa que no hay nodos en el grupo de nodos que tengan la etiqueta de Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` adjunta. En este caso, siga los pasos que se indican a continuación para adjuntar esa etiqueta a los nodos del grupo de nodos. 1. Si ha creado el grupo de nodos autoadministrado con `eksctl`, utilice el siguiente comando para agregar la etiqueta de Kubernetes `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` a todos los nodos del grupo de nodos autoadministrado `NodeGroupName` a la vez. ``` kubectl label nodes --selector alpha.eksctl.io/nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` Si no utilizó `eksctl` para crear el grupo de nodos autoadministrado, tendrá que sustituir el selector del comando anterior por una etiqueta de Kubernetes diferente que esté adjunta a todos los nodos del grupo de nodos. 1. Utilice el siguiente comando para verificar que los nodos estén etiquetados correctamente: ``` kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` El grupo de seguridad del grupo de nodos autoadministrado debe tener la etiqueta `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` adjunta. Siga estos pasos para adjuntar la etiqueta al grupo de seguridad desde la Consola de administración de AWS. 1. Vaya a la consola de Amazon EC2. En el panel de navegación izquierdo, elija **Grupos de seguridad**. 1. Seleccione la casilla de verificación junto al grupo de seguridad de su grupo de nodos autoadministrado. 1. En la pestaña **Etiquetas**, use el botón **Administrar etiquetas** para agregar la etiqueta `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName`. Sustituya `ClusterName` y `NodeGroupName` por los valores adecuados. ## Asociación de un pod de JEG a un grupo de nodos administrado con instancias bajo demanda También puede definir etiquetas adicionales, conocidas como *selectores de etiquetas de Kubernetes*, para especificar restricciones o restricciones adicionales para ejecutar un punto de conexión interactivo en un nodo o grupo de nodos determinado. En el ejemplo siguiente, se muestra cómo utilizar instancias de Amazon EC2 para un pod de JEG. ``` --configuration-overrides '{ "applicationConfiguration": [ { "classification": "endpoint-configuration", "properties": { "managed-nodegroup-name": NodeGroupName, "node-labels": "eks.amazonaws.com/capacityType:ON_DEMAND" } } ] }' ``` **nota** Solo puede usar la propiedad `node-labels` con una propiedad `managed-nodegroup-name` o `self-managed-nodegroup-name`. # Opciones de configuración de Jupyter Enterprise Gateway (JEG) Amazon EMR en EKS utiliza Jupyter Enterprise Gateway (JEG) para activar los puntos de conexión interactivos. Puede establecer los siguientes valores para las configuraciones de JEG permitidas cuando crea el punto de conexión. + **`RemoteMappingKernelManager.cull_idle_timeout`**: tiempo de espera en segundos (número entero), tras el cual el kernel se considera inactivo y listo para eliminarse. Los valores iguales a `0` o inferiores desactivan la eliminación selectiva. Los tiempos de espera cortos pueden provocar que se eliminen los kernels de los usuarios con conexiones de red deficientes. + **`RemoteMappingKernelManager.cull_interval`**: el intervalo en segundos (número entero) para comprobar si hay kernels inactivos que superen el valor de tiempo de espera de eliminación. # Modificar los parámetros PySpark de la sesión A partir de Amazon EMR en la versión 6.9.0 de EKS, en Amazon EMR Studio puede ajustar la configuración de Spark asociada a una PySpark sesión ejecutando el `%%configure` comando mágico en la celda del portátil EMR. En el siguiente ejemplo, se muestra una carga útil de muestra que puede usar para modificar la memoria, los núcleos y otras propiedades del controlador y ejecutor de Spark. En cuanto a los ajustes de `conf`, puede configurar cualquier configuración de Spark que se mencione en la [documentación de configuración de Apache Spark](https://spark.apache.org/docs/latest/configuration.html). ``` %%configure -f { "driverMemory": "16G", "driverCores": 4, "executorMemory" : "32G", "executorCores": 2, "conf": { "spark.dynamicAllocation.maxExecutors" : 10, "spark.dynamicAllocation.minExecutors": 1 } } ``` En el siguiente ejemplo, se muestra una carga útil de muestra que puede usar para agregar archivos, pyFiles y dependencias jar a un tiempo de ejecución de Spark. ``` %%configure -f { "files": "s3://amzn-s3-demo-bucket-emr-eks/sample_file.txt", "pyFiles": : "path-to-python-files", "jars" : "path-to-jars } ``` # Imagen de kernel personalizada con punto de conexión interactivo Para asegurarse de que disponga de las dependencias correctas para su aplicación cuando ejecute cargas de trabajo interactivas desde Amazon EMR Studio, puede personalizar las imágenes de Docker para los puntos de conexión interactivos y ejecutar imágenes de kernel base personalizadas. Para crear un punto de conexión interactivo y conectarlo a una imagen de Docker personalizada, siga estos pasos. **nota** Solo puede anular las imágenes base. No puede agregar nuevos tipos de imágenes de kernel. 1. **Cree y publique una imagen de Docker personalizada.** La imagen base contiene el tiempo de ejecución de Spark y los kernels del cuaderno que se ejecutan con él. Para crear la imagen, puede seguir los pasos del 1 al 4 de [Cómo personalizar las imágenes de Docker](docker-custom-images-steps.md). En el paso 1, `notebook-spark` debe usar el URI de imagen base del archivo de Docker en lugar de `spark`. ``` ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag ``` Para obtener más información sobre cómo seleccionar Regiones de AWS y almacenar etiquetas de imagen, consulte. [Información sobre cómo seleccionar un URI de imagen base](docker-custom-images-tag.md) 1. **Cree un punto de conexión interactivo que se pueda utilizar con la imagen personalizada.** 1. Cree un archivo JSON denominado `custom-image-managed-endpoint.json` con el siguiente contenido. En este ejemplo, se utiliza la versión 6.9.0 de Amazon EMR. **Example** ``` { "name": "endpoint-name", "virtualClusterId": "virtual-cluster-id", "type": "JUPYTER_ENTERPRISE_GATEWAY", "releaseLabel": "emr-6.9.0-latest", "executionRoleArn": "execution-role-arn", "configurationOverrides": { "applicationConfiguration": [ { "classification": "jupyter-kernel-overrides", "configurations": [ { "classification": "python3", "properties": { "container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-python:latest" } }, { "classification": "spark-python-kubernetes", "properties": { "container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-spark:latest" } } ] } ] } } ``` 1. Cree un punto de conexión interactivo con las configuraciones especificadas en el archivo JSON, tal como se muestra en el ejemplo siguiente. Para obtener más información, consulte [Crear un punto de conexión interactivo con el comando `create-managed-endpoint`](create-managed-endpoint.md#create-using-json-file). ``` aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json ``` 1. **Conéctese al punto de conexión interactivo a través de EMR Studio.** Para obtener más información y los pasos a seguir, consulte [Conectarse desde Studio](https://emr-on-eks.workshop.aws/advanced/emr-studio/connecting-from-studio.html) en la sección Amazon EMR en EKS de los documentos de AWS Workshop Studio. # Supervisión de puntos de conexión interactivos Con Amazon EMR en la versión 6.10 y posteriores de EKS, los puntos de enlace interactivos emiten métricas de CloudWatch Amazon para supervisar y solucionar problemas de las operaciones del ciclo de vida del kernel. Las métricas las activan clientes interactivos, como EMR Studio o los cuadernos de Jupyter autoalojados. Cada una de las operaciones compatibles con los puntos de conexión interactivos tiene métricas asociadas. Las operaciones se modelan como dimensiones de cada métrica, como se muestra en la siguiente tabla. Las métricas emitidas por los puntos de enlace interactivos están visibles en un espacio de nombres personalizado, en su cuenta. EMRContainers | Métrica | Description (Descripción) | Unidad | | --- | --- | --- | | RequestCount | Número acumulado de solicitudes de una operación procesadas por el punto de conexión interactivo. | Recuento | | RequestLatency | El tiempo desde que llegó una solicitud al punto de conexión interactivo y el punto de conexión interactivo envió una respuesta. | Milisegundos | | 4. XXError | Se emite cuando una solicitud de operación genera un error 4xx durante el procesamiento. | Recuento | | 5XXError | Se emite cuando la solicitud de una operación produce un error 5Xxx en el servidor. | Recuento | | KernelLaunchSuccess | Aplicable únicamente a la CreateKernel operación. Indica el número acumulado de lanzamientos del kernel que tuvieron éxito hasta esta solicitud incluida. | Recuento | | KernelLaunchFailure | Aplicable únicamente a la CreateKernel operación. Indica el número acumulado de errores de lanzamiento del kernel hasta esta solicitud incluida. | Recuento | Cada métrica de punto de conexión interactivo tiene las siguientes dimensiones asociadas: + **`ManagedEndpointId`**: identificador del punto de conexión interactivo + **`OperationName`**: la operación desencadenada por el cliente interactivo Los posibles valores de la dimensión **`OperationName`** se muestran en la siguiente tabla: | `operationName` | Descripción de la operación | | --- | --- | | `CreateKernel` | Solicite que el punto de conexión interactivo inicie un kernel. | | `ListKernels` | Solicite que el punto de conexión interactivo enumere los kernels que se han iniciado anteriormente con el mismo token de sesión. | | `GetKernel` | Solicite que el punto de conexión interactivo obtenga detalles sobre un kernel específico que se haya iniciado anteriormente. | | `ConnectKernel` | Solicite que el punto de conexión interactivo establezca la conectividad entre el cliente del cuaderno y el kernel. | | `ConfigureKernel` | Publique `%%configure magic request` en un kernel de PySpark. | | `ListKernelSpecs` | Solicite que el punto de conexión interactivo enumere las especificaciones del kernel disponibles. | | `GetKernelSpec` | Solicite al punto de conexión que obtenga las especificaciones del kernel de un kernel que se haya lanzado anteriormente. | | `GetKernelSpecResource` | Solicite que el punto de conexión interactivo obtenga recursos específicos asociados a las especificaciones del kernel que se hayan lanzado anteriormente. | ## Ejemplos ### Para acceder a la cantidad total de kernels lanzados para un punto de conexión interactivo en un día determinado: 1. Seleccione el espacio de nombres personalizado: `EMRContainers` 1. Seleccione su `ManagedEndpointId`, `OperationName – CreateKernel` 1. La métrica `RequestCount` con la estadística `SUM` y el periodo `1 day` proporcionará todas las solicitudes de lanzamiento del kernel hechas en las últimas 24 horas. 1. KernelLaunchSuccess La métrica con la estadística `SUM` y el período `1 day` proporcionará todas las solicitudes de lanzamiento del núcleo realizadas correctamente en las últimas 24 horas. ### Para acceder a la cantidad de errores del kernel para un punto de conexión interactivo en un día determinado: 1. Seleccione el espacio de nombres personalizado: EMRContainers 1. Seleccione su `ManagedEndpointId`, `OperationName – CreateKernel` 1. La métrica `KernelLaunchFailure` con la estadística `SUM` y el periodo `1 day` proporcionará todas las solicitudes de lanzamiento del kernel con errores hechas en las últimas 24 horas. También puede seleccionar las métricas `4XXError` y `5XXError` para saber qué tipo de error se ha producido en el lanzamiento del kernel. # Uso de cuadernos Jupyter autoalojados *Puede alojar y gestionar Jupyter o JupyterLab notebooks en una instancia de Amazon EC2 o en su propio clúster de Amazon EKS como un bloc de notas Jupyter autohospedado.* A continuación, puede ejecutar cargas de trabajo interactivas con sus cuadernos de Jupyter autoalojados. En las siguientes secciones se explica el proceso de configuración e implementación de un cuaderno de Jupyter autoalojado en un clúster de Amazon EKS. **Topics** + [Creación de un grupo de seguridad](#managed-endpoints-self-hosted-security) + [Crear un punto de conexión interactivo de Amazon EMR en EKS](#managed-endpoints-self-hosted-create-me) + [Recuperar la URL del servidor de puerta de enlace de su punto de conexión interactivo](#managed-endpoints-self-hosted-gateway) + [Recuperar un token de autenticación para conectarse al punto de conexión interactivo](#managed-endpoints-self-hosted-auth) + [Ejemplo: implementar un portátil JupyterLab](#managed-endpoints-self-hosted-example) + [Eliminar un cuaderno de Jupyter autoalojado](#managed-endpoints-self-hosted-cleanup) ## Creación de un grupo de seguridad Antes de poder crear un punto de conexión interactivo y ejecutar un Jupyter o un JupyterLab bloc de notas autohospedado, debe crear un grupo de seguridad para controlar el tráfico entre el portátil y el punto de conexión interactivo. Para usar la consola de Amazon EC2 o el SDK de Amazon EC2 para crear el grupo de seguridad, consulte los pasos en [Crear un grupo de seguridad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) en la *Guía del usuario de Amazon EC2*. Debe crear el grupo de seguridad en la VPC en la que desee implementar el servidor de su cuaderno. Para seguir el ejemplo de esta guía, utilice la misma VPC que su clúster de Amazon EKS. Si desea alojar su portátil en una VPC diferente de la VPC de su clúster de Amazon EKS, es posible que necesite crear una conexión de emparejamiento entre ambas. VPCs Para ver los pasos para crear una conexión de emparejamiento entre dos VPCs, consulte [Crear una conexión de emparejamiento de VPC en la Guía](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) de introducción de Amazon VPC. En el siguiente paso, necesitará el ID del grupo de seguridad para [crear un punto de conexión interactivo de Amazon EMR en EKS](https://docs.aws.amazon.com/). ## Crear un punto de conexión interactivo de Amazon EMR en EKS Después de crear el grupo de seguridad de su cuaderno, siga los pasos que se indican en [Creación de un punto de conexión interactivo para su clúster virtual](create-managed-endpoint.md) para crear un punto de conexión interactivo. Debe proporcionar el ID del grupo de seguridad que creó para su cuaderno en [Creación de un grupo de seguridad](#managed-endpoints-self-hosted-security). Inserte el ID de seguridad en lugar de los siguientes ajustes de *your-notebook-security-group-id* anulación de la configuración: ``` --configuration-overrides '{ "applicationConfiguration": [ { "classification": "endpoint-configuration", "properties": { "notebook-security-group-id": "your-notebook-security-group-id" } } ], "monitoringConfiguration": { ...' ``` ## Recuperar la URL del servidor de puerta de enlace de su punto de conexión interactivo Tras crear un punto de conexión interactivo, recupere la URL del servidor de puerta de enlace con el comando `describe-managed-endpoint` incluido en la AWS CLI. Necesita esta URL para conectar su cuaderno al punto de conexión. La URL del servidor de puerta de enlace es un punto de conexión privado. ``` aws emr-containers describe-managed-endpoint \ --region region \ --virtual-cluster-id virtualClusterId \ --id endpointId ``` Al principio, el estado del punto de conexión es **CREATING**. Pasados unos minutos, pasa al estado **ACTIVE**. Cuando el estado del punto de conexión sea **ACTIVE**, estará listo para usarse. Tome nota del atributo `serverUrl` que el comando `aws emr-containers describe-managed-endpoint` devuelve desde el punto de conexión activo. Necesitará esta URL para conectar su portátil al punto final al [implementar su Jupyter o portátil autohospedado](https://docs.aws.amazon.com/). JupyterLab ## Recuperar un token de autenticación para conectarse al punto de conexión interactivo Para conectarte a un punto final interactivo desde un Jupyter o un JupyterLab bloc de notas, debes generar un token de sesión con la API. `GetManagedEndpointSessionCredentials` El token actúa como prueba de autenticación para conectarse al servidor del punto de conexión interactivo. El siguiente comando se explica con más detalle con un ejemplo de resultado. ``` aws emr-containers get-managed-endpoint-session-credentials \ --endpoint-identifier endpointArn \ --virtual-cluster-identifier virtualClusterArn \ --execution-role-arn executionRoleArn \ --credential-type "TOKEN" \ --duration-in-seconds durationInSeconds \ --region region ``` **`endpointArn`** El ARN de su punto de conexión. Puede encontrar el ARN en el resultado de una llamada `describe-managed-endpoint`. **`virtualClusterArn`** El ARN del clúster virtual. **`executionRoleArn`** El ARN del rol de ejecución. **`durationInSeconds`** La duración en segundos durante la cual el token es válido. La duración predeterminada es de 15 minutos (`900`) y la máxima, de 12 horas (`43200`). **`region` ** La misma región que el punto de conexión. El resultado debería parecerse al siguiente ejemplo. Toma nota del `session-token` valor que utilizarás al [implementar tu Jupyter o portátil autohospedado](https://docs.aws.amazon.com/). JupyterLab ``` { "id": "credentialsId", "credentials": { "token": "session-token" }, "expiresAt": "2022-07-05T17:49:38Z" } ``` ## Ejemplo: implementar un portátil JupyterLab Una vez que haya completado los pasos anteriores, puede probar este procedimiento de ejemplo para implementar un JupyterLab bloc de notas en el clúster de Amazon EKS con su punto de enlace interactivo. 1. Cree un espacio de nombres para ejecutar el servidor de cuadernos. 1. Cree un archivo localmente denominado `notebook.yaml` y con el siguiente contenido. El contenido del archivo se describe a continuación. ``` apiVersion: v1 kind: Pod metadata: name: jupyter-notebook namespace: namespace spec: containers: - name: minimal-notebook image: jupyter/all-spark-notebook:lab-3.1.4 # open source image ports: - containerPort: 8888 command: ["start-notebook.sh"] args: ["--LabApp.token=''"] env: - name: JUPYTER_ENABLE_LAB value: "yes" - name: KERNEL_LAUNCH_TIMEOUT value: "400" - name: JUPYTER_GATEWAY_URL value: "serverUrl" - name: JUPYTER_GATEWAY_VALIDATE_CERT value: "false" - name: JUPYTER_GATEWAY_AUTH_TOKEN value: "session-token" ``` Si va a implementar el cuaderno de Jupyter en un clúster exclusivo de Fargate, etiquete el pod de Jupyter con una etiqueta de `role`, tal como se muestra en el siguiente ejemplo: ``` ... metadata: name: jupyter-notebook namespace: default labels: role: example-role-name-label spec: ... ``` **`namespace`** El espacio de nombres de Kubernetes en el que se implementa el cuaderno. **`serverUrl`** El atributo `serverUrl` que el comando `describe-managed-endpoint` devolvió en [Recuperar la URL del servidor de puerta de enlace de su punto de conexión interactivo](#managed-endpoints-self-hosted-gateway). **`session-token`** El atributo `session-token` que el comando `get-managed-endpoint-session-credentials` devolvió en [Recuperar un token de autenticación para conectarse al punto de conexión interactivo](#managed-endpoints-self-hosted-auth). **`KERNEL_LAUNCH_TIMEOUT`** La cantidad de tiempo en segundos que el punto de conexión interactivo espera a que el kernel entre en estado **RUNNING**. Asegúrese de que haya tiempo suficiente para que se complete el inicio del kernel configurando el tiempo de espera de inicio del kernel en un valor adecuado (máximo 400 segundos). **`KERNEL_EXTRA_SPARK_OPTS`** Si lo desea, puede transferir configuraciones de Spark adicionales a los kernels de Spark. Establezca esta variable de entorno con los valores como propiedad de configuración de Spark, tal como se muestra en el siguiente ejemplo: ``` - name: KERNEL_EXTRA_SPARK_OPTS value: "--conf spark.driver.cores=2 --conf spark.driver.memory=2G --conf spark.executor.instances=2 --conf spark.executor.cores=2 --conf spark.executor.memory=2G --conf spark.dynamicAllocation.enabled=true --conf spark.dynamicAllocation.shuffleTracking.enabled=true --conf spark.dynamicAllocation.minExecutors=1 --conf spark.dynamicAllocation.maxExecutors=5 --conf spark.dynamicAllocation.initialExecutors=1 " ``` 1. Implemente la especificación del pod en su clúster de Amazon EKS: ``` kubectl apply -f notebook.yaml -n namespace ``` Esto pondrá en marcha un JupyterLab portátil mínimo conectado a su terminal interactivo Amazon EMR en EKS. Espere a que el estado del pod sea **RUNNING**. Puede comprobarlo con el siguiente comando: ``` kubectl get pod jupyter-notebook -n namespace ``` Cuando el pod esté listo, el comando `get pod` devuelve un resultado similar al siguiente: ``` NAME READY STATUS RESTARTS AGE jupyter-notebook 1/1 Running 0 46s ``` 1. Adjunte el grupo de seguridad del cuaderno al nodo en el que está programado el cuaderno. 1. En primer lugar, identifique el nodo en el que está programado el pod de `jupyter-notebook` con el comando `describe pod`. ``` kubectl describe pod jupyter-notebook -n namespace ``` 1. Abra la consola Amazon EKS en [https://console.aws.amazon.com/eks/home\$1/clusters](https://console.aws.amazon.com/eks/home#/clusters). 1. Vaya a la pestaña **Computación** de su clúster de Amazon EKS y seleccione el nodo identificado por el comando `describe pod`. Seleccione el ID de la instancia para el nodo. 1. En el menú **Acciones**, seleccione **Seguridad** > **Cambiar grupos de seguridad** para adjuntar el grupo de seguridad que creó en [Creación de un grupo de seguridad](#managed-endpoints-self-hosted-security). 1. Si va a implementar el módulo de Jupyter Notebook AWS Fargate, cree un módulo []()para aplicarlo al módulo de Jupyter Notebook con la siguiente etiqueta de rol: ``` cat >my-security-group-policy.yaml < val x = random * 2 - 1 val y = random * 2 - 1 if (x*x + y*y <= 1) 1 else 0 }.reduce(_ + _) println(s"Pi is roughly ${4.0 * count / (n - 1)}") session.stop() ``` ![\[Captura de pantalla de un ejemplo del código de un cuaderno Scala. JupyterLab\]](http://docs.aws.amazon.com/es_es/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-scala-program.png) ## Eliminar un cuaderno de Jupyter autoalojado Cuando lo tenga todo listo para eliminar su cuaderno autoalojado, también puede eliminar el punto de conexión interactivo y el grupo de seguridad. Lleve a cabo las acciones en el siguiente orden: 1. Utilice el siguiente comando para eliminar el pod de `jupyter-notebook`: ``` kubectl delete pod jupyter-notebook -n namespace ``` 1. A continuación, elimine el punto de conexión interactivo con el comando `delete-managed-endpoint`. Para ver los pasos para eliminar un punto de conexión interactivo, consulte [Eliminar un punto de conexión interactivo](delete-managed-endpoint.md). Inicialmente, el estado del punto de conexión será **TERMINATING**. Una vez que se hayan depurado todos los recursos, pasará al estado **TERMINATED**. 1. Si no piensa utilizar el grupo de seguridad de cuadernos que creó en [Creación de un grupo de seguridad](#managed-endpoints-self-hosted-security) para otras implementaciones de cuaderno de Jupyter, puede eliminarlo. Para obtener más información, consulte [Eliminar un grupo de seguridad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#deleting-security-group) en la Guía del usuario de Amazon EC2. # Obtener información sobre los puntos de conexión interactivos con comandos CLI En este tema, se tratan las operaciones admitidas en un punto de conexión interactivo que no sean [`create-managed-endpoint`](create-managed-endpoint.md). ## Obtener detalles del punto de conexión interactivo Tras crear un punto final interactivo, puede recuperar sus detalles mediante el comando. `describe-managed-endpoint` AWS CLI Inserte sus propios valores para *managed-endpoint-id**virtual-cluster-id*, y*region*: ``` aws emr-containers describe-managed-endpoint ‐‐id managed-endpoint-id \ ‐‐virtual-cluster-id virtual-cluster-id ‐‐region region ``` El resultado tiene un aspecto similar al siguiente, con el punto de conexión especificado, como el ARN, el ID y el nombre. ``` { "id": "as3ys2xxxxxxx", "name": "endpoint-name", "arn": "arn:aws:emr-containers:us-east-1:1828xxxxxxxx:/virtualclusters/lbhl6kwwyoxxxxxxxxxxxxxxx/endpoints/as3ysxxxxxxxx", "virtualClusterId": "lbhl6kwwyoxxxxxxxxxxxxxxx", "type": "JUPYTER_ENTERPRISE_GATEWAY", "state": "ACTIVE", "releaseLabel": "emr-6.9.0-latest", "executionRoleArn": "arn:aws:iam::1828xxxxxxxx:role/RoleName", "certificateAuthority": { "certificateArn": "arn:aws:acm:us-east-1:1828xxxxxxxx:certificate/zzzzzzzz-e59b-4ed0-aaaa-bbbbbbbbbbbb", "certificateData": "certificate-data" }, "configurationOverrides": { "applicationConfiguration": [ { "classification": "spark-defaults", "properties": { "spark.driver.memory": "8G" } } ], "monitoringConfiguration": { "persistentAppUI": "ENABLED", "cloudWatchMonitoringConfiguration": { "logGroupName": "log-group-name", "logStreamNamePrefix": "log-stream-name-prefix" }, "s3MonitoringConfiguration": { "logUri": "s3-bucket-name" } } }, "serverUrl": "https://internal-k8s-namespace-ingressa-aaaaaaaaaa-zzzzzzzzzz.us-east-1.elb.amazonaws.com:18888 (https://internal-k8s-nspluto-ingressa-51e860abbd-1620715833.us-east-1.elb.amazonaws.com:18888/)", "createdAt": "2022-09-19T12:37:49+00:00", "securityGroup": "sg-aaaaaaaaaaaaaa", "subnetIds": [ "subnet-11111111111", "subnet-22222222222", "subnet-33333333333" ], "stateDetails": "Endpoint created successfully. It took 3 Minutes 15 Seconds", "tags": {} } ``` ## Enumerar todos los puntos de conexión interactivos asociados a un clúster virtual Utilice el `list-managed-endpoints` AWS CLI comando para obtener una lista de todos los puntos finales interactivos asociados a un clúster virtual específico. Reemplace `virtual-cluster-id` por el ID del clúster virtual. ``` aws emr-containers list-managed-endpoints ‐‐virtual-cluster-id virtual-cluster-id ``` El resultado del comando `list-managed-endpoint` se muestra a continuación: ``` { "endpoints": [{ "id": "as3ys2xxxxxxx", "name": "endpoint-name", "arn": "arn:aws:emr-containers:us-east-1:1828xxxxxxxx:/virtualclusters/lbhl6kwwyoxxxxxxxxxxxxxxx/endpoints/as3ysxxxxxxxx", "virtualClusterId": "lbhl6kwwyoxxxxxxxxxxxxxxx", "type": "JUPYTER_ENTERPRISE_GATEWAY", "state": "ACTIVE", "releaseLabel": "emr-6.9.0-latest", "executionRoleArn": "arn:aws:iam::1828xxxxxxxx:role/RoleName", "certificateAuthority": { "certificateArn": "arn:aws:acm:us-east-1:1828xxxxxxxx:certificate/zzzzzzzz-e59b-4ed0-aaaa-bbbbbbbbbbbb", "certificateData": "certificate-data" }, "configurationOverrides": { "applicationConfiguration": [{ "classification": "spark-defaults", "properties": { "spark.driver.memory": "8G" } }], "monitoringConfiguration": { "persistentAppUI": "ENABLED", "cloudWatchMonitoringConfiguration": { "logGroupName": "log-group-name", "logStreamNamePrefix": "log-stream-name-prefix" }, "s3MonitoringConfiguration": { "logUri": "s3-bucket-name" } } }, "serverUrl": "https://internal-k8s-namespace-ingressa-aaaaaaaaaa-zzzzzzzzzz.us-east-1.elb.amazonaws.com:18888 (https://internal-k8s-nspluto-ingressa-51e860abbd-1620715833.us-east-1.elb.amazonaws.com:18888/)", "createdAt": "2022-09-19T12:37:49+00:00", "securityGroup": "sg-aaaaaaaaaaaaaa", "subnetIds": [ "subnet-11111111111", "subnet-22222222222", "subnet-33333333333" ], "stateDetails": "Endpoint created successfully. It took 3 Minutes 15 Seconds", "tags": {} }] } ``` # Eliminar un punto de conexión interactivo Para eliminar un punto final interactivo asociado a un Amazon EMR en un clúster virtual de EKS, utilice el `delete-managed-endpoint` AWS CLI comando. Al eliminar un punto de conexión interactivo, Amazon EMR en EKS elimina los grupos de seguridad predeterminados que se crearon para ese punto de conexión. Especifique valores para los siguientes parámetros del comando: + **‐‐id:** el identificador del punto de conexión interactivo que se desea eliminar. + **‐ virtual-cluster-id ‐** El identificador del clúster virtual asociado al punto final interactivo que desea eliminar. Este es el mismo ID de clúster virtual que se especificó cuando se creó el punto de conexión interactivo. ``` aws emr-containers delete-managed-endpoint ‐‐id managed-endpoint-id ‐‐virtual-cluster-id virtual-cluster-id ``` El comando devuelve un resultado similar al siguiente para confirmar que se haya eliminado el punto de conexión interactivo: ``` { "id":"8gai4l4exxxxx", "virtualClusterId":"0b0qvauoy3ch1nqodxxxxxxxx" } ```