# Puntos de conexión de desarrollo
**nota**
**La experiencia de consola para los puntos de conexión de desarrollo se eliminó a partir del 31 de marzo de 2023.** La creación, actualización y supervisión de los puntos de conexión de desarrollo siguen estando disponibles a través de la [API de puntos de conexión de desarrollo](aws-glue-api-dev-endpoint.md) y de la [CLI de AWS Glue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/index.html#cli-aws-glue).
Se recomienda migrar de los puntos de conexión de desarrollo a las sesiones interactivas por los motivos que se indican a continuación. Para conocer las acciones necesarias sobre cómo migrar de puntos de conexión de desarrollo a sesiones interactivas, consulte [Migración de puntos de conexión de desarrollo a sesiones interactivas](https://docs.aws.amazon.com/glue/latest/dg/development-migration-checklist.html).
| Descripción | Puntos de conexión de desarrollo | Sesiones interactivas |
| --- | --- | --- |
| Compatibilidad de la versión de Glue | Compatible con las versiones 0.9 y 1.0 de AWS Glue | Compatible con las versiones 2.0 y posteriores de AWS Glue |
| Los puntos de conexión de desarrollo no están disponibles en Asia-Pacífico (Yakarta) (ap-southeast-3), Medio Oriente (UAE) (me-central-1), Europa (España) (eu-south-2), Europa (Zúrich) (eu-central-2) ni en otras regiones nuevas que se establezcan en el futuro | Las sesiones interactivas no están disponibles actualmente en la región Medio Oriente (EAU) (me-central-1), pero es posible que estén disponibles más adelante. |
| Método de acceso al clúster de Spark | Compatible con SSH, intérprete de comandos de REPL, cuaderno de Jupyter, IDE (por ejemplo, PyCharm) | es compatible con el cuaderno de AWS Glue Studio, cuaderno de Jupyter, varios IDE (por ejemplo, Visual Studio Code, PyCharm) y cuaderno de IA de SageMaker |
| Tiempo de la primera consulta | Se necesitan entre 10 y 15 minutos para configurar un clúster de Spark | Puede tardar hasta 1 minuto en configurar un clúster de Spark efímero |
| Modelo de precios | AWS cobra por los puntos de conexión de desarrollo en función del momento en que se aprovisiona el punto de conexión y la cantidad de DPU. El tiempo de espera de los puntos de conexión de desarrollo no se agota. Hay una duración mínima de facturación de 10 minutos para cada punto de conexión de desarrollo aprovisionado. Además, AWS cobra por el cuaderno de Jupyter en instancias de Amazon EC2 y los cuadernos de IA de SageMaker cuando los configura con puntos de conexión de desarrollo. | AWS cobra por las sesiones interactivas en función del tiempo que la sesión está activa y de la cantidad de unidades de procesamiento de datos (DPU). Las sesiones interactivas tienen tiempos de inactividad configurables. Los cuadernos de AWS Glue Studio proporcionan una interfaz integrada para las sesiones interactivas y se ofrecen sin costo adicional. Hay una duración mínima de facturación de 1 minuto para cada sesión interactiva. Los cuadernos de AWS Glue Studio ofrecen una interfaz integrada para sesiones interactivas y se ofrecen sin costo adicional |
| Experiencia de consola | Solo está disponible a través de la CLI y la API | Disponible a través de la consola de AWS Glue, la CLI y las API |
# Migración de puntos de conexión de desarrollo a sesiones interactivas
Utilice la siguiente lista de comprobación para determinar el método adecuado para migrar de los puntos de conexión de desarrollo a las sesiones interactivas.
**¿Su script depende de características específicas de la versión 0.9 o 1.0 de AWS Glue (por ejemplo, HDFS, YARN, etc.)? **
Si la respuesta es sí, consulte [Migrar trabajos de AWS Glue a la versión 3.0 de AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html) para obtener información sobre cómo migrar de Glue 0.9 o 1.0 a Glue 3.0 y versiones posteriores.
**Qué método utiliza para acceder al punto de conexión de desarrollo?**
| Si utiliza este método | Haga esto |
| --- | --- |
| Cuaderno de IA de SageMaker, cuaderno de Jupyter o JupyterLab | Para migrar al [cuaderno de AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-gs-notebook.html), descargue los archivos .ipynb en Jupyter y cree un nuevo trabajo de cuaderno de AWS Glue Studio mediante la carga del archivo .ipynb. También puede utilizar [SageMaker AI Studio](https://aws.amazon.com/blogs/machine-learning/prepare-data-at-scale-in-amazon-sagemaker-studio-using-serverless-aws-glue-interactive-sessions/) y seleccionar el kernel de AWS Glue. |
| Bloc de notas de Zeppelin | Para convertir el cuaderno en un cuaderno de Jupyter de forma manual, copie y pegue el código; para hacerlo de forma automática, utilice un conversor de terceros, como ze2nb. A continuación, utilice el cuaderno en el cuaderno de AWS Glue Studio o en SageMaker AI Studio. |
| IDE | Consulte [Author AWS Glue jobs with PyCharm using AWS Glue interactive sessions](https://aws.amazon.com/blogs/big-data/author-aws-glue-jobs-with-pycharm-using-aws-glue-interactive-sessions/) o [Uso de las sesiones interactivas con Microsoft Visual Studio Code](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-vscode.html). |
| REPL | Para instalar [https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html) de manera local, ejecute el siguiente comando: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/development-migration-checklist.html) |
| SSH | No hay ninguna opción correspondiente en las sesiones interactivas. También puede utilizar una imagen de Docker. Para obtener más información, consulte [Desarrollo mediante una imagen de Docker](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-libraries.html#develop-local-docker-image). |
En las siguientes secciones, se ofrece información sobre el uso de puntos de conexión de desarrollo para desarrollar trabajos en AWS Glue versión 1.0.
**Topics**
+ [Migración de puntos de conexión de desarrollo a sesiones interactivas](development-migration-checklist.md)
+ [Desarrollo de scripts usando puntos de conexión de desarrollo](dev-endpoint.md)
+ [Administración de blocs de notas](notebooks-with-glue.md)
# Desarrollo de scripts usando puntos de conexión de desarrollo
**nota**
Los puntos de conexión de desarrollo solo son compatibles con versiones de AWS Glue anteriores a la 2.0. Si busca un entorno interactivo en el que pueda crear y probar scripts de ETL, utilice los [Blocs de notas en AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html).
AWS Glue puede crear un entorno, conocido como *punto de enlace de desarrollo*, que puede utilizar para desarrollar y probar de forma iterativa los scripts de extracción, transformación y carga (ETL). Puede crear, editar y eliminar puntos de enlace de desarrollo mediante la consola o la API de AWS Glue.
## Administración de su entorno de desarrollo
Al crear un punto de enlace de desarrollo, debe proporcionar valores de configuración para aprovisionar el entorno de desarrollo. Estos valores indican a AWS Glue cómo configurar la red para que pueda obtener acceso al punto de enlace de forma segura y que el punto de enlace pueda obtener acceso a sus almacenes de datos.
A continuación puede crear un bloc de notas que se conecte al punto de enlace y usar su bloc de notas para crear y probar su script ETL. Cuando esté satisfecho con los resultados de su proceso de desarrollo, podrá crear un flujo de trabajo de ETL que ejecute su script. Con este proceso, puede añadir funciones y depurar sus scripts de forma interactiva.
Siga los tutoriales de esta sección para aprender a utilizar su punto de enlace de desarrollo con blocs de notas.
**Topics**
+ [Administración de su entorno de desarrollo](#dev-endpoint-managing-dev-environment)
+ [Flujo de trabajo de punto de conexión de desarrollo](dev-endpoint-workflow.md)
+ [Cómo trabajan los puntos de conexión de desarrollo de AWS Glue con cuadernos de SageMaker](dev-endpoint-how-it-works.md)
+ [Añadir un punto de conexión de desarrollo.](add-dev-endpoint.md)
+ [Acceso al punto de conexión de desarrollo](dev-endpoint-elastic-ip.md)
+ [Tutorial: configuración de un cuaderno de Jupyter en JupyterLab para probar y depurar scripts ETL](dev-endpoint-tutorial-local-jupyter.md)
+ [Tutorial: uso de un cuaderno de IA de SageMaker con su punto de conexión de desarrollo](dev-endpoint-tutorial-sage.md)
+ [Tutorial: Utilice un REPL Shell con su punto de conexión de desarrollo](dev-endpoint-tutorial-repl.md)
+ [Tutorial: Configuración de PyCharm Professional con un punto de conexión de desarrollo](dev-endpoint-tutorial-pycharm.md)
+ [Configuración avanzada: uso compartido de puntos de conexión de desarrollo entre múltiples usuarios](dev-endpoint-sharing.md)
# Flujo de trabajo de punto de conexión de desarrollo
Para usar un punto de enlace de desarrollo de AWS Glue, puede seguir este flujo de flujo de trabajo.
1. Cree un punto de conexión de desarrollo mediante la API. El punto de enlace se lanza en una nube virtual privada (VPC) con sus grupos de seguridad definidos.
1. La API sondea el punto de conexión de desarrollo hasta que se aprovisione y esté listo para funcionar. Cuando esté listo, conéctese al punto de enlace de desarrollo utilizando uno de los siguientes métodos para crear y probar scripts AWS Glue.
+ Cree un cuaderno de IA de SageMaker en su cuenta. Para obtener más información acerca de cómo crear un blocs de notas, consulte [Creación de código con cuadernos de AWS Glue Studio](notebooks-chapter.md).
+ Abra una ventana de terminal para conectarse directamente a un punto de enlace de desarrollo.
+ Si tiene la edición Professional del [IDE de Python de PyCharm](https://www.jetbrains.com/pycharm/) de JetBrains, conéctela a un punto de enlace de desarrollo y úsela para su desarrollo interactivo. Si inserta instrucciones `pydevd` en su script, PyCharm puede admitir puntos de interrupción remotos.
1. Cuando termine de depurar y realizar pruebas en su punto de enlace de desarrollo, puede eliminarlo.
# Cómo trabajan los puntos de conexión de desarrollo de AWS Glue con cuadernos de SageMaker
Una de las formas comunes de acceder a sus puntos de enlace de desarrollo es usar [Jupyter](https://jupyter.org/) en los blocs de notas de SageMaker. El bloc de notas de Jupyter es una aplicación web de código abierto que se utiliza ampliamente en visualización, análisis, machine learning, etc. Un bloc de notas de SageMaker de AWS Glue le ofrece una experiencia de bloc de notas de Jupyter con puntos de enlace de desarrollo de AWS Glue. En el bloc de notas de SageMaker de AWS Glue, el entorno del bloc de notas de Jupyter está preconfigurado con [SparkMagic](https://github.com/jupyter-incubator/sparkmagic), un complemento de Jupyter de código abierto para enviar trabajos de Spark a un clúster remoto de Spark. [Apache Livy](https://livy.apache.org) es un servicio que permite la interacción con un clúster de Spark remoto a través de una API REST. En el bloc de notas de SageMaker de AWS Glue, SparkMagic está configurado para invocar la API REST hacia un servidor Livy que se ejecuta en un punto de enlace de desarrollo de AWS Glue.
El siguiente flujo de texto explica cómo funciona cada componente:
*Bloc de notas de SageMaker de AWS Glue: (Jupyter → SparkMagic) → (red) →punto de conexión de desarrollo de AWS Glue: (Apache Livy → Apache Spark)*
Una vez que ejecute el script de Spark escrito en cada párrafo en un bloc de notas de Jupyter, el código de Spark se envía al servidor Livy a través de SparkMagic, luego se ejecuta un trabajo de Spark llamado “livy-session-n” en el clúster de Spark. Este trabajo se llama sesión de Livy. El trabajo de Spark se ejecutará mientras la sesión del bloc de notas esté activa. El trabajo de Spark finalizará cuando cierre el kernel de Jupyter desde el bloc de notas, o cuando se agote el tiempo de espera de la sesión. Se inicia un trabajo de Spark por archivo de bloc de notas (.ipynb).
Puede utilizar un único punto de enlace de desarrollo de AWS Glue con varias instancias de bloc de notas de SageMaker. Puede crear varios archivos de bloc de notas en cada instancia de bloc de notas de SageMaker. Al abrir un archivo de cada bloc de notas y ejecutar los párrafos, se inicia una sesión de Livy por archivo de bloc de notas en el clúster de Spark a través de SparkMagic. Cada sesión de Livy corresponde a un solo trabajo de Spark.
## Comportamiento predeterminado de los puntos de conexión de desarrollo de AWS Glue y los cuadernos de SageMaker
Los trabajos de Spark se ejecutan en función de la [configuración de Spark](https://spark.apache.org/docs/2.4.3/configuration.html). Hay varias formas de establecer la configuración de Spark (por ejemplo, configuración de clúster de Spark, configuración de SparkMagic, etc.).
De forma predeterminada, Spark asigna recursos del clúster a una sesión de Livy en función de la configuración del clúster de Spark. En los puntos de desarrollo de AWS Glue, la configuración del clúster depende del tipo de empleado. A continuación, se incluye una tabla que explica las configuraciones comunes por tipo de empleado.
****
| | Standard | G.1 X | G.2 X |
| --- | --- | --- | --- |
| spark.driver.memory | 5 G | 10 G | 20 G |
| spark.executor.memory | 5 G | 10 G | 20 G |
| spark.executor.cores | 4 | 8 | 16 |
| spark.dynamicAllocation.enabled | TRUE | TRUE | TRUE |
El número máximo de ejecutores de Spark se calcula automáticamente mediante una combinación de DPU (o `NumberOfWorkers`) y tipo de empleado.
****
| | Standard | G.1 X | G.2 X |
| --- | --- | --- | --- |
| Cantidad máxima de ejecutores de Spark | (DPU - 1) \$1 2 - 1 | (NumberOfWorkers - 1) | (NumberOfWorkers - 1) |
Por ejemplo, si el punto de enlace de desarrollo tiene 10 empleados y el tipo de empleado es ` G.1X`, entonces tendrá 9 ejecutores de Spark y todo el clúster tendrá 90 G de memoria del ejecutor ya que cada ejecutor tendrá 10 G de memoria.
Independientemente del tipo de empleado especificado, se activará la asignación dinámica de recursos de Spark. Si un conjunto de datos es lo suficientemente grande, Spark puede asignar todos los ejecutores a una única sesión de Livy ya que `spark.dynamicAllocation.maxExecutors` no está configurado en forma predeterminada. Esto significa que otras sesiones de Livy en el mismo punto de enlace de desarrollo esperarán para lanzar nuevos ejecutores. Si el conjunto de datos es pequeño, Spark podrá asignar ejecutores a múltiples sesiones de Livy al mismo tiempo.
**nota**
Para obtener más información acerca de cómo se asignan los recursos en diferentes casos de uso y cómo se establece una configuración para modificar el comportamiento, consulte [Configuración avanzada: uso compartido de puntos de conexión de desarrollo entre múltiples usuarios](dev-endpoint-sharing.md).
# Añadir un punto de conexión de desarrollo.
Utilice puntos de enlace de desarrollo para desarrollar y probar iterativamente los scripts de extracción, transformación y carga (ETL) en AWS Glue. El trabajo con puntos de conexión de desarrollo solo está disponible a través de AWS Command Line Interface.
1. En una ventana de línea de comandos, escriba un comando similar al siguiente.
```
aws glue create-dev-endpoint --endpoint-name "endpoint1" --role-arn "arn:aws:iam::account-id:role/role-name" --number-of-nodes "3" --glue-version "1.0" --arguments '{"GLUE_PYTHON_VERSION": "3"}' --region "region-name"
```
Este comando especifica la versión de AWS Glue 1.0. Dado que esta versión es compatible con Python 2 y Python 3, puede utilizar el parámetro `arguments` para indicar la versión de Python deseada. Si se omite el parámetro `glue-version`, se presupone la versión de AWS Glue 0.9. Para obtener más información acerca de las versiones de AWS Glue, consulte [Glue version job property](add-job.md#glue-version-table).
Para obtener información sobre parámetros de línea de comandos adicionales, consulte [create-dev-endpoint](https://docs.aws.amazon.com/cli/latest/reference/glue/create-dev-endpoint.html) en la *Referencia de comandos de AWS CLI*.
1. (Opcional) Escriba el siguiente comando para comprobar el estado del punto de enlace de desarrollo. Cuando el estado cambia a `READY`, el punto de enlace de desarrollo está listo para su uso.
```
aws glue get-dev-endpoint --endpoint-name "endpoint1"
```
# Acceso al punto de conexión de desarrollo
Al crear un punto de enlace de desarrollo en una nube virtual privada (VPC), AWS Glue devuelve solo una dirección IP privada. El campo de dirección IP pública no se rellena. Al crear un punto de enlace de desarrollo que no pertenece a la VPC, AWS Glue devuelve solamente una dirección IP pública.
Si el punto de enlace de desarrollo tiene una **dirección pública**, confirme que es accesible con la clave privada SSH para el punto de enlace de desarrollo, como en el siguiente ejemplo.
```
ssh -i dev-endpoint-private-key.pem glue@public-address
```
Supongamos que el punto de enlace de desarrollo tiene una **dirección privada**, la subred de la VPC es direccionable desde la red pública de Internet y sus grupos de seguridad permiten el acceso de entrada desde el cliente. En este caso, siga estos pasos para adjuntar una *dirección IP elástica* a un punto de enlace de desarrollo para permitir el acceso desde Internet.
**nota**
Si desea utilizar direcciones IP elásticas, la subred que se está utilizando requiere una gateway de Internet asociada a través de la tabla de ruteo.
**Obtener acceso a un punto de enlace de desarrollo adjuntando una dirección IP elástica**
1. Abra la consola de AWS Glue en [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. En el panel de navegación, elija **Dev endpoints (Puntos de enlace de desarrollo)**, y vaya a la página de detalles del punto de enlace de desarrollo. Registre el valor de **Private address** (Dirección privada) para su uso en el siguiente paso.
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En el panel de navegación, en **Network & Security (Red y seguridad)**, seleccione **Network Interfaces (Interfaces de red)**.
1. Busque el valor de **Private DNS (IPv4)** (DNS privado, IPv4) que corresponde al valor de **Private address** (Dirección privada) en la página de detalles del punto de enlace de desarrollo de la consola de AWS Glue.
Es posible que tenga que modificar las columnas que desea mostrar en su consola de Amazon EC2. Anote el valor de **Network interface ID (ENI)** (ID de interfaz de red) correspondiente a esta dirección (por ejemplo, `eni-12345678`.
1. En la consola de Amazon EC2, en **Network & Security (Red y seguridad)**, elija **Elastic IPs (Direcciones IP elásticas)**.
1. Elija **Allocate new address (Asignar nueva dirección)** y, a continuación, elija **Allocate (Asignar)** para asignar una nueva dirección IP elástica.
1. En la página **Elastic IPs** (IP elásticas), elija la nueva **IP elástica** asignada recientemente. A continuación, elija **Actions** (Acciones) y **Associate address** (Asociar dirección).
1. En la página **Associate address (Asociar dirección)**, haga lo siguiente:
+ En **Tipo de recurso**, elija **Interfaz de red**.
+ En el campo **Network interface (Interfaz de red)**, escriba el **ID de interfaz de red** (ENI) de la dirección privada.
+ Elija **Asociar**.
1. Confirme que la dirección IP elástica recién asociada es accesible con la clave privada SSH asociada al punto de enlace de desarrollo, como en el siguiente ejemplo.
```
ssh -i dev-endpoint-private-key.pem glue@elastic-ip
```
Para ver más información acerca de cómo utilizar un host bastión para obtener acceso de SSH a la dirección privada del punto de enlace de desarrollo, consulte la publicación del blog de seguridad de AWS [Securely Connect to Linux Instances Running in a Private Amazon VPC (Conexión segura a instancias de Linux que se ejecutan en una VPC privada de Amazon)](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/).
# Tutorial: configuración de un cuaderno de Jupyter en JupyterLab para probar y depurar scripts ETL
En este tutorial, se conecta un bloc de notas Jupyter en JupyterLab que se ejecuta en su máquina local a un punto de enlace de desarrollo. Esto se hace para poder ejecutar, depurar y probar de forma interactiva los scripts de ETL (extracción, transformación y carga) de AWS Glue antes de implementarlos. Este tutorial utiliza enrutamiento de puertos Secure Shell (SSH) para conectar su máquina local a un punto de enlace de desarrollo de AWS Glue. Para obtener más información, consulte [Port forwarding (Enrutamiento de puertos)](https://en.wikipedia.org/wiki/Port_forwarding) en Wikipedia.
## Paso 1: instalar JupyterLab y Sparkmagic
Puede instalar JupyterLab con `conda` o `pip`. `conda` es un sistema de código abierto para la administración de paquetes y de entorno que se ejecuta en Windows, macOS y Linux. `pip` es el instalador del paquete para Python.
Si realizará la instalación en macOS, debe tener instalado Xcode para poder instalar Sparkmagic.
1. Instale JupyterLab, Sparkmagic y las extensiones relacionadas.
```
$ conda install -c conda-forge jupyterlab
$ pip install sparkmagic
$ jupyter nbextension enable --py --sys-prefix widgetsnbextension
$ jupyter labextension install @jupyter-widgets/jupyterlab-manager
```
1. Compruebe el directorio `sparkmagic` desde `Location`.
```
$ pip show sparkmagic | grep Location
Location: /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages
```
1. Cambie su directorio al devuelto para `Location`, e instale los kernels para Scala y PySpark.
```
$ cd /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages
$ jupyter-kernelspec install sparkmagic/kernels/sparkkernel
$ jupyter-kernelspec install sparkmagic/kernels/pysparkkernel
```
1. Descargue un archivo `config` de prueba.
```
$ curl -o ~/.sparkmagic/config.json https://raw.githubusercontent.com/jupyter-incubator/sparkmagic/master/sparkmagic/example_config.json
```
En este archivo de configuración, puede configurar los parámetros relacionados con Spark como `driverMemory` y `executorCores`.
## Paso 2: inicie JupyterLab
Cuando inicia JupyterLab, su navegador web predeterminado se abre automáticamente y se muestra la URL `http://localhost:8888/lab/workspaces/{workspace_name}`.
```
$ jupyter lab
```
## Paso 3: inicie el enrutamiento de puertos SSH para conectarse a su punto de conexión de desarrollo
A continuación, use el enrutamiento de puertos locales SSH para redireccionar un puerto local (aquí, `8998`) al destino remoto definido por AWS Glue (`169.254.76.1:8998`).
1. Abra una ventana de terminal independiente que le proporcione acceso a SSH. En Microsoft Windows, puede usar el shell de BASH proporcionado por [Git for Windows (Git para Windows)](https://git-scm.com/downloads) o instale [Cygwin](https://www.cygwin.com/).
1. Ejecute el siguiente comando SSH, modificado de la siguiente manera:
+ Reemplace `private-key-file-path` por una ruta al archivo `.pem` que contiene la clave privada que se corresponde con la clave pública que usó para crear su punto de enlace de desarrollo.
+ Si redirecciona un puerto distinto de `8998`, reemplace `8998` por el número de puerto que usa realmente de forma local. La dirección, `169.254.76.1:8998`, es el puerto remoto y no la modifica el usuario.
+ Reemplace `dev-endpoint-public-dns` por la dirección DNS pública de su punto de enlace de desarrollo. Para encontrar esta dirección, diríjase a su punto de enlace de desarrollo en la consola de AWS Glue, elija el nombre y copie la **Public address (Dirección pública)** que se enumera en la página **Endpoint details (Detalles del punto de enlace)**.
```
ssh -i private-key-file-path -NTL 8998:169.254.76.1:8998 glue@dev-endpoint-public-dns
```
Lo más probable es que vea un mensaje de advertencia similar al siguiente:
```
The authenticity of host 'ec2-xx-xxx-xxx-xx.us-west-2.compute.amazonaws.com (xx.xxx.xxx.xx)'
can't be established. ECDSA key fingerprint is SHA256:4e97875Brt+1wKzRko+JflSnp21X7aTP3BcFnHYLEts.
Are you sure you want to continue connecting (yes/no)?
```
Ingrese **yes** y deje la ventana de terminal abierta mientras usa JupyterLab.
1. Compruebe que el enrutamiento de puertos SSH funciona correctamente con el punto de enlace de desarrollo.
```
$ curl localhost:8998/sessions
{"from":0,"total":0,"sessions":[]}
```
## Paso 4: ejecute un fragmento de script sencillo en un párrafo del bloc de notas
Ahora su bloc de notas en JupyterLab debería funcionar con su punto de enlace de desarrollo. Escriba el siguiente fragmento de script en el bloc de notas y ejecútelo.
1. Compruebe que Spark se está ejecutando correctamente. El siguiente comando indica a Spark que calcule el `1` y luego imprima el valor.
```
spark.sql("select 1").show()
```
1. Compruebe si la integración AWS Glue Data Catalog está funcionando. En el siguiente comando se muestran las tablas del Catálogo de datos.
```
spark.sql("show tables").show()
```
1. Compruebe que un fragmento de script simple que use las bibliotecas de AWS Glue funcione.
El script a continuación utiliza los metadatos de la tabla `persons_json` en AWS Glue Data Catalog para crear un `DynamicFrame` a partir de sus datos de ejemplo. A continuación, imprime el recuento de elementos y el esquema de estos datos.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
# Create a Glue context
glueContext = GlueContext(SparkContext.getOrCreate())
# Create a DynamicFrame using the 'persons_json' table
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
# Print out information about *this* data
print("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
La salida del script es la siguiente.
```
Count: 1961
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- note: string
| | |-- name: string
| | |-- lang: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string
```
## Solución de problemas
+ Durante la instalación de JupyterLab, si su equipo está detrás de un proxy corporativo o firewall, es posible que encuentre errores HTTP y SSL debido a perfiles de seguridad personalizados administrados por departamentos de TI corporativos.
El siguiente es un ejemplo de un error típico que se produce cuando `conda` no puede conectarse a sus propios repositorios:
```
CondaHTTPError: HTTP 000 CONNECTION FAILED for url
```
Esto puede suceder porque su empresa puede bloquear conexiones a repositorios ampliamente utilizados en comunidades Python y JavaScript. Para obtener más información, consulte [Installation Problems (Problemas de instalación)](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html#installation-problems) en la página web de JupyterLab.
+ Si se encuentra ante un error de *connection refused (conexión rechazada)* al intentar conectar al punto de enlace de desarrollo, es posible que esté usando un punto de enlace de desarrollo que está desactualizado. Intente crear un nuevo punto de enlace de desarrollo y volver a conectarse.
# Tutorial: uso de un cuaderno de IA de SageMaker con su punto de conexión de desarrollo
En AWS Glue, puede crear un punto de conexión de desarrollo y, a continuación, crear un cuaderno de IA de SageMaker para desarrollar sus scripts de machine learning y ETL. Un cuaderno de IA de SageMaker es una instancia de computación de machine learning completamente administrada que ejecuta la aplicación Cuaderno de Jupyter.
1. En la consola de AWS Glue, seleccione **Puntos de enlace de desarrollo** para ir a la lista de puntos de enlace de desarrollo.
1. Seleccione la casilla situada junto al nombre de un punto de enlace de desarrollo que desee utilizar y, en el menú **Action (Acción)**, elija **Create SageMaker notebook (Crear bloc de notas de SageMaker)**.
1. Rellene la página **Create and configure a notebook (Crear y configurar un bloc de notas)** como se indica a continuación:
1. Escriba un nombre para el bloc de notas.
1. En **Attach to development endpoint (Asociar a un punto de enlace de desarrollo)**, verifique el punto de enlace de desarrollo.
1. Elija crear un rol AWS Identity and Access Management (IAM).
Se recomienda crear un rol. Si utiliza un rol existente, asegúrese de que tiene los permisos necesarios. Para obtener más información, consulte [Paso 6: Crear una política de IAM para cuadernos de IA de SageMaker](create-sagemaker-notebook-policy.md).
1. (Opcional) Elija una VPC, una subred y uno o varios grupos de seguridad.
1. (Opcional) Elija una clave de cifrado de AWS Key Management Service.
1. (Opcional) Añada etiquetas para la instancia de bloc de notas.
1. Elija **Crear cuaderno**. En la página **Notebooks (Blocs de notas)**, elija el icono de actualización que aparece en la parte superior derecha y continúe hasta que el **Status (Estado)** aparezca como `Ready`.
1. Seleccione la casilla situada junto al nombre del bloc de notas nuevo y, a continuación, elija **Open notebook (Abrir bloc de notas)**.
1. Cree un bloc de notas nuevo: en la página de **jupyter**, elija **New (Nuevo)** y, a continuación, seleccione **Sparkmagic (PySpark)**.
La pantalla que aparece debe ser similar a la siguiente:
![\[La página de jupyter tiene una barra de menús, una barra de herramientas y un amplio campo de texto en el que puede especificar instrucciones.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/sagemaker-notebook.png)
1. (Opcional) En la parte superior de la página, elija **Untitled (Sin título)** y asigne un nombre al bloc de notas.
1. Para iniciar una aplicación de Spark, escriba el comando siguiente en el bloc de notas y, a continuación, elija **Run (Ejecutar)** en la barra de herramientas.
```
spark
```
Después de un breve intervalo, debería ver la respuesta siguiente:
![\[La respuesta del sistema muestra el estado de la aplicación de Spark junto con el siguiente mensaje: SparkSession available as 'spark' (SparkSession disponible como “spark”).\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/spark-command-response.png)
1. Cree un marco dinámico y ejecute una consulta en él: copie, pegue y ejecute el código siguiente, que genera el recuento y el esquema de la tabla `persons_json`.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutorial: Utilice un REPL Shell con su punto de conexión de desarrollo
En AWS Glue puede crear un punto de enlace de desarrollo y, a continuación, invocar un shell REPL (bucle de lectura, evaluación e impresión) para ejecutar código de PySpark gradualmente para depurar interactivamente sus scripts de ETL antes de implementarlos.
Para usar un REPL en un punto de conexión de desarrollo, necesita tener autorización para usar SSH en el punto de conexión.
1. En el equipo local, abra una ventana de terminal que pueda ejecutar comandos SSH y pegue en ella el comando SSH editado. Ejecute el comando .
Suponiendo que aceptara la versión de AWS Glue 1.0 con Python 3 para el punto de conexión de desarrollo, el resultado será similar al siguiente:
```
Python 3.6.8 (default, Aug 2 2019, 17:42:44)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux
Type "help", "copyright", "credits" or "license" for more information.
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/usr/share/aws/glue/etl/jars/glue-assembly.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/usr/lib/spark/jars/slf4j-log4j12-1.7.16.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
2019-09-23 22:12:23,071 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Neither spark.yarn.jars nor spark.yarn.archive is set, falling back to uploading libraries under SPARK_HOME.
2019-09-23 22:12:26,562 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same name resource file:/usr/lib/spark/python/lib/pyspark.zip added multiple times to distributed cache
2019-09-23 22:12:26,580 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/etl/python/PyGlue.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/lib/spark/python/lib/py4j-src.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/libs/pyspark.zip added multiple times to distributed cache.
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/__ / .__/\_,_/_/ /_/\_\ version 2.4.3
/_/
Using Python version 3.6.8 (default, Aug 2 2019 17:42:44)
SparkSession available as 'spark'.
>>>
```
1. Compruebe que el shell REPL funcione correctamente escribiendo la instrucción `print(spark.version)`. Mientras esto muestre la versión de Spark, su REPL estará listo para su uso.
1. Ahora puede intentar ejecutar el siguiente script, que es sencillo, línea por línea, en el shell:
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutorial: Configuración de PyCharm Professional con un punto de conexión de desarrollo
En este tutorial, comprobará cómo conectar el IDE de Python [PyCharm Professional](https://www.jetbrains.com/pycharm/) que se ejecuta en su equipo local a un punto de enlace de desarrollo para que pueda ejecutar, depurar y probar de forma interactiva scripts de ETL (extraer, transferir y cargar) de AWS Glue antes de implementarlos. Las instrucciones y las capturas de pantalla del tutorial se basan en PyCharm Professional versión 2019.3.
Para conectarse a un punto de enlace de desarrollo de forma interactiva, debe haber instalado PyCharm Professional. Esto no podrá efectuarse con la edición gratuita.
**nota**
El tutorial utiliza Amazon S3 como origen de datos. Si desea utilizar un origen de datos JDBC en su lugar, debe ejecutar el punto de enlace de desarrollo en una nube virtual privada (VPC). Para conectarse con SSH a un punto de enlace de desarrollo en una instancia de VPC, debe crear un túnel SSH. Este tutorial no incluye instrucciones para crear túneles SSH. Para obtener información sobre el uso de SSH para conectarse a un punto de enlace de desarrollo en una VPC, consulte [Securely Connect to Linux Instances Running in a Private Amazon VPC (Conexión segura a instancias de Linux que se ejecutan en una instancia de Amazon VPC privada)](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/) en el blog de seguridad de AWS.
**Topics**
+ [Conexión de PyCharm Professional a un punto de conexión de desarrollo](#dev-endpoint-tutorial-pycharm-connect)
+ [Implementación del script en el punto de conexión de desarrollo](#dev-endpoint-tutorial-pycharm-deploy)
+ [Configuración de un intérprete remoto](#dev-endpoint-tutorial-pycharm-interpreter)
+ [Ejecución del script en el punto de conexión de desarrollo](#dev-endpoint-tutorial-pycharm-debug-run)
## Conexión de PyCharm Professional a un punto de conexión de desarrollo
1. Cree un nuevo proyecto de Python puro en PyCharm y llámelo `legislators`.
1. Cree un archivo denominado `get_person_schema.py` en el proyecto con el siguiente contenido:
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
def main():
# Create a Glue context
glueContext = GlueContext(SparkContext.getOrCreate())
# Create a DynamicFrame using the 'persons_json' table
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
# Print out information about this data
print("Count: ", persons_DyF.count())
persons_DyF.printSchema()
if __name__ == "__main__":
main()
```
1. Realice una de las siguientes acciones:
+ Para la versión 0.9 de AWS Glue, descargue el archivo de la biblioteca de Python de `PyGlue.zip`, AWS Glue, desde `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl/python/PyGlue.zip` en la ubicación que prefiera de su equipo local.
+ Para la versión 1.0 y posteriores de AWS Glue, descargue el archivo de la biblioteca de Python de AWS Glue, `PyGlue.zip`, desde `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl-1.0/python/PyGlue.zip` en la ubicación que prefiera de su equipo local.
1. Añada `PyGlue.zip` como raíz de contenido para el proyecto en PyCharm:
+ En PyCharm, seleccione **File** (Archivo) y **Settings** (Configuración) para abrir el cuadro de diálogo **Settings** (Configuración). (También puede pulsar `Ctrl+Alt+S`.)
+ Amplíe el proyecto `legislators` y seleccione **Project Structure** (Estructura del proyecto). A continuación, en el panel derecho, seleccione **\$1 Add Content Root** (\$1 Añadir raíz de contenido).
+ Vaya a la ubicación donde guardó `PyGlue.zip`, selecciónelo y, a continuación, seleccione **Apply** (Aplicar).
La pantalla **Settings** (Configuración) debe asemejarse a la siguiente:
![\[La pantalla de configuración de PyCharm con PyGlue.zip que se añadió como raíz de contenido.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/PyCharm_AddContentRoot.png)
Deje abierto el cuadro de diálogo **Settings** (Configuración) después de seleccionar **Apply** (Aplicar).
1. Configure las opciones de implementación para cargar el script local en el punto de enlace de desarrollo con SFTP (esta función solo está disponible en PyCharm Professional):
+ En el cuadro de diálogo **Settings** (Configuración), expanda la sección **Build, Execution, Deployment** (Generación, ejecución, implementación). Seleccione la subsección **Deployment** (Implementación).
+ Seleccione el icono **\$1** en la parte superior del panel central para añadir un nuevo servidor. Establezca **Type (Tipo)** en `SFTP` y asígnele un nombre.
+ Establezca el **SFTP host (Host SFTP)** en la opción de **Public address (Dirección pública)** de su punto de enlace de desarrollo, tal y como aparece en la página de detalles. (Elija el nombre del punto de enlace de desarrollo en la consola de AWS Glue para mostrar la página de detalles). Para un punto de enlace de desarrollo que se ejecuta en una instancia de VPC, establezca el valor de **SFTP host (Host SFTP)** en la dirección del host y el puerto local del túnel SSH en el punto de enlace de desarrollo.
+ Establezca **User name** (Nombre de usuario) en `glue`.
+ Establezca **Auth type** (Tipo de autenticación) en **Key pair (OpenSSH or Putty)** (Par de claves (OpenSSH o Putty)). Defina **Private key file** (Archivo de clave privada); para ello, vaya a la ubicación donde se encuentra el archivo de clave privada del punto de enlace de desarrollo. Tenga en cuenta que PyCharm solo es compatible con los tipos de claves DSA, RSA y ECDSA OpenSSH y no acepta claves en formato privado de Putty. Puede utilizar una versión actualizada de `ssh-keygen` para generar un tipo de par de claves que acepte PyCharm, usando una sintaxis como la siguiente:
```
ssh-keygen -t rsa -f -C ""
```
+ Seleccione **Test connection (Probar conexión)** y pruebe la conexión. Si la conexión se realiza correctamente, seleccione **Apply** (Aplicar).
La pantalla **Configuración** debe asemejarse ahora a la siguiente:
![\[La pantalla de configuración de PyCharm con un servidor SFTP definido.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/PyCharm_SFTP.png)
De nuevo, deje abierto el cuadro de diálogo **Settings** (Configuración) después de seleccionar **Apply** (Aplicar).
1. Asigne el directorio local a un directorio remoto para la implementación:
+ En el panel derecho de la página **Deployment** (Implementación), seleccione la pestaña central en la parte superior denominada **Mappings** (Mapeos).
+ En la columna **Deployment Path** (Ruta de la implementación), escriba una ruta en `/home/glue/scripts/` para la implementación de la ruta de su proyecto. Por ejemplo: `/home/glue/scripts/legislators`.
+ Seleccione **Aplicar**.
La pantalla **Configuración** debe asemejarse ahora a la siguiente:
![\[La pantalla de configuración de PyCharm después de mapear una implementación.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/PyCharm_Mapping.png)
Seleccione **OK (Aceptar)** para cerrar el cuadro de diálogo **Settings (Configuración)**.
## Implementación del script en el punto de conexión de desarrollo
1. Elija **Tools (Herramientas)**, **Deployment (Implementación)** y, a continuación, seleccione el nombre con el que ha configurado el punto de enlace de desarrollo, tal como se muestra en la imagen siguiente:
![\[El elemento de menú para implementar el script.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/PyCharm_Deploy.png)
Después de implementar el script, la parte inferior de la pantalla tendrá un aspecto similar al siguiente:
![\[La parte inferior de la pantalla de PyCharm después realizar correctamente una implementación.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/PyCharm_Deployed.png)
1. En la barra de menús, elija **Tools (Herramientas)**, **Deployment (Implementación)**, **Automatic Upload (always) [Carga automática (siempre)]**. Asegúrese de que aparezca una marca de verificación junto a **Automatic Upload (always) [Carga automática (siempre)]**.
Cuando esta opción está habilitada, PyCharm carga automáticamente los archivos modificados en el punto de enlace de desarrollo.
## Configuración de un intérprete remoto
Configure PyCharm para utilizar el intérprete de Python en el punto de enlace de desarrollo.
1. En el menú **File (Archivo)**, elija **Settings (Configuración)**.
1. Expanda los **legisladores** del proyecto y elija **Project Interpreter (Intérprete del proyecto)**.
1. Elija el icono de engranaje situado junto a la lista de **Project Interpreter (Intérprete del proyecto)** y, a continuación, elija **Add (Agregar)**.
1. En el cuadro de diálogo **Add Python Interpreter (Agregar intérprete de Python)**, en el panel izquierdo, elija **SSH Interpreter (Intérprete de SSH)**.
1. Elija **Existing server configuration (Configuración del servidor existente)** y, en la lista **Deployment configuration (Configuración de implementación)**, seleccione la configuración.
La pantalla tendrá un aspecto similar a la imagen siguiente:
![\[En el panel izquierdo aparece seleccionado SSH Interpreter (Intérprete de SSH) y, en el derecho, el botón de opción Existing server configuration (Configuración del servidor existente). El campo Deployment configuration (Configuración de implementación) contiene el nombre de la configuración y el mensaje “Remote SDK is saved in IDE settings, so it needs the deployment server to be saved there too. Which do you prefer? (El SDK remoto está guardado en la configuración de IDE, por lo que es necesario que el servidor de implementación se guarde allí también. ¿Cuál prefiere?)" Las opciones siguientes aparecen bajo el mensaje indicado: “Create copy of this deployment server in IDE settings (Crear copia de este servidor de implementación en la configuración de IDE)” y “Move this server to IDE settings (Mover este servidor a la configuración de IDE)”.\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/images/PyCharm_Interpreter1.png)
1. Elija **Move this server to IDE settings (Mover este servidor a la configuración de IDE)**, y, a continuación, elija **Next (Siguiente)**.
1. En el campo **Interpreter (Intérprete)**, cambie la ruta a` /usr/bin/gluepython` si está utilizando Python 2 o a `/usr/bin/gluepython3` si está utilizando Python 3. A continuación, elija **Finalizar**.
## Ejecución del script en el punto de conexión de desarrollo
Para ejecutar el script:
+ En el panel izquierdo, haga clic con el botón derecho en el nombre del archivo y elija **Run (Ejecutar) “**”**.
Después de una serie de mensajes, la salida final debe mostrar el recuento y el esquema.
```
Count: 1961
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string
Process finished with exit code 0
```
Ya ha terminado la configuración para depurar el script de forma remota en el punto de enlace de desarrollo.
# Configuración avanzada: uso compartido de puntos de conexión de desarrollo entre múltiples usuarios
En esta sección se explica cómo puede aprovechar los puntos de desarrollo con los blocs de notas de SageMaker en casos de uso habituales para compartir puntos de enlace de desarrollo entre múltiples usuarios.
## Configuración de tenencia única
En casos de uso de tenencia única, a fin de simplificar la experiencia del desarrollador y evitar la contención de recursos, se recomienda que cada desarrollador use su propio punto de enlace de desarrollo dimensionado para el proyecto en el que está trabajando. Esto también simplifica las decisiones relacionadas con el tipo de empleado y el recuento de DPU y las deja a discreción del desarrollador y según el proyecto en el que están trabajando.
No tendrá que ocuparse de la asignación de recursos a menos que ejecute múltiples archivos de bloc de notas en forma concurrente. Si ejecuta código en varios archivos de bloc de notas al mismo tiempo, se iniciarán múltiples sesiones de Livy en forma concurrente. Para segregar las configuraciones del clúster de Spark con el fin de ejecutar múltiples sesiones de Livy al mismo tiempo, puede seguir los pasos que se presentan en los casos de uso de multiinquilinos.
Por ejemplo, si el punto de enlace de desarrollo tiene 10 empleados y el tipo de empleado es ` G.1X`, entonces tendrá 9 ejecutores de Spark y todo el clúster tendrá 90 G de memoria del ejecutor ya que cada ejecutor tendrá 10 G de memoria.
Independientemente del tipo de empleado especificado, se activará la asignación dinámica de recursos de Spark. Si un conjunto de datos es lo suficientemente grande, Spark puede asignar todos los ejecutores a una única sesión de Livy ya que `spark.dynamicAllocation.maxExecutors` no está configurado en forma predeterminada. Esto significa que otras sesiones de Livy en el mismo punto de enlace de desarrollo esperarán para lanzar nuevos ejecutores. Si el conjunto de datos es pequeño, Spark podrá asignar ejecutores a múltiples sesiones de Livy al mismo tiempo.
**nota**
Para obtener más información acerca de cómo se asignan los recursos en diferentes casos de uso y cómo se establece una configuración para modificar el comportamiento, consulte [Configuración avanzada: uso compartido de puntos de conexión de desarrollo entre múltiples usuarios](#dev-endpoint-sharing).
### Configuración de multiinquilinos
**nota**
Tenga en cuenta que los puntos de enlace de desarrollo están destinados a emular el entorno ETL de AWS Glue como un entorno de tenencia única. Si bien el uso de multiinquilinos es posible, es un caso de uso avanzado y se recomienda que la mayoría de los usuarios mantengan un patrón de tenencia única para cada punto de enlace de desarrollo.
En casos de uso de multiinquilinos, es posible que tenga que ocuparse de la asignación de recursos. El factor clave es el número de usuarios concurrentes que usan un bloc de notas Jupyter al mismo tiempo. Si su equipo trabaja en un flujo de trabajo de “seguir el sol” y solo hay un usuario de Jupyter en cada zona horaria, entonces el número de usuarios concurrentes es solo uno, por lo que no tendrá que preocuparse por la asignación de recursos. Sin embargo, si su bloc de notas se comparte entre varios usuarios y cada usuario envía código de forma ad-hoc, tendrá que considerar los siguientes puntos.
Para particionar los recursos del clúster de Spark entre varios usuarios, puede usar configuraciones de SparkMagic. Existen dos formas diferentes de configurar SparkMagic.
#### (A) Use la directiva %%configure -f
Si desea modificar la configuración por cada sesión de Livy desde el bloc de notas, puede ejecutar la directiva `%%configure -f` en el párrafo del bloc de notas.
Por ejemplo, si desea ejecutar la aplicación Spark en 5 ejecutores, puede ejecutar el siguiente comando en el párrafo del bloc de notas.
```
%%configure -f
{"numExecutors":5}
```
Luego verá solo 5 ejecutores ejecutándose para el trabajo en la interfaz de usuario de Spark.
Recomendamos limitar el número máximo de ejecutores para la asignación dinámica de recursos.
```
%%configure -f
{"conf":{"spark.dynamicAllocation.maxExecutors":"5"}}
```
#### (B) Modificar el archivo de configuración de SparkMagic
SparkMagic funciona con base en la [API de Livy](https://livy.incubator.apache.org/docs/latest/rest-api.html). SparkMagic crea sesiones de Livy con configuraciones como `driverMemory`, ` driverCores`, `executorMemory`, `executorCores`, ` numExecutors`, `conf`, etc. Estos son los factores clave que determinan la cantidad de recursos que se consumen de todo el clúster de Spark. SparkMagic le permite proporcionar un archivo de configuración para especificar los parámetros que se envían a Livy. Puede ver un archivo de configuración de ejemplo en este [Repositorio GitHub](https://github.com/jupyter-incubator/sparkmagic/blob/master/sparkmagic/example_config.json).
Si desea modificar la configuración en todas las sesiones de Livy desde un bloc de notas, puede modificar `/home/ec2-user/.sparkmagic/config.json` para agregar `session_config`.
Para modificar el archivo de configuración en una instancia de bloc de notas de SageMaker, puede seguir estos pasos.
1. Abra un bloc de notas de SageMaker.
1. Abra el kernel del terminal.
1. Ejecute los comandos siguientes:
```
sh-4.2$ cd .sparkmagic
sh-4.2$ ls
config.json logs
sh-4.2$ sudo vim config.json
```
Por ejemplo, puede agregar estas líneas a ` /home/ec2-user/.sparkmagic/config.json` y reiniciar el kernel de Jupyter desde el bloc de notas.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
### Directrices y prácticas recomendadas
Para evitar este tipo de conflicto de recursos, puede usar algunos enfoques básicos como por ejemplo:
+ Tener un clúster de Spark más grande al aumentar el `NumberOfWorkers` (escalar horizontalmente) y actualizar el `workerType` (escalar verticalmente)
+ Asignar menos recursos por usuario (menos recursos por sesión de Livy)
Su enfoque dependerá del caso de uso. Si tiene un punto de enlace de desarrollo más grande y no hay una gran cantidad de datos, la posibilidad de un conflicto de recursos disminuirá significativamente porque Spark puede asignar recursos en función de una estrategia de asignación dinámica.
Como se describió con anterioridad, el número de ejecutores de Spark puede calcularse automáticamente con base en una combinación de DPU (o `NumberOfWorkers`) y tipo de empleado. Cada aplicación Spark lanza un controlador y varios ejecutores. Para calcular necesitará ` NumberOfWorkers` = `NumberOfExecutors + 1`. La siguiente matriz explica cuánta capacidad necesita en su punto de enlace de desarrollo en función del número de usuarios concurrentes.
****
| Número de usuarios concurrentes del bloc de notas | Número de ejecutores de Spark que desea asignar por usuario | Número total de empleados para su punto de enlace de desarrollo |
| --- | --- | --- |
| 3 | 5 | 18 |
| 10 | 5 | 60 |
| 50 | 5 | 300 |
Si desea asignar menos recursos por usuario, ` spark.dynamicAllocation.maxExecutors` (o `numExecutors`) sería el parámetro más fácil de configurar como parámetro de sesión de Livy. Si establece la siguiente configuración en `/home/ec2-user/.sparkmagic/config.json`, entonces SparkMagic asignará un máximo de 5 ejecutores por sesión de Livy. Esto ayudará a segregar recursos por sesión de Livy.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
Supongamos que hay un punto de enlace de desarrollo con 18 empleados (G-1 X) y que hay tres usuarios de bloc de notas concurrentes. Si la configuración de su sesión tiene ` spark.dynamicAllocation.maxExecutors=5` entonces cada usuario puede hacer uso de un controlador y cinco ejecutores. No habrá ningún conflicto de recursos incluso cuando ejecute varios párrafos de bloc de notas al mismo tiempo.
#### Compensación
Con esta configuración de sesión `"spark.dynamicAllocation.maxExecutors":"5"`, podrá evitar errores de conflictos de recursos y no necesitará esperar a la asignación de recursos cuando haya accesos de usuario concurrentes. Sin embargo, incluso cuando haya muchos recursos libres (por ejemplo, no hay otros usuarios concurrentes), Spark no puede asignar más de 5 ejecutores para su sesión de Livy.
#### Otras notas
Es una buena práctica detener el kernel de Jupyter cuando deje de usar un bloc de notas. Esto liberará recursos y otros usuarios de bloc de notas podrán usar esos recursos inmediatamente sin esperar al vencimiento del kernel (apagado automático).
### Problemas comunes
Es posible que experimentes ciertos problemas, aún cuando siga las pautas.
#### No se encuentra la sesión
Cuando intenta ejecutar un párrafo de bloc de notas aunque su sesión de Livy ya ha sido finalizada, verá el siguiente mensaje. Para habilitar la sesión de Livy, es necesario reiniciar el kernel de Jupyter al seleccionar **Kernel** > **Restart (Reiniciar)** en el menú Jupyter y, a continuación, vuelva a ejecutar el párrafo del bloc de notas.
```
An error was encountered:
Invalid status code '404' from http://localhost:8998/sessions/13 with error payload: "Session '13' not found."
```
#### No hay recursos suficientes de YARN
Cuando intenta ejecutar un párrafo de bloc de notas aunque su clúster de Spark no tenga suficientes recursos para iniciar una nueva sesión de Livy, verá el siguiente mensaje. En general, este problema se puede evitar si sigue las pautas; sin embargo, existe la posibilidad de que el problema surja. Para solucionar el problema, puede comprobar si hay alguna sesión de Livy activa que no sea necesaria. Si hay sesiones de Livy innecesarias, tendrá que finalizarlas para liberar los recursos del clúster. Para obtener más información, consulte la siguiente sección.
```
Warning: The Spark session does not have enough YARN resources to start.
The code failed because of a fatal error:
Session 16 did not start up in 60 seconds..
Some things to try:
a) Make sure Spark has enough available resources for Jupyter to create a Spark context.
b) Contact your Jupyter administrator to make sure the Spark magics library is configured correctly.
c) Restart the kernel.
```
### Monitoreo y depuración
En esta sección se describen las técnicas para monitorear los recursos y las sesiones.
#### Monitoreo y depuración de la asignación de recursos de clúster
Puede ver la interfaz de usuario de Spark para monitorear cuántos recursos se asignan por sesión de Livy y cuáles son las configuraciones efectivas de Spark mientras trabaja. Para habilitar la interfaz de usuario de Spark, consulte [Habilitación de la interfaz de usuario web de Apache Spark para puntos de enlace de desarrollo](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-dev-endpoints.html).
(Opcional) si necesita una vista en tiempo real de la interfaz de usuario de Spark, puede configurar un túnel SSH en relación con el servidor de historial de Spark que se ejecuta en el clúster de Spark.
```
ssh -i -N -L 8157::18080 glue@
```
Luego, puede abrir http://localhost:8157 en su navegador para ver la interfaz de usuario de Spark.
#### Sesiones de Livy libres innecesarias
Revise estos procedimientos para cerrar las sesiones de Livy innecesarias desde un bloc de notas o un clúster de Spark.
**(a). Finalizar sesiones de Livy desde un bloc de notas**
Puede apagar el kernel en un bloc de notas de Jupyter para finalizar las sesiones de Livy innecesarias.
**(b). Finalizar sesiones de Livy desde un clúster de Spark**
Si hay sesiones de Livy innecesarias que todavía se están ejecutando, puede cerrar las sesiones de Livy en el clúster de Spark.
Como requisito previo para realizar este procedimiento, debe configurar la clave pública SSH para el punto de enlace de desarrollo.
Para iniciar sesión en el clúster de Spark, puede ejecutar el siguiente comando:
```
$ ssh -i glue@
```
Puede ejecutar el siguiente comando para ver las sesiones activas de Livy:
```
$ yarn application -list
20/09/25 06:22:21 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/172.38.106.206:8032
Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):2
Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL
application_1601003432160_0005 livy-session-4 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-4-130.ec2.internal:41867
application_1601003432160_0004 livy-session-3 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-179-185.ec2.internal:33727
```
Puede cerrar la sesión de Livy con el siguiente comando:
```
$ yarn application -kill application_1601003432160_0005
20/09/25 06:23:38 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/255.1.106.206:8032
Killing application application_1601003432160_0005
20/09/25 06:23:39 INFO impl.YarnClientImpl: Killed application application_1601003432160_0005
```
# Administración de blocs de notas
**nota**
Los puntos de conexión de desarrollo solo son compatibles con versiones de AWS Glue anteriores a la 2.0. Si busca un entorno interactivo en el que pueda crear y probar scripts de ETL, utilice los [Blocs de notas en AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html).
Un cuaderno permite tareas de desarrollo y pruebas interactivas de sus scripts de ETL (extracción, transformación y carga) en un punto de conexión de desarrollo. AWS Glue proporciona una interfaz para cuadernos de Jupyter de IA de SageMaker. Con AWS Glue, el usuario crea y administra cuadernos de IA de SageMaker. También puede abrir cuadernos de IA de SageMaker desde la consola de AWS Glue.
Además, puede utilizar Apache Spark con IA de SageMaker en puntos de conexión de desarrollo de AWS Glue que admiten la IA de SageMaker (pero no trabajos de ETL de AWS Glue). SageMaker Spark es una biblioteca de Apache Spark de código abierto para la IA de SageMaker. Para obtener más información, consulte [Uso de Apache Spark con Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html).
| Región | Código |
| --- | --- |
| La administración de cuadernos de IA de SageMaker con los puntos de conexión de desarrollo de AWS Glue está disponible en las siguientes regiones de AWS: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/glue/latest/dg/notebooks-with-glue.html) |
| Este de EE. UU. (Ohio) | `us-east-2` |
| Este de EE. UU. (Norte de Virginia) | `us-east-1` |
| Oeste de EE. UU. (Norte de California) | `us-west-1` |
| Oeste de EE. UU. (Oregón) | `us-west-2` |
| Asia-Pacífico (Tokio) | `ap-northeast-1` |
| Asia-Pacífico (Seúl) | `ap-northeast-2` |
| Asia-Pacífico (Mumbai) | `ap-south-1` |
| Asia-Pacífico (Singapur) | `ap-southeast-1` |
| Asia-Pacífico (Sídney) | `ap-southeast-2` |
| Canadá (centro) | `ca-central-1` |
| Europa (Fráncfort) | `eu-central-1` |
| Europa (Irlanda) | `eu-west-1` |
| Europa (Londres) | `eu-west-2` |
**Topics**