# Uso de Apache Spark en Amazon Athena
Amazon Athena facilita la ejecución interactiva del análisis y la exploración de datos mediante Apache Spark sin necesidad de planificar, configurar ni administrar los recursos. Ejecutar aplicaciones de Apache Spark en Athena significa enviar el código de Spark para su procesamiento y recibir los resultados directamente sin necesidad de configuración adicional. Apache Spark en Amazon Athena no requiere servidor y proporciona un escalado automático y bajo demanda que ofrece computación instantánea para cumplir con los cambios en los volúmenes de datos y los requisitos de procesamiento.
En la versión de lanzamiento [Versión 3 del motor PySpark](notebooks-spark-release-versions.md#notebooks-spark-release-versions-pyspark-3), puede utilizar la experiencia simplificada de cuadernos de la consola de Amazon Athena para desarrollar aplicaciones de Apache Spark mediante las API de cuadernos de Athena o Python.
En la versión de lanzamiento [Apache Spark versión 3.5](notebooks-spark-release-versions.md#notebooks-spark-release-versions-spark-35), puede ejecutar el código de Spark desde los cuadernos de Estudio unificado de Amazon SageMaker o desde sus clientes compatibles con Spark Connect preferidos.
Amazon Athena ofrece las siguientes características:
+ **Uso de la consola**: envíe aplicaciones de Spark desde la consola de Amazon Athena (solo motor de Pyspark versión 3).
+ **Creación de scripts**: cree y depure aplicaciones de Apache Spark en Python de forma rápida e interactiva.
+ **Escalado dinámico**: Amazon Athena determina automáticamente los recursos de procesamiento y memoria necesarios para ejecutar un trabajo y los escala continuamente en consecuencia hasta los máximos que usted especifique. Este escalado dinámico reduce los costos sin afectar a la velocidad.
+ **Experiencia con cuadernos**: utilice los cuadernos de Estudio unificado de Amazon SageMaker AI para crear, editar y ejecutar cálculos mediante una interfaz familiar. En la versión 3 del motor de Pyspark, puede usar los cuadernos integrados en la consola de Athena que son compatibles con los cuadernos de Jupyter y contienen una lista de celdas que se ejecutan en orden como cálculos. El contenido de las celdas puede incluir código, texto, Markdown, cálculos, gráficos y contenido multimedia enriquecido.
Para obtener información adicional, consulte [Ejecutar Spark SQL en Amazon Athena Spark](https://aws.amazon.com/blogs/big-data/run-spark-sql-on-amazon-athena-spark/) y [Explorar el lago de datos con Amazon Athena para Apache Spark](https://aws.amazon.com/blogs/big-data/explore-your-data-lake-using-amazon-athena-for-apache-spark/) en el *AWSblog de Big Data*.
**Topics**
+ [Versiones de lanzamiento](notebooks-spark-release-versions.md)
+ [Consideraciones y limitaciones](notebooks-spark-considerations-and-limitations.md)
+ [Introducción](notebooks-spark-getting-started.md)
+ [Administración de los archivos de cuaderno](notebooks-spark-managing.md)
+ [Editor de cuaderno](notebooks-spark-editor.md)
+ [Formatos de tabla que no son de Hive](notebooks-spark-table-formats.md)
+ [Compatibilidad con las bibliotecas Python](notebooks-spark-python-library-support.md)
+ [Especificación de configuración personalizada](notebooks-spark-custom-jar-cfg.md)
+ [Formatos de datos y almacenamiento compatibles](notebooks-spark-data-and-storage-formats.md)
+ [Supervisión de Apache Spark](notebooks-spark-metrics.md)
+ [Atribución de costos](notebooks-spark-cost-attribution.md)
+ [Registro y supervisión](notebooks-spark-logging-monitoring.md)
+ [Acceso a la interfaz de usuario de Spark](notebooks-spark-ui-access.md)
+ [Spark Connect](notebooks-spark-connect.md)
+ [Habilitación de buckets de pago por solicitante](notebooks-spark-requester-pays.md)
+ [Integración de Lake Formation](notebooks-spark-lakeformation.md)
+ [Habilitación del cifrado de Spark](notebooks-spark-encryption.md)
+ [Acceso al catálogo entre cuentas](spark-notebooks-cross-account-glue.md)
+ [Cuotas de servicio](notebooks-spark-quotas.md)
+ [API de Athena Spark](notebooks-spark-api-list.md)
+ [Solución de problemas](notebooks-spark-troubleshooting.md)
# Versiones de lanzamiento
Amazon Athena para Apache Spark ofrece las siguientes versiones de lanzamiento:
## Versión 3 del motor PySpark
La versión 3 de PySpark incluye Apache Spark, versión 3.2.1. Con esta versión, puede ejecutar el código de Spark en los cuadernos integrados en la consola de Athena.
## Apache Spark versión 3.5
La versión 3.5 de Apache Spark se basa en Amazon EMR 7.12 e incluye la versión 3.5.6 de Apache Spark. Con esta versión, puede ejecutar el código de Spark desde los cuadernos de Estudio unificado de Amazon SageMaker AI o desde sus clientes compatibles con Spark preferidos. Esta versión añade características clave para ofrecer una experiencia mejorada para las cargas de trabajo interactivas:
+ **Secure Spark Connect**: añade Spark Connect como punto de conexión de AWS autenticado y autorizado.
+ **Atribución de costos a nivel de sesión**: los usuarios pueden realizar un seguimiento de los costos por sesión interactiva en los informes de costos y uso o del Explorador de costos de AWS. Para obtener más información, consulte [Atribución de costos a nivel de sesión](notebooks-spark-cost-attribution.md).
+ **Capacidades de depuración avanzadas**: añade compatibilidad con la interfaz de usuario activa de Spark y el servidor de historial de Spark para depurar cargas de trabajo tanto desde las API como desde los cuadernos. Para obtener más información, consulte [Acceso a la interfaz de usuario de Spark](notebooks-spark-ui-access.md#notebooks-spark-ui-access-methods).
+ **Soporte de acceso sin filtros**: accede a las tablas protegidas de AWS Glue Data Catalog en las que dispones de todos los permisos necesarios. Para obtener más información, consulte [Uso de Lake Formation con los grupos de trabajo de Athena Spark](notebooks-spark-lakeformation.md).
### Propiedades predeterminadas de Spark
La siguiente tabla enumera las propiedades de Spark y sus valores predeterminados que se aplican a las sesiones de Athena SparkConnect.
| Key | Valor predeterminado | Descripción |
| --- | --- | --- |
| `spark.app.id` | `` | Esto no se puede modificar. |
| `spark.app.name` | `default` | |
| `spark.driver.cores` | `4` | La cantidad de núcleos que utiliza el controlador. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.driver.memory` | `10g` | La cantidad de memoria que utiliza el controlador. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.driver.memoryOverhead` | `6g` | Cantidad de sobrecarga de memoria asignada a las cargas de trabajo de Python y otros procesos que se ejecutan en el controlador. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.cortex.driver.disk` | `64g` | El disco del controlador de Spark. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.executor.cores` | `4` | El número de núcleos que usa cada ejecutor. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.executor.memory` | `10g` | La cantidad de memoria que utiliza el controlador. |
| `spark.executor.memoryOverhead` | `6g` | Cantidad de sobrecarga de memoria asignada a las cargas de trabajo de Python y otros procesos que se ejecutan en el ejecutor. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.cortex.executor.disk` | `64g` | El disco ejecutor de Spark. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.cortex.executor.architecture` | `AARCH_64` | Arquitectura del ejecutor. |
| `spark.driver.extraJavaOptions` | `-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false` | Opciones de Java adicionales para el controlador de Spark. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.executor.extraJavaOptions` | `-Djava.net.preferIPv6Addresses=false -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.invoke=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.ref=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.cs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.util.calendar=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED -Djdk.reflect.useDirectMethodHandle=false` | Opciones de Java adicionales para el ejecutor de Spark. Esto no se puede modificar durante el lanzamiento inicial. |
| `spark.executor.instances` | `1` | El número de contenedores de ejecutores de Spark que se asignarán. |
| `spark.dynamicAllocation.enabled` | `TRUE` | Opción que activa la asignación dinámica de recursos. Esta opción escala o reduce verticalmente el número de ejecutores registrados en la aplicación, en función de la carga de trabajo. |
| `spark.dynamicAllocation.minExecutors` | `0` | El límite superior del número de ejecutores si activa la asignación dinámica. |
| `spark.dynamicAllocation.maxExecutors` | `59` | El límite superior del número de ejecutores si activa la asignación dinámica. |
| `spark.dynamicAllocation.initialExecutors` | `1` | El número inicial de ejecutores que se ejecutarán si activa la asignación dinámica. |
| `spark.dynamicAllocation.executorIdleTimeout` | `60s` | El tiempo que un ejecutor puede permanecer inactivo antes de que Spark lo elimine. Esto solo se aplica si activa la asignación dinámica. |
| `spark.dynamicAllocation.shuffleTracking.enabled` | `TRUE` | La función DRA habilitada requiere que el seguimiento aleatorio esté activado. |
| `spark.dynamicAllocation.sustainedSchedulerBacklogTimeout` | `1s` | El tiempo de espera define el tiempo que el programador de Spark debe observar una acumulación sostenida de tareas pendientes antes de enviar una solicitud al administrador de clústeres para que lance nuevos ejecutores. |
| `spark.sql.catalogImplementation` | `hive` | |
| `spark.hadoop.hive.metastore.client.factory.class` | `com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory` | La clase de implementación del metaalmacén de AWS Glue. |
| `spark.hadoop.hive.metastore.glue.catalogid` | `` | accountId de AWS Glue Catalog. |
| `spark.sql.hive.metastore.sharedPrefixes` | `software.amazon.awssdk.services.dynamodb` | La propiedad especifica una lista de prefijos de paquetes separados por comas para las clases que debe cargar el ClassLoader de la aplicación en lugar del ClassLoader aislado creado para el código del cliente de Hive Metastore. |
| `spark.hadoop.fs.s3.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Define la implementación para que el cliente de S3 utilice S3A. |
| `spark.hadoop.fs.s3a.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Define la implementación para el cliente de S3A (S3A). |
| `spark.hadoop.fs.s3n.impl` | `org.apache.hadoop.fs.s3a.S3AFileSystem` | Define la implementación para que el cliente de S3 nativo (S3N) utilice S3A. |
| `spark.hadoop.fs.AbstractFileSystem.s3.impl` | `org.apache.hadoop.fs.s3a.S3A` | |
| `spark.hadoop.fs.s3a.aws.credentials.provider` | `software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider` | |
| `spark.hadoop.fs.s3.customAWSCredentialsProvider` | `com.amazonaws.auth.DefaultAWSCredentialsProviderChain` | |
| `spark.hadoop.mapreduce.output.fs.optimized.committer.enabled` | `TRUE` | Esta propiedad habilita un protocolo de confirmación optimizado para los trabajos de Spark al escribir datos en Amazon S3. Si se establece en true, ayuda a Spark a evitar costosas operaciones de cambio de nombre de archivos, lo que se traduce en escrituras atómicas más rápidas y fiables en comparación con el archivador predeterminado de Hadoop. |
| `spark.hadoop.fs.s3a.endpoint.region` | `` | Esta configuración establece de forma explícita la región de AWS del bucket de Amazon S3 al que se accede a través del cliente S3A. |
| `spark.hadoop.fs.s3.getObject.initialSocketTimeoutMilliseconds` | `2000` | Especifica el tiempo de espera de la conexión del socket en milisegundos. |
| `spark.hadoop.fs.s3a.committer.magic.enabled` | `TRUE` | Esto habilita el S3A “Magic” Committer, un protocolo de confirmación específico pero de alto rendimiento que depende del soporte del administrador de clústeres subyacente para rutas especiales. |
| `spark.hadoop.fs.s3a.committer.magic.track.commits.in.memory.enabled` | `TRUE` | Únicamente relevante cuando el Magic Committer está activado, especifica si la lista de archivos archivados por una tarea debe guardarse en la memoria en lugar de grabarse en archivos de disco temporales. |
| `spark.hadoop.fs.s3a.committer.name` | `magicv2` | Esta configuración selecciona de forma explícita el algoritmo específico del S3A Output Committer que se va a utilizar (p. ej., directorio, particionado o mágico). Al especificar el nombre, usted elige la estrategia que administra los datos temporales, gestiona los errores de las tareas y realiza la confirmación atómica final con la ruta de Amazon S3 de destino. |
| `spark.hadoop.fs.s3.s3AccessGrants.enabled` | `FALSE` | La propiedad permite la compatibilidad con las Concesiones de acceso a Amazon S3 al acceder a los datos de Amazon S3 a través del cliente del sistema de archivos S3A/EMRFS. |
| `spark.hadoop.fs.s3.s3AccessGrants.fallbackToIAM` | `FALSE` | Cuando las Concesiones de acceso a Amazon S3 están habilitadas, esta propiedad controla si el cliente de Amazon S3 debe recurrir a las credenciales de IAM tradicionales si la búsqueda de concesiones de acceso falla o no proporciona permisos suficientes. |
| `spark.pyspark.driver.python` | `/usr/bin/python3.11` | Ruta de Python para el controlador. |
| `spark.pyspark.python` | `/usr/bin/python3.11` | Ruta de Python para el ejecutor. |
| `spark.python.use.daemon` | `TRUE` | Esta configuración controla si Spark utiliza un proceso daemon de trabajo de Python en cada ejecutor. Cuando está habilitado (true, es el valor predeterminado), el ejecutor mantiene al trabajador de Python activo entre tareas para evitar la sobrecarga de iniciar e inicializar repetidamente un nuevo intérprete de Python para cada tarea, lo que mejora significativamente el rendimiento de las aplicaciones de PySpark. |
| `spark.sql.execution.arrow.pyspark.enabled` | `TRUE` | Permite el uso de Apache Arrow para optimizar la transferencia de datos entre los procesos de JVM y Python en PySpark. |
| `spark.sql.execution.arrow.pyspark.fallback.enabled` | `TRUE` | Propiedad de configuración que controla el comportamiento de Spark cuando se produce un error durante la transferencia de datos entre JVM y Python mediante la optimización de Apache Arrow. |
| `spark.sql.parquet.fs.optimized.committer.optimization-enabled` | `TRUE` | Propiedad de configuración que controla si Spark utiliza un archivador de archivos optimizado al escribir archivos de Parquet en determinados sistemas de archivos, específicamente en sistemas de almacenamiento en la nube como Amazon S3. |
| `spark.sql.parquet.output.committer.class` | `com.amazon.emr.committer.EmrOptimizedSparkSqlParquetOutputCommitter` | Propiedad de configuración de Spark que especifica el nombre de clase completo del OutputCommitter de Hadoop que se utilizará al escribir archivos Parquet. |
| `spark.resourceManager.cleanupExpiredHost` | `TRUE` | Esta propiedad controla si el controlador limpia activamente los recursos de la aplicación de Spark asociados a los ejecutores que se ejecutaban en nodos que se eliminaron o vencieron. |
| `spark.blacklist.decommissioning.enabled` | `TRUE` | La propiedad permite que la lógica de Spark ponga automáticamente en una lista negra a los ejecutores que el administrador de clústeres está procediendo a su desmantelamiento (apagado controlado). Esto evita que el programador envíe nuevas tareas a los ejecutores que están a punto de salir, lo que mejora la estabilidad laboral durante la reducción vertical de los recursos. |
| `spark.blacklist.decommissioning.timeout` | `1h` | El tiempo máximo que Spark esperará a que una tarea se migre correctamente de un ejecutor de desmantelamiento antes de incluir el host en una lista negra. |
| `spark.stage.attempt.ignoreOnDecommissionFetchFailure` | `TRUE` | Indica a Spark que sea indulgente y que no falle ni un intento de fase completa si se produce un error de recuperación al leer datos aleatorios de un ejecutor de desmantelamiento. El error de recuperación se considera recuperable, y Spark volverá a buscar los datos desde una ubicación diferente (es posible que sea necesario volver a calcularlos), por lo que dará prioridad a la finalización del trabajo antes que a la gestión estricta de los errores durante los apagados controlados. |
| `spark.decommissioning.timeout.threshold` | `20` | Esta propiedad suele usarse internamente o en configuraciones específicas de administradores de clústeres para definir la duración máxima total que Spark espera que dure el proceso de desmantelamiento de un host. Si el tiempo real de desmantelamiento supera este umbral, Spark podría tomar medidas agresivas, como incluir el host en una lista negra o solicitar la terminación forzosa, para liberar el recurso. |
| `spark.files.fetchFailure.unRegisterOutputOnHost` | `TRUE` | Cuando una tarea no consigue recuperar datos de modo aleatorio o RDD de un host específico, si se establece este valor en true, Spark debe anular el registro de todos los bloques de salida asociados a la aplicación que está fallando en ese host. Esto evita que las tareas futuras intenten obtener datos de un host poco fiable, lo que obliga a Spark a volver a calcular los bloques necesarios en otros lugares y aumenta la solidez del trabajo ante problemas de red intermitentes. |
# Consideraciones y limitaciones
## Apache Spark versión 3.5
Las siguientes son las consideraciones y limitaciones de la versión de lanzamiento de Apache Spark 3.5:
+ Esta versión de lanzamiento está disponible en las siguientes Regiones de AWS:
+ Asia-Pacífico (Mumbai)
+ Asia-Pacífico (Seúl)
+ Asia-Pacífico (Singapur)
+ Asia-Pacífico (Sídney)
+ Asia-Pacífico (Tokio)
+ Canadá (centro)
+ Europa (Fráncfort)
+ Europa (Irlanda)
+ Europa (Londres)
+ Europa (París)
+ Europa (Estocolmo)
+ América del Sur (São Paulo)
+ Este de EE. UU. (Norte de Virginia)
+ Este de EE. UU. (Ohio)
+ Oeste de EE. UU. (Oregón)
+ Esta versión del motor no es compatible con los cuadernos integrados en la consola ni las API de cuadernos de Athena. En cambio, esta versión viene integrada con los cuadernos de Estudio unificado de Amazon SageMaker AI. También puede usar clientes compatibles de Spark Connect.
+ API de cálculo: `StartCalculationExecution`,`ListCalculationExecutions` y `GetCalculationExecution` no son compatibles con esta versión.
+ No puede actualizar un grupo de trabajo de la versión 3 del motor de PySpark a la versión 3.5 de Apache Spark.
## Versión 3 del motor Pyspark
Las siguientes son las consideraciones y limitaciones de la versión de lanzamiento del motor de Pyspark, versión 3:
+ Esta versión de lanzamiento está disponible en las siguientes Regiones de AWS:
+ Asia-Pacífico (Mumbai)
+ Asia-Pacífico (Singapur)
+ Asia-Pacífico (Sídney)
+ Asia-Pacífico (Tokio)
+ Europa (Fráncfort)
+ Europa (Irlanda)
+ Este de EE. UU. (Norte de Virginia)
+ Este de EE. UU. (Ohio)
+ Oeste de EE. UU. (Oregón)
+ AWS Lake Formation no se admite.
+ No se admiten las tablas que utilizan proyección de particiones.
+ Los grupos de trabajo habilitados para Apache Spark pueden usar el editor de cuadernos de Athena, pero no el editor de consultas de Athena. Solo los grupos de trabajo de Athena SQL pueden usar el editor de consultas de Athena.
+ No se admiten las consultas de vista entre motores. Athena para Spark no puede consultar las vistas creadas por Athena SQL. Dado que las vistas de los dos motores se implementan de manera diferente, no son compatibles para el uso entre motores.
+ No se admiten MLlib (biblioteca de machine learning de Apache Spark) y el paquete `pyspark.ml`. Para obtener una lista de las bibliotecas Python compatibles, consulte [Lista de bibliotecas de Python preinstaladas](notebooks-spark-preinstalled-python-libraries.md).
+ Actualmente, `pip install` no es compatible con Athena para las sesiones de Spark.
+ Solo se permite una sesión activa por cuaderno.
+ Cuando varios usuarios utilizan la consola para abrir una sesión existente en un grupo de trabajo, acceden al mismo cuaderno. Para evitar confusiones, abra solo las sesiones que cree usted mismo.
+ Los dominios de host de las aplicaciones de Apache Spark que puede utilizar con Amazon Athena (por ejemplo, `analytics-gateway.us-east-1.amazonaws.com`) están registrados en la [Lista de sufijos públicos (PSL)](https://publicsuffix.org/list/public_suffix_list.dat) de Internet. Si alguna vez necesita configurar cookies confidenciales en sus dominios, le recomendamos que utilice cookies con un prefijo `__Host-` para proteger su dominio de los intentos de falsificación de solicitudes entre sitios (CSRF). Para obtener más información, consulte la página [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#cookie_prefixes) en la red de desarrolladores de Mozilla.org.
+ Para obtener información sobre la solución de problemas de cuadernos, sesiones y grupos de trabajo de Spark en Athena, consulte [Solución de problemas de Athena para Spark](notebooks-spark-troubleshooting.md).
# Introducción a Apache Spark en Amazon Athena
**nota**
Para la versión de lanzamiento de Apache Spark 3.5, siga la guía de introducción de los [cuadernos de SageMaker](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html). Utilice esta guía para la versión de lanzamiento del motor de Pyspark, versión 3.
Para empezar a usar Apache Spark en Amazon Athena, primero cree un grupo de trabajo habilitado para Spark. Después de cambiar al grupo de trabajo, puede crear un cuaderno o abrir uno existente. Al abrir un cuaderno en Athena, se inicia automáticamente una nueva sesión y puede trabajar con él directamente en el editor de cuadernos de Athena.
**nota**
Asegúrese de crear un grupo de trabajo habilitado para Spark antes de crear un cuaderno.
## Paso 1: crear un grupo de trabajo habilitado para Spark en Athena
Puede usar [grupos de trabajo](workgroups-manage-queries-control-costs.md) en Athena para agrupar usuarios, equipos, aplicaciones o cargas de trabajo, así como para realizar un seguimiento de los costos. Para usar Apache Spark en Amazon Athena, debe crear un grupo de trabajo de Amazon Athena que utilice un motor de Spark.
**nota**
Los grupos de trabajo habilitados para Apache Spark pueden usar el editor de cuadernos de Athena, pero no el editor de consultas de Athena. Solo los grupos de trabajo de Athena SQL pueden usar el editor de consultas de Athena.
**Para crear un grupo de trabajo habilitado para Spark en Athena**
1. Abra la consola de Athena en [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Si el panel de navegación de la consola no está visible, elija el menú de expansión de la izquierda.
![\[Elija el menú de expansión.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/nav-pane-expansion.png)
1. En el panel de navegación, elija **Grupos de trabajo**.
1. En el panel **Grupos de trabajo**, elija **Crear grupo de trabajo**.
1. En **Workgroup name** (Nombre del grupo de trabajo), ingrese un nombre para el grupo de trabajo de Apache Spark.
1. (Opcional) En **Description** (Descripción), ingrese una descripción para el grupo de trabajo.
1. En **Analytics engine** (Motor de análisis), elija **Apache Spark**.
**nota**
Tras crear un grupo de trabajo, no se puede cambiar su tipo de motor de análisis. Por ejemplo, un grupo de trabajo de la versión 3 del motor de Athena no se puede cambiar a un grupo de trabajo de la versión 3 del motor de PySpark.
1. Para los fines de este tutorial, seleccione **Turn on example notebook** (Activar un cuaderno de ejemplo). Esta característica opcional agrega un cuaderno de ejemplo con el nombre `example-notebook-random_string` al grupo de trabajo y agrega los permisos asociados a AWS Glue que el cuaderno utiliza para crear, mostrar y eliminar bases de datos y tablas específicas de su cuenta, así como los permisos de lectura en Amazon S3 para el conjunto de datos de ejemplo. Para ver los permisos agregados, elija **View additional permissions details** (Ver detalles de permisos adicionales).
**nota**
La ejecución del cuaderno de ejemplo puede suponer un costo adicional.
1. En la **configuración de resultados de cálculo**, seleccione una de las siguientes opciones:
+ **Create a new S3 bucket** (Crear un nuevo bucket de S3): esta opción crea un bucket de Amazon S3 en su cuenta para los resultados de sus cálculos. El nombre del bucket tiene el formato `account_id-region-athena-results-bucket-alphanumeric_id` y utiliza las configuraciones de ACL inhabilitadas, acceso público bloqueado, control de versiones inhabilitado y propietario de bucket aplicado.
+ **Choose an existing S3 location** (Elegir una ubicación de S3 existente): en esta opción, haga lo siguiente:
+ Ingrese la ruta de S3 a una ubicación existente en el cuadro de búsqueda o elija **Browse S3** (Examinar S3) para elegir un bucket de una lista.
**nota**
Al seleccionar una ubicación existente en Amazon S3, no agregue una barra diagonal (`/`) a la ubicación. Si lo hace, el enlace a la ubicación de los resultados del cálculo en la [página de detalles del cálculo](#notebooks-spark-getting-started-viewing-session-and-calculation-details) apuntará al directorio equivocado. Si esto ocurre, edite la ubicación de los resultados del grupo de trabajo para eliminar la barra diagonal situada al final.
+ (Opcional) Elija **View** (Ver) para abrir la página **Buckets** de la consola de Amazon S3, donde podrá ver más información sobre el bucket existente que haya elegido.
+ (Opcional) En **Expected bucket owner** (Propietario esperado del bucket), ingrese el ID de cuenta de AWS que espera que sea el propietario de su bucket de ubicación de salida de los resultados de las consultas. Le recomendamos que elija esta opción como medida de seguridad adicional siempre que sea posible. Si el ID de cuenta del propietario del bucket no coincide con el ID que especifique, los intentos de generar el bucket generarán errores. Para obtener información detallada, consulte [Verificación de la propiedad del bucket con la condición de propietario del bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html) en la *Guía del usuario de Amazon S3*.
+ (Opcional) Seleccione **Assign bucket owner full control over query results** (Asignar al propietario del bucket control total sobre los resultados de las consultas) si la ubicación de los resultados de cálculo pertenece a otra cuenta y desea concederle el control total sobre los resultados de sus consultas.
1. (Opcional) Seleccione **Cifrar resultados de las consultas** si desea cifrar los resultados de su consulta.
+ En **Tipo de cifrado**, seleccione una de las siguientes opciones:
+ **SSE\$1S3**: esta opción utiliza cifrado del servidor (SSE) con claves de cifrado administradas por Amazon S3.
+ **SSE\$1KMS**: esta opción utiliza cifrado del servidor (SSE) con claves administradas por AWS KMS.
En **Elegir una clave AWS KMS**, seleccione una de las siguientes opciones.
+ **Usar clave de AWS**: la clave AWS KMS está bajo la propiedad y administración de AWS. No se cobrará ningún cargo adicional por el uso de esta clave.
+ **Elegir una clave AWS KMS diferente (avanzado)**: para esta opción, realice una de las siguientes acciones:
+ Para usar una clave existente, utilice el cuadro de búsqueda para elegir una clave de AWS KMS o ingresar un ARN de clave.
+ Para crear una clave en la consola de AWS KMS, elija **Crear una clave de AWS KMS**. Su rol de ejecución debe tener permiso para utilizar la clave que cree. Después de crear la clave en la consola de KMS, vuelva a la página **Crear grupo de trabajo** de la consola de Athena y, a continuación, utilice el cuadro de búsqueda **Elegir una clave de AWS KMS o ingresar un ARN** para elegir la clave que acaba de crear.
**importante**
Al cambiar la [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) de un grupo de trabajo, los cuadernos administrados antes de la actualización siguen haciendo referencia a la antigua clave de KMS. Los cuadernos administrados después de la actualización utilizan la nueva clave de KMS. Para actualizar los cuadernos antiguos para que hagan referencia a la nueva clave de KMS, exporte y después importe cada uno de los cuadernos antiguos. Si elimina la clave de KMS antigua antes de actualizar las referencias de los cuadernos antiguos a la nueva clave de KMS, los cuadernos antiguos ya no se pueden descifrar ni recuperar.
Este comportamiento también se aplica a las actualizaciones de los [alias](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html), que son nombres descriptivos de las claves de KMS. Al actualizar un alias de clave de KMS para que apunte a una nueva clave de KMS, los cuadernos administrados antes de la actualización del alias siguen haciendo referencia a la clave de KMS antigua, y los cuadernos administrados después de la actualización del alias utilizan la nueva clave de KMS. Tenga en cuenta estos puntos antes de actualizar las claves o alias de KMS.
1. En **configuraciones adicionales**, elija **Usar valores predeterminados**. Esta opción lo ayuda a empezar con su grupo de trabajo habilitado para Spark. Cuando utiliza los valores predeterminados, Athena crea un rol de IAM y una ubicación para los resultados de cálculo en Amazon S3. El nombre del rol de IAM y la ubicación del bucket de S3 que se van a crear aparecen en el cuadro situado debajo del encabezado **Additional configurations** (Configuraciones adicionales).
Si no desea utilizar los valores predeterminados, continúe con los pasos en la sección [(Opcional) Especificación de sus propias configuraciones de grupo de trabajo](#notebooks-spark-getting-started-workgroup-configuration) para configurar su grupo de trabajo de forma manual.
1. (Opcional) **Tags** (Etiquetas): utilice esta opción para agregar etiquetas al grupo de trabajo. Para obtener más información, consulte [Etiquetado de recursos de Athena](tags.md).
1. Elija **Crear grupo de trabajo**. Un mensaje le informa de que el grupo de trabajo se ha creado correctamente y aparecerá en la lista de grupos de trabajo.
### (Opcional) Especificación de sus propias configuraciones de grupo de trabajo
Si desea especificar su propio rol de IAM y ubicación para los resultados de cálculo del cuaderno, siga los pasos de esta sección. Si ha elegido **Use defaults** (Usar valores predeterminados) en la opción **Additional configurations** (Configuraciones adicionales), omita esta sección y vaya directamente a [Paso 2: abrir el explorador de cuadernos y cambiar de grupo de trabajo](#notebooks-spark-getting-started-switching-workgroups-and-opening-notebook-explorer).
El siguiente procedimiento supone que ha completado los pasos del 1 al 9 del procedimiento **Para crear un grupo de trabajo habilitado para Spark en Athena** de la sección anterior.
**Para especificar configuraciones propias de grupo de trabajo**
1. Si desea crear o utilizar su propio rol de IAM o configurar el cifrado del cuaderno, expanda **IAM role configuration** (Configuración del rol de IAM).
+ En **Rol de servicio que autoriza Athena**, elija una de las siguientes opciones:
+ **Crear y usar un nuevo rol de servicio**: elija esta opción para que Athena cree un rol de servicio para usted. Para ver los permisos que concede el rol, elija **View permission details** (Ver detalles de los permisos).
+ **Usar un rol de servicio existente**: desde el menú desplegable, seleccione un rol existente. El rol que elija debe incluir los permisos de la primera opción. Para obtener más información sobre los permisos de los grupos de trabajo habilitados para cuadernos, consulte [Solución de problemas de grupos de trabajo habilitados para Spark](notebooks-spark-troubleshooting-workgroups.md).
+ En **Notebook and calculation code encryption key management** (Administrar las claves de cifrado del cuaderno y el código de cálculo), elija una de las siguientes opciones:
+ **Cifrar usando clave de AWS (predeterminado)**: la clave AWS KMS está bajo la propiedad y administración de AWS. No se cobrará ningún cargo adicional por el uso de esta clave.
+ **Cifrar con su propia clave AWS KMS**: para esta opción, realice una de las siguientes acciones:
+ Para usar una clave existente, utilice el cuadro de búsqueda para elegir una clave de AWS KMS o ingresar un ARN de clave.
+ Para crear una clave en la consola de AWS KMS, elija **Crear una clave de AWS KMS**. Su rol de ejecución debe tener permiso para utilizar la clave que cree. Después de crear la clave en la consola de KMS, vuelva a la página **Crear grupo de trabajo** de la consola de Athena y, a continuación, utilice el cuadro de búsqueda **Elegir una clave de AWS KMS o ingresar un ARN** para elegir la clave que acaba de crear.
**importante**
Al cambiar la [AWS KMS key](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html) de un grupo de trabajo, los cuadernos administrados antes de la actualización siguen haciendo referencia a la antigua clave de KMS. Los cuadernos administrados después de la actualización utilizan la nueva clave de KMS. Para actualizar los cuadernos antiguos para que hagan referencia a la nueva clave de KMS, exporte y después importe cada uno de los cuadernos antiguos. Si elimina la clave de KMS antigua antes de actualizar las referencias de los cuadernos antiguos a la nueva clave de KMS, los cuadernos antiguos ya no se pueden descifrar ni recuperar.
Este comportamiento también se aplica a las actualizaciones de los [alias](https://docs.aws.amazon.com/kms/latest/developerguide/kms-alias.html), que son nombres descriptivos de las claves de KMS. Al actualizar un alias de clave de KMS para que apunte a una nueva clave de KMS, los cuadernos administrados antes de la actualización del alias siguen haciendo referencia a la clave de KMS antigua, y los cuadernos administrados después de la actualización del alias utilizan la nueva clave de KMS. Tenga en cuenta estos puntos antes de actualizar las claves o alias de KMS.
1. (Opcional) **Other settings** (Otras configuraciones): expanda esta opción para activar o desactivar la opción **Publish CloudWatch metrics** (Publicar métricas de CloudWatch) del grupo de trabajo. Este campo se selecciona de forma predeterminada. Para obtener más información, consulte [Supervisión de Apache Spark con métricas de CloudWatch](notebooks-spark-metrics.md).
1. (Opcional) **Tags** (Etiquetas): utilice esta opción para agregar etiquetas al grupo de trabajo. Para obtener más información, consulte [Etiquetado de recursos de Athena](tags.md).
1. Elija **Crear grupo de trabajo**. Un mensaje le informa de que el grupo de trabajo se ha creado correctamente y aparecerá en la lista de grupos de trabajo.
## Paso 2: abrir el explorador de cuadernos y cambiar de grupo de trabajo
Antes de poder usar el grupo de trabajo habilitado para Spark que acaba de crear, debe cambiar de grupo de trabajo. Para cambiar los grupos de trabajo habilitados para Spark, puede usar la opción **Workgroup** (Grupo de trabajo) del explorador o del editor de cuadernos.
**nota**
Antes de empezar, compruebe que el navegador no bloquea las cookies de terceros. Cualquier navegador que bloquee las cookies de terceros, ya sea de manera predeterminada o porque el usuario lo haya configurado así, impedirá que se inicien los cuadernos. Para obtener más información sobre cómo administrar las cookies, consulte:
[Chrome](https://support.alertlogic.com/hc/en-us/articles/360018127132-Turn-Off-Block-Third-Party-Cookies-in-Chrome-for-Windows)
[Firefox](https://support.mozilla.org/en-US/kb/third-party-cookies-firefox-tracking-protection)
[Safari](https://support.apple.com/guide/safari/manage-cookies-sfri11471/mac)
**Para abrir el explorador de cuadernos y cambiar de grupo de trabajo**
1. En el panel de navegación, elija **Notebook explorer** (Explorador de cuadernos).
1. Use la opción **Workgroup** (Grupo de trabajo) de la parte superior derecha de la consola para elegir el grupo de trabajo habilitado para Spark que ha creado. El cuaderno de ejemplo se muestra en la lista de cuadernos.
Puede usar el explorador de cuadernos de las siguientes formas:
+ Elija el nombre vinculado de un cuaderno para abrirlo en una nueva sesión.
+ Para cambiar el nombre del cuaderno, eliminarlo o exportarlo, utilice el menú **Actions** (Acciones).
+ Para importar un archivo de cuaderno, elija **Import file** (Importar archivo).
+ Pare crear un cuaderno, elija **Create notebook** (Crear cuaderno).
## Paso 3: ejecutar el cuaderno de ejemplo
El cuaderno de ejemplo consulta datos de un conjunto de datos de viajes en taxi en la ciudad de Nueva York de acceso público. El cuaderno tiene ejemplos que muestran cómo trabajar con Spark DataFrames, Spark SQL y AWS Glue Data Catalog.
**Para ejecutar el cuaderno de ejemplo**
1. En el explorador de cuadernos, elija el nombre vinculado del cuaderno de ejemplo.
De esta forma, se inicia una sesión de cuaderno con los parámetros predeterminados y se abre el cuaderno en el editor de cuadernos. Un mensaje le informa de que se ha iniciado una nueva sesión de Apache Spark con los parámetros predeterminados (20 DPU como máximo).
1. Para ejecutar las celdas en orden y ver los resultados, pulse el botón **Run** (Ejecutar) una vez para cada celda del cuaderno.
+ Desplácese hacia abajo para ver los resultados así como nuevas celdas.
+ En las celdas que tienen un cálculo, una barra de progreso muestra el porcentaje completado, el tiempo transcurrido y el tiempo restante.
+ El cuaderno de ejemplo crea una base de datos y una tabla de ejemplo en su cuenta. La última celda las elimina como paso de limpieza.
**nota**
Si cambia los nombres de carpetas, tablas o bases de datos en el cuaderno de ejemplo, asegúrese de que esos cambios se reflejen en los roles de IAM que utilice. De lo contrario, es posible que el cuaderno no se ejecute debido a la falta de permisos.
## Paso 4: editar los detalles de la sesión
Tras iniciar una sesión de cuaderno, puede editar los detalles de la sesión, como el formato de la tabla, el cifrado, el tiempo de inactividad de la sesión y el número máximo de unidades de procesamiento de datos (DPU) simultáneas que desea utilizar. Una DPU es una medida relativa de la potencia de procesamiento que consta de 4 vCPU de capacidad de cómputo y 16 GB de memoria.
**Para editar los detalles de la sesión**
1. En el editor de cuadernos, en el menú **Session** (Sesión) de la esquina superior derecha, elija **Edit session** (Editar sesión).
1. En el cuadro de diálogo **Editar detalles de la sesión**, en la sección **Propiedades de Spark**, elija o ingrese valores para las siguientes opciones:
+ **Formato de tabla adicional**: elija **Linux Foundation Delta Lake**, **Apache Hudi**, **Apache Iceberg** o **Personalizada**.
+ Para las opciones de tabla **Delta**, **Hudi** o **Iceberg**, las propiedades de tabla necesarias para el formato de tabla correspondiente se proporcionan automáticamente en las opciones **Editar en tabla** y **Editar en JSON**. Para obtener más información sobre el uso de estos formatos de tabla, consulte [Uso de formatos de tabla que no sean Hive en Athena para Spark](notebooks-spark-table-formats.md).
+ Para agregar o eliminar propiedades de tabla para las tablas **personalizadas** o de otro tipo, utilice las opciones **Editar en tabla** y **Editar en JSON**.
+ Para la opción **Editar en la tabla**, seleccione **Agregar propiedad** si desea agregar una propiedad o **Eliminar** si desea eliminar una propiedad. Utilice los cuadros **Clave** y **Valor** para introducir los nombres de las propiedades y sus valores.
+ Para la opción **Editar en JSON**, utilice el editor de texto JSON a fin de editar la configuración directamente.
+ Seleccione **Copiar** para copiar el texto JSON en el portapapeles.
+ Seleccione **Borrar** para eliminar todo el texto del editor JSON.
+ Elija el icono de ajustes (engranaje) a fin de configurar el ajuste de líneas o seleccionar un tema de color para el editor JSON.
+ **Activar el cifrado de Spark**: seleccione esta opción para cifrar los datos que se escriben en el disco y se envían a través de los nodos de la red de Spark. Para obtener más información, consulte [Habilitación del cifrado de Apache Spark](notebooks-spark-encryption.md).
1. En la sección **Parámetros de la sesión**, elija o ingrese valores para las siguientes opciones:
+ **Session idle timeout** (Tiempo de inactividad de la sesión): elija o ingrese un valor comprendido entre 1 y 480 minutos. El valor predeterminado es 20.
+ **Coordinator size** (Tamaño del coordinador): un *coordinador* es un ejecutor especial que orquesta el trabajo de procesamiento y administra a otros ejecutores en una sesión de cuaderno. Actualmente, 1 DPU es el valor predeterminado y el único posible.
+ **Executor size** (Tamaño del ejecutor): un *ejecutor* es la unidad de cálculo más pequeña que una sesión de cuaderno puede solicitar a Athena. Actualmente, 1 DPU es el valor predeterminado y el único posible.
+ **Max concurrent value** (Valor máximo de simultaneidad): la cantidad máxima de DPU que se pueden ejecutar simultáneamente. El valor predeterminado es 20, el mínimo es 3 y el máximo es 60. Al aumentar este valor no se asignan automáticamente recursos adicionales, pero Athena intentará asignar hasta el máximo especificado cuando la carga de computación lo requiera y haya recursos disponibles.
1. Seleccione **Save**.
1. Cuando aparezca el mensaje **Confirm edit** (Confirmar edición), elija **Confirm** (Confirmar).
Athena guarda el cuaderno e inicia una nueva sesión con los parámetros especificados. Un banner en el editor de cuadernos le informa de que se ha iniciado una nueva sesión con los parámetros modificados.
**nota**
Athena recuerda la configuración de la sesión del cuaderno. Si edita los parámetros de una sesión y, a continuación, la termina, Athena utilizará los parámetros de sesión que configuró la próxima vez que inicie una sesión para el cuaderno.
## Paso 5: ver los detalles de sesión y cálculo
Tras ejecutar el cuaderno, podrá ver los detalles de la sesión y del cálculo.
**Para ver los detalles de sesión y cálculo**
1. En el menú **Session** (Sesión) de la esquina superior derecha, elija **View details** (Ver detalles).
+ La pestaña **Current session** (Sesión actual) muestra información sobre la sesión actual, que incluye el ID de sesión, la hora de creación, el estado y el grupo de trabajo.
+ La pestaña **History** (Historial) muestra los ID de sesiones anteriores. Para ver los detalles de una sesión anterior, elija la pestaña **History** (Historial) y, a continuación, elija un ID de sesión de la lista.
+ La sección **Calculations** (Cálculos) muestra una lista de los cálculos que se ejecutaron en la sesión.
1. Para ver los detalles de un cálculo, elija el ID del cálculo.
1. En la página **Calculation details** (Detalles del cálculo), puede hacer lo siguiente:
+ Para ver el código del cálculo, consulte la sección **Código**.
+ Para ver los resultados del cálculo, seleccione la pestaña **Results** (Resultados).
+ Para descargar los resultados que ve en formato de texto, elija **Download results** (Descargar resultados).
+ Para ver información sobre los resultados del cálculo en Amazon S3, elija **View in S3** (Ver en S3).
## Paso 6: terminar la sesión
**Cómo finalizar la sesión de cuaderno**
1. En el editor de cuadernos, en el menú **Session** (Sesión) de la esquina superior derecha, elija **Terminate** (Terminar).
1. Cuando aparezca el mensaje **Confirm session termination** (Confirmar terminación de sesión), elija **Confirm** (Confirmar). Se guardará el cuaderno y volverá al editor de cuadernos.
**nota**
El cierre de una pestaña de un cuaderno en el editor de cuadernos no termina por sí solo la sesión de un cuaderno activo. Si quiere asegurarse de que la sesión ha terminado, utilice la opción **Session** (Sesión), **Terminate** (Terminar).
## Paso 7: crear su propio cuaderno
Tras crear un grupo de trabajo de Athena habilitado para Spark, podrá crear un cuaderno propio.
**Para crear un cuaderno**
1. Si el panel de navegación de la consola no está visible, elija el menú de expansión de la izquierda.
1. En el panel de navegación de la consola de Athena, elija **Notebook explorer** (Explorador de cuadernos) o **Notebook editor** (Editor de cuadernos).
1. Realice una de las siguientes acciones:
+ En **Notebook explorer** (Explorador de cuadernos), elija **Create notebook** (Crear cuaderno).
+ En **Notebook editor** (Editor de cuadernos), elija **Create notebook** (Crear cuaderno) o elija el icono con el signo más (**\$1**) para agregar un cuaderno.
1. En el cuadro de diálogo **Create notebook** (Crear cuaderno), ingrese un nombre en **Notebook name** (Nombre del cuaderno).
1. (Opcional) Amplíe **Propiedades de Spark** y, a continuación, elija o ingrese valores para las siguientes opciones:
+ **Formato de tabla adicional**: elija **Linux Foundation Delta Lake**, **Apache Hudi**, **Apache Iceberg** o **Personalizada**.
+ Para las opciones de tabla **Delta**, **Hudi** o **Iceberg**, las propiedades de tabla necesarias para el formato de tabla correspondiente se proporcionan automáticamente en las opciones **Editar en tabla** y **Editar en JSON**. Para obtener más información sobre el uso de estos formatos de tabla, consulte [Uso de formatos de tabla que no sean Hive en Athena para Spark](notebooks-spark-table-formats.md).
+ Para agregar o eliminar propiedades de tabla para las tablas **personalizadas** o de otro tipo, utilice las opciones **Editar en tabla** y **Editar en JSON**.
+ Para la opción **Editar en la tabla**, seleccione **Agregar propiedad** si desea agregar una propiedad o **Eliminar** si desea eliminar una propiedad. Utilice los cuadros **Clave** y **Valor** para introducir los nombres de las propiedades y sus valores.
+ Para la opción **Editar en JSON**, utilice el editor de texto JSON a fin de editar la configuración directamente.
+ Seleccione **Copiar** para copiar el texto JSON en el portapapeles.
+ Seleccione **Borrar** para eliminar todo el texto del editor JSON.
+ Elija el icono de ajustes (engranaje) a fin de configurar el ajuste de líneas o seleccionar un tema de color para el editor JSON.
+ **Activar el cifrado de Spark**: seleccione esta opción para cifrar los datos que se escriben en el disco y se envían a través de los nodos de la red de Spark. Para obtener más información, consulte [Habilitación del cifrado de Apache Spark](notebooks-spark-encryption.md).
1. (Opcional) Expanda **Session parameters** (Parámetros de sesión) y, a continuación, elija o ingrese valores para las siguientes opciones:
+ **Session idle timeout** (Tiempo de inactividad de la sesión): elija o ingrese un valor comprendido entre 1 y 480 minutos. El valor predeterminado es 20.
+ **Coordinator size** (Tamaño del coordinador): un *coordinador* es un ejecutor especial que orquesta el trabajo de procesamiento y administra a otros ejecutores en una sesión de cuaderno. Actualmente, 1 DPU es el valor predeterminado y el único posible. Una DPU (unidad de procesamiento de datos) es una medida relativa de la potencia de procesamiento que consta de 4 vCPU de capacidad de computación y 16 GB de memoria.
+ **Executor size** (Tamaño del ejecutor): un *ejecutor* es la unidad de cálculo más pequeña que una sesión de cuaderno puede solicitar a Athena. Actualmente, 1 DPU es el valor predeterminado y el único posible.
+ **Max concurrent value** (Valor máximo de simultaneidad): la cantidad máxima de DPU que se pueden ejecutar simultáneamente. El valor predeterminado es 20 y el máximo es 60. Al aumentar este valor no se asignan automáticamente recursos adicionales, pero Athena intentará asignar hasta el máximo especificado cuando la carga de computación lo requiera y haya recursos disponibles.
1. Seleccione **Crear**. El cuaderno se abre en una nueva sesión en el editor de cuadernos.
Para obtener información sobre la administración de sus archivos de cuaderno, consulte [Administración de los archivos de cuaderno](notebooks-spark-managing.md).
# Administración de los archivos de cuaderno
**nota**
El editor de cuadernos de Athena es compatible con la versión 3 del motor de Pyspark. Para usar cuadernos con la versión 3.5 de Apache Spark, consulte [Cuadernos de SageMaker](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html).
Además de utilizar el explorador de cuadernos para [crear](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) cuadernos, también puede usarlo para abrir, renombrar, eliminar, exportar o importar cuadernos, o ver el historial de sesiones de un cuaderno.
**: apertura de un cuaderno previamente creado**
1. Si el panel de navegación de la consola no está visible, elija el menú de expansión de la izquierda.
1. En el panel de navegación de la consola de Athena, elija **Notebook editor** (Editor de cuadernos) o **Notebook explorer** (Explorador de cuadernos).
1. Realice una de las siguientes acciones:
+ En **Notebook editor** (Editor de cuadernos), elija un cuaderno de la lista **Recent notebooks** (Cuadernos recientes) o **Saved notebooks** (Cuadernos guardados). El cuaderno se abre en una nueva sesión.
+ En **Notebook explorer** (Explorador de cuadernos), elija el nombre de un cuaderno de la lista. El cuaderno se abre en una nueva sesión.
**Para cambiar el nombre de un cuaderno**
1. [Finalice](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) las sesiones activas del cuaderno cuyo nombre desee cambiar. Las sesiones activas del cuaderno deben finalizarse para poder cambiarle el nombre.
1. Abra el **explorador de cuadernos**.
1. En la lista **Notebooks** (Cuadernos), seleccione el botón de opción del cuaderno al que desee cambiar el nombre.
1. En el menú **Actions** (Acciones), elija **Rename** (Cambiar el nombre).
1. En la línea de comandos **Rename notebook** (Cambiar el nombre del cuaderno), introduzca el nuevo nombre y, a continuación, seleccione **Save** (Guardar). El nuevo nombre del cuaderno aparece en la lista de cuadernos.
**Para eliminar un cuaderno**
1. [Finalice](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) todas las sesiones activas del cuaderno que desee eliminar. Las sesiones activas del cuaderno deben finalizarse antes de poder eliminarlo.
1. Abra el **explorador de cuadernos**.
1. En la lista **Notebooks** (Cuadernos), seleccione el botón de opción del cuaderno que desee eliminar.
1. En el menú **Actions (Acciones)**, elija **Delete (Eliminar)**.
1. En la pregunta **Delete notebook?** (¿Eliminar cuaderno?), introduzca el nombre del cuaderno y, a continuación, elija **Delete** (Eliminar) para confirmar la eliminación. El nombre del cuaderno se elimina de la lista de cuadernos.
**Para exportar un cuaderno**
1. Abra el **explorador de cuadernos**.
1. En la lista **Notebooks** (Cuadernos), seleccione el botón de opción del cuaderno que desee exportar.
1. En el menú **Actions** (Acciones), elija **Export file** (Exportar archivo).
**Para importar un cuaderno**
1. Abra el **explorador de cuadernos**.
1. Seleccione **Import File** (Importar archivo).
1. Busque la ubicación del archivo que desee importar en su equipo local y, a continuación, seleccione **Open** (Abrir). El cuaderno importado aparece en la lista de cuadernos.
**Para ver el historial de sesiones de un cuaderno**
1. Abra el **explorador de cuadernos**.
1. En la lista **Notebooks** (Cuadernos), seleccione el botón de opción del cuaderno cuyo historial de sesiones desee ver.
1. En el menú **Actions** (Acciones), seleccione **Session history** (Historial de sesiones).
1. En la pestaña **History** (Historial), elija un **ID de sesión** para ver información sobre la sesión y sus cálculos.
# Uso del editor de cuadernos de Athena
**nota**
El editor de cuadernos de Athena es compatible con la versión 3 del motor de Pyspark. Para usar cuadernos con la versión 3.5 de Apache Spark, consulte [Cuadernos de SageMaker](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/what-is-sagemaker-unified-studio.html).
Administre sus cuadernos en el explorador de cuadernos de Athena y edítelos y ejecútelos en sesiones con el editor de cuadernos de Athena. Puede configurar el uso de la DPU para las sesiones de su cuaderno según sus necesidades.
Al detener un cuaderno, se termina la sesión asociada. Se guardan todos los archivos, pero se pierden los cambios en curso en las variables, funciones y clases declaradas. Al reiniciar el cuaderno, Athena vuelve a cargar los archivos del cuaderno y puede volver a ejecutar el código.
El editor de cuadernos de Athena es un entorno interactivo para escribir y ejecutar código. En las siguientes secciones, se describen las características del entorno.
## Comprensión de las sesiones de cuadernos y los cálculos
Cada cuaderno está asociado a un único núcleo de Python y ejecuta código Python. Un cuaderno puede tener una o más celdas que contengan comandos. Para ejecutar las celdas de un cuaderno, primero debe crear una sesión para el cuaderno. Las sesiones realizan un seguimiento de las variables y el estado de los cuadernos.
Ejecutar una celda en un cuaderno significa ejecutar un cálculo en la sesión actual. Los cálculos hacen avanzar el estado del cuaderno y pueden realizar tareas como leer desde Amazon S3 o escribir en otros almacenes de datos. Mientras se esté ejecutando una sesión, los cálculos utilizan y modifican el estado que se mantiene en el cuaderno.
Cuando ya no necesite el estado, puede finalizar una sesión. Al finalizar una sesión, el cuaderno permanece, pero las variables y el resto de información de estado se destruyen. Si necesita trabajar en varios proyectos al mismo tiempo, puede crear una sesión para cada proyecto y las sesiones serán independientes entre sí.
Las sesiones tienen una capacidad de cálculo dedicada, medida en DPU. Cuando crea una sesión, puede asignar a la sesión una cantidad de DPU. Las diferentes sesiones pueden tener diferentes capacidades según los requisitos de la tarea.
## Cambio entre el modo de comando y el modo de edición
El editor de cuadernos tiene una interfaz de usuario modal: un modo de edición para ingresar texto en una celda y un modo de comandos para enviar comandos al propio editor, como copiar, pegar o ejecutar.
Para utilizar el modo de edición y el modo de comandos, puede realizar las siguientes tareas:
+ Para ingresar al modo de edición, pulse **ENTER** o elija una celda. Cuando una celda está en modo de edición, su margen izquierdo está en verde.
+ Para entrar en el modo de comandos, pulse **ESC** o haga clic fuera de una celda. Tenga en cuenta que, normalmente, los comandos solo se aplican a la celda seleccionada actualmente, no a todas las celdas. Cuando el editor está en modo de comandos, el margen izquierdo de la celda está en azul.
+ En el modo de comandos, puede utilizar los atajos de teclado y el menú situado encima del editor, pero no puede ingresar texto en celdas individuales.
+ Para seleccionar una celda, elíjala.
+ Para seleccionar todas las celdas, pulse **Ctrl\$1A** (Windows) o **Cmd\$1A** (Mac).
## Uso de las acciones del menú del editor del cuaderno
Los iconos del menú situados en la parte superior del editor de cuadernos ofrecen las siguientes opciones:
+ **Save** (Guardar): guarda el estado actual del cuaderno.
+ **Insert cell below** (Insertar celda debajo): agrega una celda nueva (vacía) debajo de la seleccionada actualmente.
+ **Cut selected cells** (Suprimir celdas seleccionadas): elimina la celda seleccionada de su ubicación actual y la copia en la memoria.
+ **Copy selected cells** (Copiar celdas seleccionadas): copia la celda seleccionada en la memoria.
+ **Paste cells below** (Pegar celdas debajo): pega la celda copiada debajo de la celda actual.
+ **Move selected cells up** (Mover celdas seleccionadas hacia arriba): sitúa la celda actual encima de la celda superior.
+ **Move selected cells down** (Mover celdas seleccionadas hacia abajo): sitúa la celda actual debajo de la celda inferior.
+ **Run** (Ejecutar): ejecuta la celda actual (seleccionada). El resultado se muestra justo debajo de la celda actual.
+ **Run all** (Ejecutar todo): ejecuta todas las celdas del cuaderno. El resultado de cada celda se muestra justo debajo de la celda.
+ **Stop (Interrupt the kernel)** (Detener [interrumpir el kernel]): interrumpe el kernel para detener el cuaderno actual.
+ **Format option** (Opción de formato): selecciona el formato de celda, que puede ser uno de los siguientes:
+ **Code**: se usa para código Python (predeterminado).
+ **Markdown**: se usa para ingresar texto en formato [Markdown al estilo de GitHub](https://docs.github.com/en/get-started/writing-on-github). Para renderizar el Markdown, ejecute la celda.
+ **Raw NBConvert**: se usa para ingresar texto en forma no modificada. Las celdas marcadas como **Raw NBConvert** se pueden convertir a un formato diferente, como HTML, mediante la herramienta de línea de comandos [nbconvert](https://nbconvert.readthedocs.io/en/latest/usage.html) de Jupyter.
+ **Heading** (Encabezado): se usa para cambiar el nivel del encabezado de la celda.
+ **Command palette** (Paleta de comandos): contiene los comandos del cuaderno de Jupyter y sus atajos de teclado. Para obtener más información acerca de los atajos de teclado, consulte las secciones que aparecen más adelante en este documento.
+ **Session** (Sesión): utilice las opciones de este menú para [ver](notebooks-spark-getting-started.md#notebooks-spark-getting-started-viewing-session-and-calculation-details) los detalles de una sesión, [editar los parámetros de la sesión](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) o [terminar](notebooks-spark-getting-started.md#notebooks-spark-getting-started-terminating-a-session) la sesión.
## Uso de atajos de teclado en modo de comando para aumentar la productividad
A continuación, se presentan algunos atajos de teclado habituales de un editor de cuadernos en el modo de comandos. Estos atajos están disponibles después de pulsar **ESC** para ingresar al modo de comandos. Para ver una lista completa de los comandos disponibles en el editor, pulse **ESC \$1 H**.
****
| Key | Action |
| --- | --- |
| 1 - 6 | Cambiar el tipo de celda a Markdown y establecer el nivel del encabezado en el número escrito |
| a | Crear una celda encima de la celda actual |
| b | Crear una celda debajo de la celda actual |
| c | Copiar la celda actual en memoria |
| d d | Eliminar la celda actual |
| h | Mostrar la pantalla de ayuda de los atajos de teclado |
| j | Ir una celda más abajo |
| k | Ir una celda más arriba |
| m | Cambiar el formato de celda actual a Markdown |
| r | Cambiar el formato de celda actual a Raw |
| s | Guardar el cuaderno |
| v | Pegar el contenido de la memoria en la celda actual |
| x | Cortar la celda o las celdas seleccionadas |
| y | Cambiar el formato de celda a Code |
| z | Deshacer |
| Ctrl\$1Enter | Ejecutar la celda actual e ingresar al modo de comandos |
| Shift\$1Enter o Alt\$1Enter | Ejecutar la celda actual, crear una nueva debajo de la salida y hacer que ingrese al modo de edición |
| Space | Página siguiente |
| Shift\$1Space | Página anterior |
| Shift \$1 L | Para alternar la visibilidad de los números de línea en las celdas |
## Personalización de los atajos del modo de comandos
El editor de cuadernos tiene una opción para personalizar los atajos de teclado del modo de comandos.
**Para editar los atajos del modo de comandos**
1. En el menú del editor de cuadernos, elija **Command palette** (Paleta de comandos).
1. En la paleta de comandos, elija el comando **Edit command mode keyboard shortcuts** (Editar atajos de teclado del modo de comandos).
1. Utilice la interfaz **Edit command mode shortcuts** (Editar atajos del modo de comandos) para asignar o reasignar los comandos que desee al teclado.
Para ver las instrucciones sobre cómo editar los atajos del modo de comandos, desplácese hasta la parte inferior de la pantalla **Edit command mode shortcuts** (Editar atajos del modo de comandos).
Para obtener información sobre el uso de comandos mágicos en Athena para Apache Spark, consulte [Uso de comandos mágicos](notebooks-spark-magics.md).
**Topics**
+ [Comprensión de las sesiones de cuadernos y los cálculos](#notebooks-spark-sessions-and-calculations)
+ [Cambio entre el modo de comando y el modo de edición](#notebooks-spark-command-mode-vs-edit-mode)
+ [Uso de las acciones del menú del editor del cuaderno](#notebooks-spark-notebook-editor-menu)
+ [Uso de atajos de teclado en modo de comando para aumentar la productividad](#notebooks-spark-command-mode-keyboard-shortcuts)
+ [Personalización de los atajos del modo de comandos](#notebooks-spark-editing-command-mode-shortcuts)
+ [Uso de comandos mágicos](notebooks-spark-magics.md)
# Uso de comandos mágicos
Los comandos mágicos, o magics, son comandos especiales que puede ejecutar en una celda de un cuaderno. Por ejemplo, `%env` muestra las variables de entorno de una sesión de cuaderno. Athena admite las funciones mágicas de iPython 6.0.3.
En esta sección se muestran algunos comandos mágicos de Athena para Apache Spark.
+ Para ver una lista de estos comandos mágicos en Athena, ejecute el comando **%lsmagic** en una celda de un cuaderno.
+ Para obtener información sobre el uso de los comandos mágicos para crear gráficos en los cuadernos de Athena, consulte [Uso de comandos mágicos para crear gráficos de datos](notebooks-spark-magics-graphs.md).
+ Para obtener información sobre comandos mágicos adicionales, consulte [Comandos mágicos integrados](https://ipython.readthedocs.io/en/stable/interactive/magics.html) en la documentación de IPython.
**nota**
Actualmente, el comando `%pip` genera un error cuando se ejecuta. Se trata de un problema conocido.
**Topics**
+ [Comandos mágicos de celda](notebooks-spark-magics-cell-magics.md)
+ [Comandos mágicos de línea](notebooks-spark-magics-line-magics.md)
+ [Comandos mágicos de gráficos](notebooks-spark-magics-graphs.md)
# Uso de comandos mágicos de celda
Los magics que se escriben en varias líneas van precedidos de un signo de doble porcentaje (`%%`) y se denominan funciones mágicas de celda o magics de celda.
## %%sql
Este comando mágico de celda permite ejecutar instrucciones SQL directamente sin tener que decorarla con la instrucción SQL de Spark. El comando también muestra el resultado al invocar `.show()` implícitamente en el marco de datos devuelto.
![\[Uso de %%sql.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-1.png)
El comando `%%sql` trunca automáticamente las salidas de las columnas a un ancho de 20 caracteres. Esto no se puede configurar actualmente. Para evitar esta limitación, utilice la siguiente sintaxis completa y modifique los parámetros del método `show` según corresponda.
```
spark.sql("""YOUR_SQL""").show(n=number, truncate=number, vertical=bool)
```
+ **n**`int`, opcional. El número de filas que se mostrarán.
+ **truncate** – `bool` o `int`, opcional: si es `true`, trunca las cadenas de más de 20 caracteres. Si se establece en un número mayor que 1, trunca las cadenas largas hasta la longitud especificada y alinea las celdas a la derecha.
+ **vertical** – `bool`, opcional. Si es `true`, imprime las filas de salida de forma vertical (una línea por valor de columna).
# Uso de comandos mágicos de línea
Los magics que se encuentran en una sola línea van precedidos de un signo de porcentaje (`%`) y se denominan funciones mágicas de línea o magics de línea.
## %help
Muestra descripciones de los comandos mágicos disponibles.
![\[Uso de %help.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-2.png)
## %list\$1sessions
Muestra las sesiones asociadas al cuaderno. La información de cada sesión incluye el ID de la sesión, el estado de la sesión y la fecha y la hora de inicio y finalización de la sesión.
![\[Uso de %list_sessions.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-3.png)
## %session\$1id
Recupera el ID de la sesión actual.
![\[Uso de session_id.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-4.png)
## %set\$1log\$1level
Establece o restablece el registrador para utilizar el nivel de registro especificado. Los valores posibles son `DEBUG`, `ERROR`, `FATAL`, `INFO` y `WARN` o `WARNING`. Los valores deben estar en mayúsculas y no entre comillas simples o dobles.
![\[Uso de %set_log_level.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-5.png)
## %status
Describe la sesión actual. El resultado incluye el ID de la sesión, el estado de la sesión, el nombre del grupo de trabajo, la versión del motor de PySpark y la hora de inicio de la sesión. Este comando mágico requiere una sesión activa para recuperar los detalles de la sesión.
Estos son los posibles valores de estado:
**CREANDO**: se está iniciando la sesión, incluida la adquisición de recursos.
**CREADA**: se ha iniciado la sesión.
**INACTIVA**: la sesión puede aceptar un cálculo.
**OCUPADA**: la sesión está procesando otra tarea y no puede aceptar un cálculo.
**FINALIZANDO**: se está cerrando la sesión.
**FINALIZADA**: la sesión y sus recursos ya no se están ejecutando.
**DEGRADADA**: la sesión no tiene coordinadores en buen estado.
**ERROR**: debido a un error, la sesión y sus recursos ya no se están ejecutando.
![\[Uso de %status.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-6.png)
# Uso de comandos mágicos para crear gráficos de datos
Los comandos mágicos de línea de esta sección se especializan en representar datos para determinados tipos de datos o en combinación con bibliotecas de gráficos.
## %table
Puede usar el comando mágico `%table` para mostrar los datos del marco de datos en formato de tabla.
En el siguiente ejemplo, se crea un marco de datos con dos columnas y tres filas de datos y, a continuación, se muestran los datos en formato de tabla.
![\[Uso del comando mágico %table.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-graphs-1.png)
## %matplot
[Matplotlib](https://matplotlib.org/) es una biblioteca integral para crear visualizaciones estáticas, animadas e interactivas en Python. Puede usar el comando mágico `%matplot` para crear un gráfico después de importar la biblioteca matplotlib a una celda de un cuaderno.
En el siguiente ejemplo, se importa la biblioteca matplotlib, se crea un conjunto de coordenadas “x” e “y”, y luego se utiliza el comando mágico `%matplot` para crear un gráfico de los puntos.
```
import matplotlib.pyplot as plt
x=[3,4,5,6,7,8,9,10,11,12]
y= [9,16,25,36,49,64,81,100,121,144]
plt.plot(x,y)
%matplot plt
```
![\[Uso del comando mágico %matplot.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-graphs-2.png)
### Uso conjunto de las bibliotecas matplotlib y seaborn
[Seaborn](https://seaborn.pydata.org/tutorial/introduction) es una biblioteca para hacer gráficos estadísticos en Python. Se basa en matplotlib y se integra perfectamente con las estructuras de datos de [pandas](https://pandas.pydata.org/) (análisis de datos de Python). También se puede usar el comando mágico `%matplot` para representar los datos de seaborn.
En el siguiente ejemplo, se utilizan las bibliotecas matplotlib y seaborn para crear un gráfico de barras sencillo.
```
import matplotlib.pyplot as plt
import seaborn as sns
x = ['A', 'B', 'C']
y = [1, 5, 3]
sns.barplot(x, y)
%matplot plt
```
![\[Uso de %matplot para representar los datos de seaborn.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-graphs-3.png)
## %plotly
[Plotly](https://plotly.com/python/) es una biblioteca de gráficos de código abierto para Python que se puede usar para crear gráficos interactivos. El comando mágico `%ploty` se utiliza para representar datos de plotly.
En el siguiente ejemplo, se utilizan las bibliotecas [StringIO](https://docs.python.org/3.13/library/io.html#io.StringIO), plotly y pandas con los datos de precios de las acciones para crear un gráfico de la actividad bursátil de febrero y marzo de 2015.
```
from io import StringIO
csvString = """
Date,AAPL.Open,AAPL.High,AAPL.Low,AAPL.Close,AAPL.Volume,AAPL.Adjusted,dn,mavg,up,direction
2015-02-17,127.489998,128.880005,126.919998,127.830002,63152400,122.905254,106.7410523,117.9276669,129.1142814,Increasing
2015-02-18,127.629997,128.779999,127.449997,128.720001,44891700,123.760965,107.842423,118.9403335,130.0382439,Increasing
2015-02-19,128.479996,129.029999,128.330002,128.449997,37362400,123.501363,108.8942449,119.8891668,130.8840887,Decreasing
2015-02-20,128.619995,129.5,128.050003,129.5,48948400,124.510914,109.7854494,120.7635001,131.7415509,Increasing
2015-02-23,130.020004,133,129.660004,133,70974100,127.876074,110.3725162,121.7201668,133.0678174,Increasing
2015-02-24,132.940002,133.600006,131.169998,132.169998,69228100,127.078049,111.0948689,122.6648335,134.2347981,Decreasing
2015-02-25,131.559998,131.600006,128.149994,128.789993,74711700,123.828261,113.2119183,123.6296667,134.0474151,Decreasing
2015-02-26,128.789993,130.869995,126.610001,130.419998,91287500,125.395469,114.1652991,124.2823333,134.3993674,Increasing
2015-02-27,130,130.570007,128.240005,128.460007,62014800,123.510987,114.9668484,124.8426669,134.7184854,Decreasing
2015-03-02,129.25,130.279999,128.300003,129.089996,48096700,124.116706,115.8770904,125.4036668,134.9302432,Decreasing
2015-03-03,128.960007,129.520004,128.089996,129.360001,37816300,124.376308,116.9535132,125.9551669,134.9568205,Increasing
2015-03-04,129.100006,129.559998,128.320007,128.539993,31666300,123.587892,118.0874253,126.4730002,134.8585751,Decreasing
2015-03-05,128.580002,128.75,125.760002,126.410004,56517100,121.539962,119.1048311,126.848667,134.5925029,Decreasing
2015-03-06,128.399994,129.369995,126.260002,126.599998,72842100,121.722637,120.190797,127.2288335,134.26687,Decreasing
2015-03-09,127.959999,129.570007,125.059998,127.139999,88528500,122.241834,121.6289771,127.631167,133.6333568,Decreasing
2015-03-10,126.410004,127.220001,123.800003,124.510002,68856600,119.71316,123.1164763,127.9235004,132.7305246,Decreasing
"""
csvStringIO = StringIO(csvString)
from io import StringIO
import plotly.graph_objects as go
import pandas as pd
from datetime import datetime
df = pd.read_csv(csvStringIO)
fig = go.Figure(data=[go.Candlestick(x=df['Date'],
open=df['AAPL.Open'],
high=df['AAPL.High'],
low=df['AAPL.Low'],
close=df['AAPL.Close'])])
%plotly fig
```
![\[Uso del comando mágico %ploty.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-magics-graphs-4.png)
# Uso de formatos de tabla que no sean Hive en Athena para Spark
**nota**
Esta página hace referencia al uso de las bibliotecas de Python en la versión de lanzamiento del motor de Pyspark, versión 3. Consulte [Amazon EMR 7.12](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html) para conocer las versiones de formato de tabla abierta compatibles.
Cuando trabaja con sesiones y cuadernos en Athena para Spark, puede usar las tablas de Linux Foundation Delta Lake, Apache Hudi y Apache Iceberg, además de las tablas de Apache Hive.
## Consideraciones y limitaciones
Cuando utilice formatos de tabla que no sean de Apache Hive con Athena para Spark, tenga en cuenta los siguientes puntos:
+ Además de Apache Hive, solo se admite un formato de tabla por cuaderno. Si desea usar varios formatos de tabla en Athena para Spark, cree un cuaderno independiente para cada formato de tabla. Para obtener información sobre la creación de cuadernos en Athena para Spark, consulte [Paso 7: crear su propio cuaderno](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
+ Los formatos de tabla de Delta Lake, Hudi e Iceberg se probaron en Athena para Spark utilizando AWS Glue como almacén de metadatos. Es posible que pueda usar otros almacenes de metadatos, pero actualmente no se admite ese uso.
+ Para usar los formatos de tabla adicionales, anule la propiedad `spark_catalog`predeterminada, tal y como se indica en la consola de Athena y en esta documentación. Estos catálogos que no son de Hive pueden leer tablas de Hive, además de sus propios formatos de tabla.
## Versiones de tablas
En la siguiente tabla, se muestran las versiones de tablas que no son de Hive y que se admiten en Amazon Athena para Apache Spark.
****
| Formato de tabla | Versión compatible |
| --- | --- |
| Apache Iceberg | 1.2.1 |
| Apache Hudi | 0.13 |
| Linux Foundation Delta Lake | 2.0.2 |
En Athena para Spark, estos archivos `.jar` con formato de tabla y sus dependencias se cargan en la ruta de clases de los controladores y ejecutores de Spark.
Para consultar una *AWSpublicación en el blog de Big Data* que indica cómo trabajar con los formatos de tabla Iceberg, Hudi y Delta Lake mediante Spark SQL en blocs de notas de Amazon Athena, consulte [Utilizar Amazon Athena con Spark SQL para los formatos de tabla transaccionales de código abierto](https://aws.amazon.com/blogs/big-data/use-amazon-athena-with-spark-sql-for-your-open-source-transactional-table-formats/).
**Topics**
+ [Consideraciones y limitaciones](#notebooks-spark-table-formats-considerations-and-limitations)
+ [Versiones de tablas](#notebooks-spark-table-formats-versions)
+ [Iceberg](notebooks-spark-table-formats-apache-iceberg.md)
+ [Hudi](notebooks-spark-table-formats-apache-hudi.md)
+ [Delta Lake](notebooks-spark-table-formats-linux-foundation-delta-lake.md)
# Uso de tablas de Apache Iceberg en Athena para Spark
[Apache Iceberg](https://iceberg.apache.org/) es un formato de tabla de código abierto para conjuntos de datos de gran tamaño en Amazon Simple Storage Service (Amazon S3). Ofrece un rendimiento rápido de consultas en tablas grandes, confirmaciones atómicas, escrituras simultáneas y una evolución de tablas compatible con SQL.
Para usar las tablas de Apache Iceberg en Athena para Spark, configure las siguientes propiedades de Spark. Estas propiedades se configuran de forma predeterminada en la consola Athena para Spark cuando elige Apache Iceberg como formato de tabla. Para ver los pasos, consulte [Paso 4: editar los detalles de la sesión](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) o [Paso 7: crear su propio cuaderno](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
```
"spark.sql.catalog.spark_catalog": "org.apache.iceberg.spark.SparkSessionCatalog",
"spark.sql.catalog.spark_catalog.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.sql.catalog.spark_catalog.io-impl": "org.apache.iceberg.aws.s3.S3FileIO",
"spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions"
```
En el siguiente procedimiento, se muestra cómo utilizar una tabla de Apache Iceberg en un cuaderno Athena para Spark. Ejecute cada paso en una nueva celda del cuaderno.
**Para usar una tabla de Apache Iceberg en Athena para Spark**
1. Defina las constantes que se utilizarán en el cuaderno.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Cree un [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html) de Apache Spark.
```
columns = ["language","users_count"]
data = [("Golang", 3000)]
df = spark.createDataFrame(data, columns)
```
1. Cree una base de datos.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Cree una tabla de Apache Iceberg vacía.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING ICEBERG
""".format(DB_NAME, TABLE_NAME))
```
1. Inserte una fila de datos en la tabla.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME, TABLE_NAME))
```
1. Confirme que puede consultar la nueva tabla.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
Para obtener más información y ejemplos sobre cómo trabajar con DataFrames de Spark y tablas de Iceberg, vea [Consultas de Spark](https://iceberg.apache.org/docs/latest/spark-queries/) en la documentación de Apache Iceberg.
# Uso de tablas de Apache Hudi en Athena para Spark
[https://hudi.apache.org/](https://hudi.apache.org/) es un marco de administración de datos de código abierto que simplifica el procesamiento incremental de datos. Las acciones de inserción, actualización, modificación y eliminación a nivel de registro se procesan con mayor precisión, lo que reduce la sobrecarga.
Para usar las tablas de Apache Hudi en Athena para Spark, configure las siguientes propiedades de Spark. Estas propiedades se configuran de forma predeterminada en la consola Athena para Spark cuando elige Apache Hudi como formato de tabla. Para ver los pasos, consulte [Paso 4: editar los detalles de la sesión](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) o [Paso 7: crear su propio cuaderno](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
```
"spark.sql.catalog.spark_catalog": "org.apache.spark.sql.hudi.catalog.HoodieCatalog",
"spark.serializer": "org.apache.spark.serializer.KryoSerializer",
"spark.sql.extensions": "org.apache.spark.sql.hudi.HoodieSparkSessionExtension"
```
En el siguiente procedimiento, se muestra cómo utilizar una tabla de Apache Hudi en un cuaderno de Athena para Spark. Ejecute cada paso en una nueva celda del cuaderno.
**Para usar una tabla de Apache Hudi en Athena para Spark**
1. Defina las constantes que se utilizarán en el cuaderno.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Cree un [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html) de Apache Spark.
```
columns = ["language","users_count"]
data = [("Golang", 3000)]
df = spark.createDataFrame(data, columns)
```
1. Cree una base de datos.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Cree una tabla de Apache Hudi vacía.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING HUDI
TBLPROPERTIES (
primaryKey = 'language',
type = 'mor'
);
""".format(DB_NAME, TABLE_NAME))
```
1. Inserte una fila de datos en la tabla.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME,TABLE_NAME))
```
1. Confirme que puede consultar la nueva tabla.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
# Uso de las tablas de Delta Lake de Linux Foundation en Athena para Spark
[Linux Foundation Delta Lake](https://delta.io/) es un formato de tabla que se puede utilizar para el análisis de macrodatos. Puede usar Athena para Spark para leer las tablas de Delta Lake almacenadas en Amazon S3.
Para usar las tablas de Delta Lake en Athena para Spark, configure las siguientes propiedades de Spark. Estas propiedades se configuran de forma predeterminada en la consola Athena para Spark cuando elige Delta Lake como formato de tabla. Para ver los pasos, consulte [Paso 4: editar los detalles de la sesión](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details) o [Paso 7: crear su propio cuaderno](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook).
```
"spark.sql.catalog.spark_catalog" : "org.apache.spark.sql.delta.catalog.DeltaCatalog",
"spark.sql.extensions" : "io.delta.sql.DeltaSparkSessionExtension"
```
En el siguiente procedimiento, se muestra cómo utilizar una tabla de Delta Lake en un cuaderno de Athena para Spark. Ejecute cada paso en una nueva celda del cuaderno.
**Para usar una tabla de Delta Lake en Athena para Spark**
1. Defina las constantes que se utilizarán en el cuaderno.
```
DB_NAME = "NEW_DB_NAME"
TABLE_NAME = "NEW_TABLE_NAME"
TABLE_S3_LOCATION = "s3://amzn-s3-demo-bucket"
```
1. Cree un [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html) de Apache Spark.
```
columns = ["language","users_count"]
data = [("Golang", 3000)]
df = spark.createDataFrame(data, columns)
```
1. Cree una base de datos.
```
spark.sql("CREATE DATABASE {} LOCATION '{}'".format(DB_NAME, TABLE_S3_LOCATION))
```
1. Cree una tabla de Delta Lake vacía.
```
spark.sql("""
CREATE TABLE {}.{} (
language string,
users_count int
) USING DELTA
""".format(DB_NAME, TABLE_NAME))
```
1. Inserte una fila de datos en la tabla.
```
spark.sql("""INSERT INTO {}.{} VALUES ('Golang', 3000)""".format(DB_NAME, TABLE_NAME))
```
1. Confirme que puede consultar la nueva tabla.
```
spark.sql("SELECT * FROM {}.{}".format(DB_NAME, TABLE_NAME)).show()
```
# Uso de bibliotecas de Python en Athena para Spark
**nota**
Esta página hace referencia al uso de las bibliotecas de Python en la versión de lanzamiento del motor de Pyspark, versión 3. La versión de lanzamiento de Apache Spark 3.5 se basa en [Amazon EMR 7.12](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-7120-release.html). Consulte EMR 7.12 para ver las bibliotecas incluidas en esta versión.
En esta página, se describe la terminología utilizada y la administración del ciclo de vida de los tiempos de ejecución, las bibliotecas y los paquetes que se utilizan en Amazon Athena para Apache Spark.
## Definiciones
+ **Amazon Athena para Apache Spark** es una versión personalizada de Apache Spark de código abierto. Para ver la versión actual, ejecute el comando `print(f'{spark.version}')` en una celda de un cuaderno.
+ El **tiempo de ejecución de Athena** es el entorno en el que se ejecuta su código. El entorno incluye un intérprete de Python y bibliotecas de PySpark.
+ Una **biblioteca o paquete externo** es una biblioteca JAR o Python de Java o Scala que no forma parte del tiempo de ejecución de Athena, pero que se puede incluir en los trabajos de Athena para Spark. Tanto usted como Amazon pueden crear los paquetes externos.
+ Un **paquete de conveniencia** es un conjunto de paquetes externos seleccionados por Athena que puede elegir incluir en sus aplicaciones de Spark.
+ Una **agrupación** combina el tiempo de ejecución de Athena y un paquete de conveniencia.
+ Una **biblioteca de usuario** es una biblioteca o paquete externo que agrega explícitamente a su trabajo de Athena para Spark.
+ Una biblioteca de usuario es un paquete externo que no forma parte de un paquete de conveniencia. Es necesario cargar e instalar una biblioteca de usuario, como cuando escribe algunos archivos `.py`, los comprime y, a continuación, agrega los archivos `.zip` a la aplicación.
+ Una **aplicación de Athena para Spark** es un trabajo o una consulta que se envía a Athena para Spark.
## Administración del ciclo de vida
En las siguientes secciones, se describen las políticas de control de versiones y obsolescencia relacionadas con los paquetes de tiempo de ejecución y comodidad utilizados en Athena para Spark.
### Control de versiones y obsolescencia del tiempo de ejecución
El componente principal del tiempo de ejecución de Athena es el intérprete de Python. Dado que Python es un lenguaje en evolución, se lanzan nuevas versiones con regularidad y se elimina el soporte para las versiones anteriores. Athena no recomienda ejecutar programas con versiones obsoletas del intérprete de Python y recomienda encarecidamente que utilice el último tiempo de ejecución de Athena siempre que sea posible.
La programación de obsolescencia del tiempo de ejecución de Athena es la siguiente:
1. Una vez que Athena proporcione un nuevo tiempo de ejecución, Athena seguirá admitiendo el tiempo de ejecución anterior durante 6 meses. Durante ese tiempo, Athena aplicará revisiones y actualizaciones de seguridad al tiempo de ejecución anterior.
1. Transcurridos 6 meses, Athena dejará de ofrecer soporte para el tiempo de ejecución anterior. Athena ya no aplicará revisiones de seguridad ni otras actualizaciones al tiempo de ejecución anterior. Las aplicaciones de Spark que utilicen el tiempo de ejecución anterior ya no podrán recibir soporte técnico.
1. Transcurridos 12 meses, ya no podrá actualizar ni editar las aplicaciones de Spark en un grupo de trabajo que utilice el tiempo de ejecución anterior. Le recomendamos actualizar sus aplicaciones de Spark antes de finalizar este periodo. Una vez finalizado el periodo de tiempo, podrá seguir ejecutando los cuadernos existentes, pero los cuadernos que sigan utilizando el tiempo de ejecución anterior registrarán una advertencia en ese sentido.
1. Transcurridos 18 meses, ya no podrá ejecutar los trabajos en el grupo de trabajo utilizando el tiempo de ejecución anterior.
### Control de versiones y obsolescencia de los paquetes de conveniencia
El contenido de los paquetes de conveniencia cambia con el tiempo. Athena ocasionalmente agrega, elimina o actualiza estos paquetes de conveniencia.
Athena utiliza las siguientes pautas para los paquetes de conveniencia:
+ Los paquetes de conveniencia tienen un esquema de control de versiones simple, como 1, 2, 3.
+ Cada versión del paquete de conveniencia incluye versiones específicas de paquetes externos. Una vez que Athena crea un paquete de conveniencia, el conjunto de paquetes externos del paquete de conveniencia y sus versiones correspondientes no cambian.
+ Athena crea una nueva versión del paquete de conveniencia cuando incluye un nuevo paquete externo, elimina un paquete externo o actualiza la versión de uno o más paquetes externos.
Athena descarta un paquete de conveniencia cuando descarta el tiempo de ejecución de Athena que utiliza el paquete. Athena puede descartar los paquetes antes para limitar la cantidad de paquetes que admite.
La programación de obsolescencia de los paquetes de conveniencia sigue la programación de obsolescencia del tiempo de ejecución de Athena.
# Lista de bibliotecas de Python preinstaladas
Las bibliotecas de Python preinstaladas incluyen lo siguiente.
```
boto3==1.24.31
botocore==1.27.31
certifi==2022.6.15
charset-normalizer==2.1.0
cycler==0.11.0
cython==0.29.30
docutils==0.19
fonttools==4.34.4
idna==3.3
jmespath==1.0.1
joblib==1.1.0
kiwisolver==1.4.4
matplotlib==3.5.2
mpmath==1.2.1
numpy==1.23.1
packaging==21.3
pandas==1.4.3
patsy==0.5.2
pillow==9.2.0
plotly==5.9.0
pmdarima==1.8.5
pyathena==2.9.6
pyparsing==3.0.9
python-dateutil==2.8.2
pytz==2022.1
requests==2.28.1
s3transfer==0.6.0
scikit-learn==1.1.1
scipy==1.8.1
seaborn==0.11.2
six==1.16.0
statsmodels==0.13.2
sympy==1.10.1
tenacity==8.0.1
threadpoolctl==3.1.0
urllib3==1.26.10
pyarrow==9.0.0
```
## Notas
+ No se admiten MLlib (biblioteca de machine learning de Apache Spark) y el paquete `pyspark.ml`.
+ Actualmente, `pip install` no es compatible con Athena para las sesiones de Spark.
Para de obtener más información sobre cómo importar bibliotecas de Python a Amazon Athena para Apache Spark, consulte. [Importación de archivos y bibliotecas de Python a Athena para Spark](notebooks-import-files-libraries.md)
# Importación de archivos y bibliotecas de Python a Athena para Spark
En este documento, se proporcionan ejemplos de cómo importar archivos y bibliotecas de Python a Amazon Athena para Apache Spark.
## Condiciones y limitaciones
+ **Versión de Python**: actualmente, Athena para Spark usa la versión 3.9.16 de Python. Tenga en cuenta que los paquetes de Python son sensibles a las versiones inferiores de Python.
+ **Athena para la arquitectura Spark**: Athena para Spark utiliza Amazon Linux 2 en la arquitectura ARM64. Tenga en cuenta que algunas bibliotecas de Python no distribuyen binarios para esta arquitectura.
+ **Objetos binarios compartidos (SO)**: dado que el método [addPyFile](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkContext.addPyFile.html) de SparkContext no detecta objetos binarios compartidos, no se puede usar en Athena para que Spark agregue paquetes de Python que dependen de objetos compartidos.
+ **Conjuntos de datos distribuidos resilientes (RDD)**: no se admiten los [RDD](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.RDD.html).
+ **Dataframe.foreach**: no se admite el método [DataFrame.foreach](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/api/pyspark.sql.DataFrame.foreach.html) de PySpark.
## Ejemplos
En los ejemplos, se utilizan las siguientes convenciones.
+ La ubicación de los marcadores de posición de Amazon S3 `s3://amzn-s3-demo-bucket`. Reemplácela por la ubicación de un bucket de S3 propio.
+ Todos los bloques de código que se ejecutan desde un intérprete de comandos de Unix se muestran como *directory\$1name* `$`. Por ejemplo, el comando `ls` del directorio `/tmp` y su resultado se muestran de la siguiente manera:
```
/tmp $ ls
```
**Output**
```
file1 file2
```
## Importación de archivos de texto para usarlos en cálculos
En los ejemplos de esta sección, se muestra cómo importar archivos de texto para usarlos en los cálculos de sus cuadernos de Athena para Spark.
### Adición de un archivo a un cuaderno después de escribirlo en el directorio temporal local
En el siguiente ejemplo, se muestra cómo escribir un archivo en un directorio temporal local, agregarlo a un cuaderno y probarlo.
```
import os
from pyspark import SparkFiles
tempdir = '/tmp/'
path = os.path.join(tempdir, "test.txt")
with open(path, "w") as testFile:
_ = testFile.write("5")
sc.addFile(path)
def func(iterator):
with open(SparkFiles.get("test.txt")) as testFile:
fileVal = int(testFile.readline())
return [x * fileVal for x in iterator]
#Test the file
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show()
```
**Output**
```
Calculation completed.
+---+---+-------+
| _1| _2| col|
+---+---+-------+
| 1| a|[aaaaa]|
| 2| b|[bbbbb]|
+---+---+-------+
```
### Importar un archivo desde Amazon S3
En el siguiente ejemplo, se muestra cómo importar un archivo de Amazon S3 a un cuaderno y cómo probarlo.
**Para importar un archivo de Amazon S3 a un cuaderno**
1. Cree un archivo llamado `test.txt` que tenga una sola línea con el valor `5`.
1. Agregue el archivo a un bucket de Amazon S3. En este ejemplo, se utiliza la ubicación `s3://amzn-s3-demo-bucket`.
1. Utilice el siguiente código para importar el archivo a su cuaderno y probarlo.
```
from pyspark import SparkFiles
sc.addFile('s3://amzn-s3-demo-bucket/test.txt')
def func(iterator):
with open(SparkFiles.get("test.txt")) as testFile:
fileVal = int(testFile.readline())
return [x * fileVal for x in iterator]
#Test the file
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show()
```
**Output**
```
Calculation completed.
+---+---+-------+
| _1| _2| col|
+---+---+-------+
| 1| a|[aaaaa]|
| 2| b|[bbbbb]|
+---+---+-------+
```
## Adición de archivos de Python
En los ejemplos de esta sección, se muestra cómo agregar archivos y bibliotecas de Python a sus cuadernos de Spark en Athena.
### Adición de archivos de Python y registro de una UDF
En el siguiente ejemplo, se muestra cómo agregar archivos de Python desde Amazon S3 a su cuaderno y cómo registrar una UDF.
**Para agregar archivos de Python a su cuaderno y registrar una UDF**
1. Con una ubicación propia de Amazon S3, cree el archivo `s3://amzn-s3-demo-bucket/file1.py` con el siguiente contenido:
```
def xyz(input):
return 'xyz - udf ' + str(input);
```
1. En la misma ubicación de S3, cree el archivo `s3://amzn-s3-demo-bucket/file2.py` con el siguiente contenido:
```
from file1 import xyz
def uvw(input):
return 'uvw -> ' + xyz(input);
```
1. En su cuaderno de Athena para Spark, ejecute los siguientes comandos.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/file1.py')
sc.addPyFile('s3://amzn-s3-demo-bucket/file2.py')
def func(iterator):
from file2 import uvw
return [uvw(x) for x in iterator]
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
udf_with_import = udf(func)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", udf_with_import(col('_2'))).show(10)
```
**Output**
```
Calculation started (calculation_id=1ec09e01-3dec-a096-00ea-57289cdb8ce7) in (session=c8c09e00-6f20-41e5-98bd-4024913d6cee). Checking calculation status...
Calculation completed.
+---+---+--------------------+
| _1| _2| col|
+---+---+--------------------+
| 1 | a|[uvw -> xyz - ud... |
| 2 | b|[uvw -> xyz - ud... |
+---+---+--------------------+
```
### Importación de un archivo .zip de Python
Puede utilizar los métodos `addPyFile` y `import` de Python para importar un archivo .zip de Python a su cuaderno.
**nota**
Los archivos `.zip` que importe a Athena para Spark pueden incluir solo paquetes de Python. Por ejemplo, no se admite la inclusión de paquetes con archivos basados en C.
**Para importar un archivo `.zip` de Python a su cuaderno**
1. En su equipo local, en un directorio de escritorio, por ejemplo `\tmp`, cree un directorio llamado `moduletest`.
1. En el directorio `moduletest`, cree un archivo denominado `hello.py` con el contenido siguiente:
```
def hi(input):
return 'hi ' + str(input);
```
1. En el mismo directorio, agregue un archivo vacío con el nombre `__init__.py`.
Si saca un listado del contenido del directorio, ahora debería tener el siguiente aspecto.
```
/tmp $ ls moduletest
__init__.py hello.py
```
1. Utilice el comando `zip` para agregar los dos archivos del módulo en un archivo llamado `moduletest.zip`.
```
moduletest $ zip -r9 ../moduletest.zip *
```
1. Cargue el archivo `.zip` en el bucket de Amazon S3.
1. Use el siguiente código para importar el archivo `.zip` de Python a su cuaderno.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/moduletest.zip')
from moduletest.hello import hi
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
hi_udf = udf(hi)
df = spark.createDataFrame([(1, "a"), (2, "b")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Output**
```
Calculation started (calculation_id=6ec09e8c-6fe0-4547-5f1b-6b01adb2242c) in (session=dcc09e8c-3f80-9cdc-bfc5-7effa1686b76). Checking calculation status...
Calculation completed.
+---+---+----+
| _1| _2| col|
+---+---+----+
| 1| a|hi a|
| 2| b|hi b|
+---+---+----+
```
### Importación de dos versiones de una biblioteca de Python como módulos independientes
En los siguientes ejemplos de código, se muestra cómo agregar e importar dos versiones diferentes de una biblioteca de Python desde una ubicación de Amazon S3 como dos módulos independientes. El código agrega cada uno de los archivos de la biblioteca de S3, los importa y, a continuación, imprime la versión de la biblioteca para verificar la importación.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/python-third-party-libs-test/simplejson_v3_15.zip')
sc.addPyFile('s3://amzn-s3-demo-bucket/python-third-party-libs-test/simplejson_v3_17_6.zip')
import simplejson_v3_15
print(simplejson_v3_15.__version__)
```
**Output**
```
3.15.0
```
```
import simplejson_v3_17_6
print(simplejson_v3_17_6.__version__)
```
**Output**
```
3.17.6
```
### Importación de un archivo .zip de Python desde PyPI
En este ejemplo, se utiliza el comando `pip` para descargar un archivo .zip de Python del proyecto [bpabel/piglatin](https://github.com/bpabel/piglatin) desde el [Índice de paquetes de Python (PyPI)](https://pypi.org/).
**Para importar un archivo .zip de Python desde PyPI**
1. En el escritorio local, utilice los siguientes comandos para crear un directorio llamado `testpiglatin` y crear un entorno virtual.
```
/tmp $ mkdir testpiglatin
/tmp $ cd testpiglatin
testpiglatin $ virtualenv .
```
**Output**
```
created virtual environment CPython3.9.6.final.0-64 in 410ms
creator CPython3Posix(dest=/private/tmp/testpiglatin, clear=False, no_vcs_ignore=False, global=False)
seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=/Users/user1/Library/Application Support/virtualenv)
added seed packages: pip==22.0.4, setuptools==62.1.0, wheel==0.37.1
activators BashActivator,CShellActivator,FishActivator,NushellActivator,PowerShellActivator,PythonActivator
```
1. Cree un subdirectorio llamado `unpacked` para albergar el proyecto.
```
testpiglatin $ mkdir unpacked
```
1. Utilice el comando `pip` para instalar el proyecto en el directorio `unpacked`.
```
testpiglatin $ bin/pip install -t $PWD/unpacked piglatin
```
**Output**
```
Collecting piglatin
Using cached piglatin-1.0.6-py2.py3-none-any.whl (3.1 kB)
Installing collected packages: piglatin
Successfully installed piglatin-1.0.6
```
1. Compruebe el contenido del directorio.
```
testpiglatin $ ls
```
**Output**
```
bin lib pyvenv.cfg unpacked
```
1. Cambie al directorio `unpacked` y muestre el contenido.
```
testpiglatin $ cd unpacked
unpacked $ ls
```
**Output**
```
piglatin piglatin-1.0.6.dist-info
```
1. Utilice el comando `zip` para insertar el contenido del proyecto piglatin en un archivo llamado `library.zip`.
```
unpacked $ zip -r9 ../library.zip *
```
**Output**
```
adding: piglatin/ (stored 0%)
adding: piglatin/__init__.py (deflated 56%)
adding: piglatin/__pycache__/ (stored 0%)
adding: piglatin/__pycache__/__init__.cpython-39.pyc (deflated 31%)
adding: piglatin-1.0.6.dist-info/ (stored 0%)
adding: piglatin-1.0.6.dist-info/RECORD (deflated 39%)
adding: piglatin-1.0.6.dist-info/LICENSE (deflated 41%)
adding: piglatin-1.0.6.dist-info/WHEEL (deflated 15%)
adding: piglatin-1.0.6.dist-info/REQUESTED (stored 0%)
adding: piglatin-1.0.6.dist-info/INSTALLER (stored 0%)
adding: piglatin-1.0.6.dist-info/METADATA (deflated 48%)
```
1. (Opcional) Utilice los siguientes comandos para probar la importación localmente.
1. Establezca la ruta de Python en la ubicación del archivo `library.zip` e inicie Python.
```
/home $ PYTHONPATH=/tmp/testpiglatin/library.zip
/home $ python3
```
**Output**
```
Python 3.9.6 (default, Jun 29 2021, 06:20:32)
[Clang 12.0.0 (clang-1200.0.32.29)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
```
1. Importe la biblioteca y ejecute un comando de prueba.
```
>>> import piglatin
>>> piglatin.translate('hello')
```
**Output**
```
'ello-hay'
```
1. Utilice comandos como los siguientes para agregar el archivo `.zip` desde Amazon S3, importarlo a su cuaderno de Athena y probarlo.
```
sc.addPyFile('s3://amzn-s3-demo-bucket/library.zip')
import piglatin
piglatin.translate('hello')
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
hi_udf = udf(piglatin.translate)
df = spark.createDataFrame([(1, "hello"), (2, "world")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Output**
```
Calculation started (calculation_id=e2c0a06e-f45d-d96d-9b8c-ff6a58b2a525) in (session=82c0a06d-d60e-8c66-5d12-23bcd55a6457). Checking calculation status...
Calculation completed.
+---+-----+--------+
| _1| _2| col|
+---+-----+--------+
| 1|hello|ello-hay|
| 2|world|orld-way|
+---+-----+--------+
```
### Importación de un archivo .zip de Python desde PyPI con dependencias
En este ejemplo, se importa desde PyPI el paquete [https://github.com/makeworld-the-better-one/md2gemini](https://github.com/makeworld-the-better-one/md2gemini), que convierte el texto en Markdown al formato de texto Gemini. El paquete tiene las siguientes [dependencias](https://libraries.io/pypi/md2gemini):
```
cjkwrap
mistune
wcwidth
```
**Para importar un archivo .zip de Python con dependencias**
1. En su equipo local, utilice los siguientes comandos para crear un directorio llamado `testmd2gemini` y crear un entorno virtual.
```
/tmp $ mkdir testmd2gemini
/tmp $ cd testmd2gemini
testmd2gemini$ virtualenv .
```
1. Cree un subdirectorio llamado `unpacked` para albergar el proyecto.
```
testmd2gemini $ mkdir unpacked
```
1. Utilice el comando `pip` para instalar el proyecto en el directorio `unpacked`.
```
/testmd2gemini $ bin/pip install -t $PWD/unpacked md2gemini
```
**Output**
```
Collecting md2gemini
Downloading md2gemini-1.9.0-py3-none-any.whl (31 kB)
Collecting wcwidth
Downloading wcwidth-0.2.5-py2.py3-none-any.whl (30 kB)
Collecting mistune<3,>=2.0.0
Downloading mistune-2.0.2-py2.py3-none-any.whl (24 kB)
Collecting cjkwrap
Downloading CJKwrap-2.2-py2.py3-none-any.whl (4.3 kB)
Installing collected packages: wcwidth, mistune, cjkwrap, md2gemini
Successfully installed cjkwrap-2.2 md2gemini-1.9.0 mistune-2.0.2 wcwidth-0.2.5
...
```
1. Cambie al directorio `unpacked` y compruebe el contenido.
```
testmd2gemini $ cd unpacked
unpacked $ ls -lah
```
**Output**
```
total 16
drwxr-xr-x 13 user1 wheel 416B Jun 7 18:43 .
drwxr-xr-x 8 user1 wheel 256B Jun 7 18:44 ..
drwxr-xr-x 9 user1 staff 288B Jun 7 18:43 CJKwrap-2.2.dist-info
drwxr-xr-x 3 user1 staff 96B Jun 7 18:43 __pycache__
drwxr-xr-x 3 user1 staff 96B Jun 7 18:43 bin
-rw-r--r-- 1 user1 staff 5.0K Jun 7 18:43 cjkwrap.py
drwxr-xr-x 7 user1 staff 224B Jun 7 18:43 md2gemini
drwxr-xr-x 10 user1 staff 320B Jun 7 18:43 md2gemini-1.9.0.dist-info
drwxr-xr-x 12 user1 staff 384B Jun 7 18:43 mistune
drwxr-xr-x 8 user1 staff 256B Jun 7 18:43 mistune-2.0.2.dist-info
drwxr-xr-x 16 user1 staff 512B Jun 7 18:43 tests
drwxr-xr-x 10 user1 staff 320B Jun 7 18:43 wcwidth
drwxr-xr-x 9 user1 staff 288B Jun 7 18:43 wcwidth-0.2.5.dist-info
```
1. Utilice el comando `zip` para insertar el contenido del proyecto md2gemini en un archivo llamado `md2gemini.zip`.
```
unpacked $ zip -r9 ../md2gemini *
```
**Output**
```
adding: CJKwrap-2.2.dist-info/ (stored 0%)
adding: CJKwrap-2.2.dist-info/RECORD (deflated 37%)
....
adding: wcwidth-0.2.5.dist-info/INSTALLER (stored 0%)
adding: wcwidth-0.2.5.dist-info/METADATA (deflated 62%)
```
1. (Opcional) Utilice los siguientes comandos para comprobar que la biblioteca funciona en su equipo local.
1. Establezca la ruta de Python en la ubicación del archivo `md2gemini.zip` e inicie Python.
```
/home $ PYTHONPATH=/tmp/testmd2gemini/md2gemini.zip
/home python3
```
1. Importe la biblioteca y realice una prueba.
```
>>> from md2gemini import md2gemini
>>> print(md2gemini('[abc](https://abc.def)'))
```
**Output**
```
https://abc.def abc
```
1. Utilice los siguientes comandos para agregar el archivo `.zip` desde Amazon S3, importarlo a su cuaderno de Athena y realizar una prueba no UDF.
```
# (non udf test)
sc.addPyFile('s3://amzn-s3-demo-bucket/md2gemini.zip')
from md2gemini import md2gemini
print(md2gemini('[abc](https://abc.def)'))
```
**Output**
```
Calculation started (calculation_id=0ac0a082-6c3f-5a8f-eb6e-f8e9a5f9bc44) in (session=36c0a082-5338-3755-9f41-0cc954c55b35). Checking calculation status...
Calculation completed.
=> https://abc.def (https://abc.def/) abc
```
1. Utilice los siguientes comandos para realizar una prueba UDF.
```
# (udf test)
from pyspark.sql.functions import udf
from pyspark.sql.functions import col
from md2gemini import md2gemini
hi_udf = udf(md2gemini)
df = spark.createDataFrame([(1, "[first website](https://abc.def)"), (2, "[second website](https://aws.com)")])
df.withColumn("col", hi_udf(col('_2'))).show()
```
**Output**
```
Calculation started (calculation_id=60c0a082-f04d-41c1-a10d-d5d365ef5157) in (session=36c0a082-5338-3755-9f41-0cc954c55b35). Checking calculation status...
Calculation completed.
+---+--------------------+--------------------+
| _1| _2| col|
+---+--------------------+--------------------+
| 1|[first website](h...|=> https://abc.de...|
| 2|[second website](...|=> https://aws.co...|
+---+--------------------+--------------------+
```
# Uso de las propiedades de Spark para especificar una configuración personalizada
Al crear o editar una sesión en Amazon Athena para Apache Spark, puede usar las [propiedades de Spark](https://spark.apache.org/docs/latest/configuration.html#spark-properties) a fin de especificar los archivos `.jar`, los paquetes u otra configuración personalizada para la sesión. Para especificar las propiedades de Spark, puede usar la consola, la AWS CLI o la API de Athena.
## Uso de la consola de Athena para especificar propiedades de Spark
En la consola de Athena, puede especificar sus propiedades de Spark al [crear un cuaderno](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) o [editar una sesión actual](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details).
**Para agregar propiedades en el cuadro de diálogo **Crear cuaderno** o **Editar detalles de la sesión****
1. Amplíe **Propiedades de Spark**.
1. Para agregar sus propiedades, use la opción **Editar en la tabla** o **Editar en JSON**.
+ Para la opción **Editar en la tabla**, seleccione **Agregar propiedad** si desea agregar una propiedad o **Eliminar** si desea eliminar una propiedad. Utilice los cuadros **Clave** y **Valor** para introducir los nombres de las propiedades y sus valores.
+ Para agregar un archivo `.jar` personalizado, utilice la propiedad `spark.jars`.
+ Utilice la propiedad `spark.jars.packages` para especificar un archivo de paquete.
+ Para introducir y editar la configuración directamente, elija la opción **Editar en JSON**. En el editor de texto JSON, puede llevar a cabo las siguientes tareas:
+ Seleccione **Copiar** para copiar el texto JSON en el portapapeles.
+ Seleccione **Borrar** para eliminar todo el texto del editor JSON.
+ Elija el icono de ajustes (engranaje) a fin de configurar el ajuste de líneas o seleccionar un tema de color para el editor JSON.
### Notas
+ Puede configurar las propiedades en Athena para Spark, que es lo mismo que configurar las [propiedades de Spark](https://spark.apache.org/docs/latest/configuration.html#spark-properties) directamente en un objeto [SparkConf](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.SparkConf.html).
+ Inicie todas las propiedades de Spark con el prefijo `spark.`. Se ignoran las propiedades con otros prefijos.
+ No todas las propiedades de Spark están disponibles para la configuración personalizada en Athena. Si envía una solicitud `StartSession` que tiene una configuración restringida, la sesión no podrá iniciarse.
+ No puede usar el prefijo `spark.athena.` porque está reservado.
## Uso de la AWS CLI o la API de Athena para proporcionar una configuración personalizada
Para utilizar la AWS CLI o la API de Athena a fin de proporcionar la configuración de la sesión, utilice la acción de la API [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html) o el comando de la CLI [start-session](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/start-session.html). En la solicitud `StartSession`, utilice el campo `SparkProperties` del objeto [EngineConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EngineConfiguration.html) para pasar la información de configuración en formato JSON. Esto inicia una sesión con la configuración especificada.
Para especificar propiedades de Spark personalizadas desde la AWS CLI, use la configuración `engine-configuration` al iniciar una sesión interactiva.
```
aws athena start-session \
--region "REGION"
--work-group "WORKGROUP" \
--engine-configuration '{
"Classifications": [{
"Name": "spark-defaults",
"Properties": {
"spark.dynamicAllocation.minExecutors": "1",
"spark.dynamicAllocation.initialExecutors": "2",
"spark.dynamicAllocation.maxExecutors": "10",
"spark.dynamicAllocation.executorIdleTimeout": "300"
}
}]
}'
```
También puede especificar los valores de configuración predeterminados a nivel de grupo de trabajo mediante la acción de la API `CreateWorkgroup` o la acción de la API `UpdateWorkgroup`. Los valores predeterminados de configuración definidos en el grupo de trabajo se aplican a todas las sesiones iniciadas para ese grupo de trabajo.
Para especificar las propiedades predeterminadas de Spark de la AWS CLI para un grupo de trabajo, utilice la configuración `engine-configuration` al crear un grupo de trabajo nuevo:
```
aws athena create-work-group \
--region "REGION" \
--name "WORKGROUP_NAME" \
--configuration '{
"EngineVersion": {
"SelectedEngineVersion": "Apache Spark version 3.5"
},
"ExecutionRole": "EXECUTION_ROLE",
"EngineConfiguration": {
"Classifications": [
{
"Name": "spark-defaults",
"Properties": {
"spark.dynamicAllocation.minExecutors": "1",
"spark.dynamicAllocation.initialExecutors": "2",
"spark.dynamicAllocation.maxExecutors": "10",
"spark.dynamicAllocation.executorIdleTimeout": "300"
}
}
]
}
}'
```
Para modificar las propiedades predeterminadas de Spark de la AWS CLI para un grupo de trabajo, utilice la configuración `engine-configuration` al actualizar un grupo de trabajo: Los cambios se aplicarán a las nuevas sesiones interactivas en el futuro.
```
aws athena update-work-group \
--region "REGION" \
--work-group "WORKGROUP_NAME" \
--configuration-updates '{
"EngineVersion": {
"SelectedEngineVersion": "Apache Spark version 3.5"
},
"ExecutionRole": "EXECUTION_ROLE",
"EngineConfiguration": {
"Classifications": [
{
"Name": "spark-defaults",
"Properties": {
"spark.dynamicAllocation.minExecutors": "1",
"spark.dynamicAllocation.initialExecutors": "2",
"spark.dynamicAllocation.maxExecutors": "12",
"spark.dynamicAllocation.executorIdleTimeout": "300"
}
}
]
}
}'
```
# Formatos de datos y almacenamiento compatibles
En la siguiente tabla se muestran los formatos que se admiten de manera nativa en Athena para Apache Spark.
****
| **Formato de los datos** | **Lectura** | **Escritura** | **Compresión de escritura** |
| --- | --- | --- | --- |
| parquet | sí | sí | ninguna, sin comprimir, snappy, gzip |
| orc | sí | sí | ninguna, snappy, zlib, lzo |
| json | sí | sí | bzip2, gzip, deflate |
| csv | sí | sí | bzip2, gzip, deflate |
| text | sí | sí | ninguna, bzip2, gzip, deflate |
| archivo binario | sí | N/A | N/A |
# Supervisión de Apache Spark con métricas de CloudWatch
Athena publica las métricas relacionadas con el cálculo en Amazon CloudWatch cuando se selecciona la opción **[Publish CloudWatch metrics](notebooks-spark-getting-started.md#notebook-gs-metrics)** para su grupo de trabajo habilitado para Spark. En la consola de CloudWatch puede crear paneles personalizados y establecer alarmas y activadores de métricas.
Athena publica las siguientes métricas en la consola de CloudWatch bajo el espacio de nombres `AmazonAthenaForApacheSpark`:
+ `DPUCount`: número de DPU consumidas durante la sesión para ejecutar los cálculos.
Esta métrica tiene las siguientes dimensiones:
+ `SessionId`: ID de la sesión en la que se envían los cálculos.
+ `WorkGroup`: nombre del grupo de trabajo.
**Para consultar las métricas de los grupos de trabajo habilitados para Spark en la consola de Amazon CloudWatch**
1. Abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, seleccione **Métricas** y, a continuación, **Todas las métricas**.
1. Seleccione el espacio de nombres **AmazonAthenaForApacheSpark**.
**Para ver métricas mediante la CLI**
+ Realice una de las siguientes acciones:
+ Para enumerar las métricas de los grupos de trabajo habilitados para Spark de Athena, abra un símbolo del sistema y utilice el siguiente comando:
```
aws cloudwatch list-metrics --namespace "AmazonAthenaForApacheSpark"
```
+ Para mostrar todas las métricas disponibles, utilice el siguiente comando:
```
aws cloudwatch list-metrics
```
## Lista de métricas y dimensiones de CloudWatch para cálculos de Apache Spark en Athena
Si habilitó métricas de CloudWatch en su grupo de trabajo de Athena habilitado para Spark, Athena envía las siguientes métricas a CloudWatch por grupo de trabajo. La métrica usa el espacio de nombres `AmazonAthenaForApacheSpark`.
****
| Nombre de métrica | Descripción |
| --- | --- |
| DPUCount | Número de DPU (unidades de procesamiento de datos) consumidas durante la sesión para ejecutar los cálculos. Una DPU es una medida relativa de la potencia de procesamiento que consta de 4 vCPU de capacidad de cómputo y 16 GB de memoria. |
Esta métrica tiene las siguientes dimensiones.
| Dimensión | Descripción |
| --- | --- |
| SessionId | El ID de la sesión en la que se envían los cálculos. |
| WorkGroup | El nombre del grupo de trabajo. |
## Lista de métricas y dimensiones de CloudWatch para las sesiones interactivas de Athena Spark
En la versión de lanzamiento de Apache Spark 3.5, si habilitó métricas de CloudWatch en su grupo de trabajo de Athena Spark, Athena envía las siguientes métricas a CloudWatch. La métrica usa el espacio de nombres `AmazonAthenaForApacheSpark`.
****
| Nombre | Descripción |
| --- | --- |
| DPUConsumed | El número de DPU consumidas activamente por las consultas en un estado EN EJECUCIÓN en un momento determinado en el grupo de trabajo. |
Esta métrica tiene las siguientes dimensiones.
| Dimensión | Descripción |
| --- | --- |
| Cuenta | El ID de la cuenta de AWS. |
| WorkGroup | El nombre del grupo de trabajo. |
# Atribución de costos a nivel de sesión
A partir de la versión 3.5 de Apache Spark, Athena permite realizar un seguimiento de los costos de cada sesión. Puede definir etiquetas de asignación de costos al iniciar una sesión y los costos informados de una sesión aparecerán en el Explorador de costos o en los informes de asignación de costos de facturación de AWS. También puede aplicar etiquetas de asignación de costos a nivel de grupo de trabajo y copiarlas a cualquier sesión que se inicie en ese grupo de trabajo.
## Uso de la atribución de costos a nivel de sesión
De forma predeterminada, las etiquetas de asignación de costos especificadas a nivel de grupo de trabajo se copian en las sesiones interactivas que se inician en ese grupo de trabajo.
Desactivación de las etiquetas que se van a copiar del grupo de trabajo al iniciar una sesión interactiva desde AWS CLI:
```
aws athena start-session \
--region "REGION" \
--work-group "WORKGROUP" \
--tags '[
{
"Key": "tag_key",
"Value": "tag_value"
}
]' \
--no-copy-work-group-tags
```
Habilitación de las etiquetas que se van a copiar del grupo de trabajo al iniciar una sesión interactiva desde AWS CLI:
```
aws athena start-session \
--region "REGION" \
--work-group "WORKGROUP" \
--copy-work-group-tags
```
## Condiciones y limitaciones
+ Las etiquetas de sesión anulan las etiquetas de grupo de trabajo con las mismas claves.
# Registro y supervisión de las sesiones de Apache Spark
A partir de la versión 3.5 de Apache Spark, puede especificar el registro administrado, de Amazon S3 o de CloudWatch como opciones de registro.
Con el registro administrado y el registro de S3, en la siguiente tabla se muestran las ubicaciones de registro y la disponibilidad de la IU que puede esperar si elige esas opciones.
****
| Opción | Registros de eventos | Registros de contenedor | IU de las aplicaciones |
| --- | --- | --- | --- |
| Registro administrado (valor predeterminado) | Almacenado en un bucket de S3 administrado | Almacenado en un bucket de S3 administrado | Compatible |
| Tanto registro administrado como bucket de S3 | Almacenado en ambos lugares | Almacenado en un bucket de S3 | Compatible |
| Bucket de Amazon S3 | Almacenado en un bucket de S3 | Almacenado en un bucket de S3 | No admitido1 |
1 Le sugerimos que mantenga seleccionada la opción de registro administrado. De lo contrario, no podrá utilizar las IU de la aplicación integradas.
## Registro administrado
De forma predeterminada, los grupos de trabajo de Athena Spark almacenan los registros de las aplicaciones de forma segura en los bucket de S3 administrados por el servicio durante un máximo de 30 días.
Si lo desea, puede proporcionar una clave de KMS (ID de clave, ARN, alias o ARN de alias) que el servicio utilizará para cifrar los registros administrados.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"ManagedLoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
},
}'
--engine-configuration ''
```
**nota**
Si desactiva el registro administrado, Athena no podrá solucionar los problemas de sus sesiones en su nombre. Ejemplo: no accederá a la interfaz de usuario de Spark desde los cuadernos de Amazon SageMaker AI Studio ni mediante la API `GetResourceDashboard`.
Para desactivar esta opción desde la AWS CLI, utilice la configuración `ManagedLoggingConfiguration` cuando inicie una sesión interactiva.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"ManagedLoggingConfiguration": {
"Enabled": false
},
}'
--engine-configuration ''
```
### Permisos necesarios para el registro administrado
Si ha proporcionado una clave de KMS, necesitará los siguientes permisos en la política de permisos para el rol de ejecución.
```
{
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*",
"Effect": "Allow"
}
```
## Registros de Amazon S3
Puede configurar la entrega de registros a buckets de Amazon S3.
Para activar la entrega de registros de S3 desde la AWS CLI, utilice la configuración `S3LoggingConfiguration` cuando inicie una sesión interactiva.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"S3LoggingConfiguration": {
"Enabled":true,
"LogLocation": "s3://bucket/",
},
}'
--engine-configuration ''
```
Si lo desea, puede proporcionar una clave de KMS (ID de clave, ARN, alias o ARN de alias) que el servicio utilizará para cifrar los registros de S3.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"S3LoggingConfiguration": {
"Enabled":true,
"LogLocation": "s3://bucket/",
"KmsKey": "KMS_KEY"
},
}'
--engine-configuration ''
```
### Permisos necesarios para la entrega de registros a Amazon S3
Para que las sesiones puedan entregar registros a los buckets de Amazon S3, incluya los siguientes permisos en la política de permisos del rol de ejecución.
```
{
"Action": "s3:*",
"Resource": "*",
"Effect": "Allow"
}
```
Si ha proporcionado una clave de KMS, también necesitará los siguientes permisos en la política de permisos del rol de ejecución.
```
{
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*",
"Effect": "Allow"
}
```
Si la clave de kms y el bucket no son de la misma cuenta, KMS debe permitir la entidad principal del servicio de S3.
```
{
"Effect": "Allow",
"Principal": { "Service": "s3.amazonaws.com" },
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:GenerateDataKey*"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "ACCOUNT_HAVING_KMS_KEY"
}
}
}
```
## Registro de CloudWatch
Puede configurar la entrega de registros a grupos de registro de CloudWatch.
Para activar la entrega de registros de S3 desde la AWS CLI, utilice la configuración `CloudWatchLoggingConfiguration` cuando inicie una sesión interactiva.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-"
}
}'
--engine-configuration ''
```
Todos los registros se entregarán de forma predeterminada, pero si lo desea, puede especificar qué tipos de registro desea incluir.
```
aws athena start-session \
--work-group "WORKGROUP" \
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
}
}'
--engine-configuration ''
```
### Permisos necesarios para la entrega de registros a CloudWatch
Para que las sesiones puedan entregar registros a los grupos de registro de CloudWatch, incluya los siguientes permisos en la política de permisos del rol de ejecución.
```
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:DescribeLogGroups",
"logs:DescribeLogStreams"
],
"Resource": "*",
"Effect": "Allow"
}
```
Y el siguiente permiso para la política de recursos de claves de KMS.
```
{
"Effect": "Allow",
"Principal": {
"Service": "logs..amazonaws.com"
},
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": "*"
}
```
## Configuración de los valores predeterminados de registro en el grupo de trabajo
También puede especificar las opciones de registro predeterminadas a nivel de grupo de trabajo.
Para especificar las opciones de registro predeterminadas de la AWS CLI para un grupo de trabajo, utilice la configuración `monitoring-configuration` al crear un grupo de trabajo nuevo:
```
aws athena create-work-group \
--region "REGION" \
--name "WORKGROUP_NAME" \
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
},
"ManagedLoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
},
"S3LoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
"LogLocation": "s3://bucket/",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
}
}'
```
Para modificar las opciones de registro predeterminadas de la AWS CLI para un grupo de trabajo, utilice la configuración `monitoring-configuration` al actualizar un grupo de trabajo: Los cambios se aplicarán a las nuevas sesiones interactivas en el futuro.
```
aws athena update-work-group \
--region "REGION" \
--work-group "WORKGROUP_NAME"
--monitoring-configuration '{
"CloudWatchLoggingConfiguration": {
"Enabled": true,
"LogGroup": "/aws/athena/sessions/${workgroup}",
"LogStreamNamePrefix": "session-",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
},
"ManagedLoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
},
"S3LoggingConfiguration": {
"Enabled": true,
"KmsKey": "KMS_KEY"
"LogLocation": "s3://bucket/",
"LogTypes": {
"SPARK_DRIVER": [
"STDOUT",
"STDERR"
],
"SPARK_EXECUTOR": [
"STDOUT",
"STDERR"
]
}
}
}'
```
# Acceso a la interfaz de usuario de Spark
Las interfaces de usuario de Apache Spark presentan interfaces visuales con información detallada sobre los trabajos de Spark en ejecución y finalizados. Puede supervisar y depurar las sesiones interactivas en Athena Spark mediante las interfaces de usuario nativas de Apache Spark, donde puede analizar las métricas específicas de cada trabajo y la información sobre los cronogramas, las etapas, las tareas y los ejecutores de los eventos de cada trabajo de Spark.
## Acceso a la interfaz de usuario de Spark
Tras iniciar una sesión interactiva de Athena Spark, puede ver la interfaz de usuario de Spark en tiempo real para las sesiones en ejecución desde los cuadernos de Estudio unificado de Amazon SageMaker AI o solicitar una URL segura mediante la API `GetResourceDashboard`. Para ver las sesiones finalizadas, puede ver el servidor de historial de Spark desde los cuadernos de Estudio unificado de Amazon SageMaker AI Unified Studio, la consola de Amazon Athena o mediante la misma API.
```
aws athena get-resource-dashboard \
--region "REGION" \
--session-id "SESSION_ID"
```
## Permisos necesarios para acceder a la interfaz de usuario de Spark
Antes de que pueda acceder a la interfaz de usuario de Spark, se deben incluir los siguientes permisos en la política de permisos del usuario o rol.
```
{
"Action": "athena:GetResourceDashboard",
"Resource": "WORKGROUP",
"Effect": "Allow"
}
```
# Soporte de Spark Connect
Spark Connect es una arquitectura cliente-servidor para Apache Spark que desacopla el cliente de la aplicación del proceso de controlador del clúster de Spark, lo que permite la conectividad remota a Spark desde los clientes compatibles. Spark Connect también permite la depuración interactiva durante el desarrollo directamente desde sus IDE o clientes favoritos.
A partir de la versión 3.5 de Apache Spark, Athena admite Spark Connect como punto de conexión de AWS al que se puede acceder mediante la API `GetSessionEndpoint`.
## Ejemplos de API/CLI (GetSessionEndpoint)
Puede usar la API `GetSessionEndpoint` para obtener el punto de conexión de Spark Connect para una sesión interactiva.
```
aws athena get-session-endpoint \
--region "REGION" \
--session-id "SESSION_ID"
```
Esta API devuelve la URL del punto de conexión de Spark Connect para esa sesión.
```
{
"EndpointUrl": "ENDPOINT_URL",
"AuthToken": "AUTH_TOKEN",
"AuthTokenExpirationTime": "AUTH_TOKEN_EXPIRY_TIME"
}
```
## Conexión desde clientes autoadministrados
Puede conectarse a una sesión interactiva de Athena Spark desde clientes autoadministrados.
### Requisitos previos
Instale el cliente pyspark-connect para Spark 3.5.6 y el SDK de AWS para Python.
```
pip install --user pyspark[connect]==3.5.6
pip install --user boto3
```
El siguiente es un ejemplo de script de Python para enviar solicitudes directamente al punto de conexión de la sesión:
```
import boto3
import time
from pyspark.sql import SparkSession
client = boto3.client('athena', region_name='')
# start the session
response = client.start_session(
WorkGroup='',
EngineConfiguration={}
)
# wait for the session endpoint to be ready
time.sleep(5)
response = client.get_session_endpoint(SessionId=session_id)
# construct the authenticated remote url
authtoken=response['AuthToken']
endpoint_url=response['EndpointUrl']
endpoint_url=endpoint_url.replace("https", "sc")+":443/;use_ssl=true;"
url_with_headers = (
f"{endpoint_url}"
f"x-aws-proxy-auth={authtoken}"
)
# start the Spark session
start_time = time.time()
spark = SparkSession.builder\
.remote(url_with_headers)\
.getOrCreate()
spark.version
#
# Enter your spark code here
#
# stop the Spark session
spark.stop()
```
El siguiente es un ejemplo de script de Python para acceder a la interfaz de usuario de Spark en vivo o al servidor de historial de Spark durante una sesión:
```
Region=''
WorkGroupName=''
SessionId=''
Partition='aws'
Account=''
SessionARN=f"arn:{Partition}:athena:{Region}:{Account}:workgroup/{WorkGroupName}/session/{SessionId}"
# invoke the API to get the live UI/persistence UI for a session
response = client.get_resource_dashboard(
ResourceARN=SessionARN
)
response['Url']
```
# Habilitación de buckets de Amazon S3 de pago por solicitante en Athena para Spark
Cuando un bucket de Amazon S3 se configura para pagos por solicitante, a la cuenta del usuario que ejecuta la consulta se le cobran las tarifas de acceso y transferencia de datos asociadas a la consulta. Para obtener más información, consulte [Uso de buckets de pagos por solicitante para transferencias de almacenamiento y uso](https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html) en la *Guía del usuario de Amazon S3*.
En Athena para Spark, los buckets de pagos por solicitante están habilitados por sesión, no por grupo de trabajo. En un nivel superior, habilitar los buckets de pagos por solicitante incluye los siguientes pasos:
1. En la consola de Amazon S3, habilite los pagos por solicitante en las propiedades del bucket y agregue una política de bucket para especificar el acceso.
1. En la consola de IAM, cree una política de IAM para permitir el acceso al bucket y, a continuación, adjunte la política al rol de IAM que se utilizará para acceder al bucket de pagos por solicitante.
1. En Athena para Spark, agregue una propiedad de sesión para habilitar la característica de pagos por solicitante.
## Paso 1: habilitar el pago por solicitante en un bucket de Amazon S3 y agregar una política de bucket
**Para habilitar los pagos por solicitante en un bucket de S3**
1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3](https://console.aws.amazon.com/s3/).
1. En la lista de buckets, elija el enlace del bucket para el que desea habilitar los pagos por solicitante.
1. En la página del bucket, elija la pestaña **Propiedades**.
1. Desplácese hacia abajo hasta la sección **Pagos por solicitante** y, a continuación, elija **Editar**.
1. En la página **Editar pagos por solicitante**, seleccione **Habilitar** y, a continuación, elija **Guardar cambios**.
1. Elija la pestaña **Permisos**.
1. Elija **Editar** en la sección **Política de bucket**.
1. En la página **Editar política de bucket**, aplique la política de bucket que desee para el bucket de origen. El siguiente ejemplo de política da acceso a todas las entidades principales de AWS (`"AWS": "*"`), pero su acceso puede ser más detallado. Por ejemplo, puede que desee especificar solo un rol de IAM determinado en otra cuenta.
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Sid": "Statement1", "Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::111122223333:root" },
"Action": "s3:*", "Resource": [
"arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket",
"arn:aws:s3:::555555555555-us-east-1-amzn-s3-demo-bucket/*"
] } ] }
```
------
## Paso 2: crear una política de IAM y adjuntarla a un rol de IAM
Luego, cree una política de IAM que permita el acceso al bucket. A continuación, adjunte la política al rol que se utilizará para acceder al bucket de pagos por solicitante.
**Para crear una política de IAM para el bucket de pagos por solicitante y adjuntar la política a un rol**
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. En en el panel de navegación de la consola de IAM, elija **Políticas**.
1. Elija **Crear política**.
1. Elija **JSON**.
1. En el **Editor de políticas**, agregue una política como la que sigue:
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Action": [ "s3:*" ], "Effect": "Allow",
"Resource": [
"arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket",
"arn:aws:s3:::111122223333-us-east-1-amzn-s3-demo-bucket/*"
] } ] }
```
------
1. Elija **Siguiente**.
1. En la página **Revisar y crear**, escriba un nombre y una descripción opcional para la política y, a continuación, elija **Crear política**.
1. Seleccione **Roles** en el panel de navegación.
1. En la página **Roles**, busque el rol que desea usar y, a continuación, elija el enlace del nombre del rol.
1. En la sección **Políticas de permisos**, elija **Agregar permisos**, **Adjuntar políticas**.
1. En la sección **Otras políticas de permisos**, active la casilla de verificación de la política que creó y, a continuación, elija **Agregar permisos**.
## Paso 3: agregar una propiedad de sesión de Athena para Spark
Una vez que haya configurado el bucket de Amazon S3 y los permisos asociados para los pagos por solicitante, podrá habilitar la característica en una sesión de Athena para Spark.
**Para habilitar buckets de pagos por solicitante en una sesión de Athena para Spark**
1. En el editor de cuadernos, en el menú **Session** (Sesión) de la esquina superior derecha, elija **Edit session** (Editar sesión).
1. Amplíe **Propiedades de Spark**.
1. Seleccione **Editar en JSON**.
1. En el editor de texto JSON, introduzca lo siguiente:
```
{
"spark.hadoop.fs.s3.useRequesterPaysHeader":"true"
}
```
1. Seleccione **Save**.
# Uso de Lake Formation con los grupos de trabajo de Athena Spark
Con la versión de lanzamiento de Apache Spark 3.5, puede aprovechar AWS Lake Formation con AWS Glue Data Catalog, donde el rol de ejecución de la sesión tiene permisos de tabla completos. Esta capacidad le permite leer y escribir en tablas protegidas por Lake Formation desde sus sesiones interactivas de Athena Spark. Consulte las siguientes secciones para obtener más información sobre Lake Formation y cómo usarlo con Athena Spark.
## Paso 1: habilitación del acceso completo a las tablas en Lake Formation
Para utilizar el modo de acceso completo a la tabla (FTA), debe permitir que Athena Spark acceda a los datos sin la validación de etiquetas de sesión de IAM en AWS Lake Formation. Para habilitarlo, siga los pasos descritos en [Integración de aplicaciones para acceso completo a la tabla ](https://docs.aws.amazon.com//lake-formation/latest/dg/fta-app-integration.html).
### Paso 1.1: registro de las ubicaciones de los datos en Lake Formation mediante el rol definido por el usuario
Debe utilizar un rol definido por el usuario para registrar las ubicaciones de los datos en AWS Lake Formation. Consulte [Requisitos de los roles utilizados para registrar ubicaciones](https://docs.aws.amazon.com//lake-formation/latest/dg/registration-role.html) para obtener más información.
## Paso 2: configuración de los permisos de IAM para el rol de ejecución de la sesión
Para acceder a los datos subyacentes, ya sea para lectura o escritura, además de los permisos de Lake Formation, el rol de ejecución necesita el permiso de IAM `lakeformation:GetDataAccess`. Con este permiso, Lake Formation concede la solicitud de credenciales temporales para acceder a los datos.
El siguiente es un ejemplo de política sobre cómo proporcionar permisos de IAM para acceder a un script en Amazon S3, cargar registros en S3, permisos de la API de AWS Glue y permiso para acceder a Lake Formation.
### Paso 2.1: configuración de los permisos de Lake Formation
+ Los trabajos de Spark que leen datos desde S3 requieren el permiso `SELECT` de Lake Formation.
+ Los trabajos de Spark que escriben o eliminan datos en S3 requieren el permiso `ALL (SUPER)` de Lake Formation.
+ Los trabajos de Spark que interactúan con AWS Glue Data Catalog requieren los permisos `DESCRIBE`, `ALTER` y `DROP`, según corresponda.
## Paso 3: inicialización de una sesión de Spark para el acceso completo a la tabla mediante Lake Formation
### Requisitos previos
AWS Glue Data Catalog se debe configurar como un metaalmacén para acceder a las tablas de Lake Formation.
Para configurar AWS Glue Catalog como metaalmacén, establezca la siguiente configuración:
```
{
"spark.hadoop.glue.catalogid": "ACCOUNT_ID",
"spark.hadoop.hive.metastore.client.factory.class": "com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory",
"spark.hadoop.hive.metastore.glue.catalogid": "ACCOUNT_ID",
"spark.sql.catalogImplementation": "hive"
}
```
Para acceder a tablas registradas en AWS Lake Formation, es necesario establecer las siguientes configuraciones durante la inicialización de Spark, con el fin de configurar Spark para que utilice credenciales de AWS Lake Formation.
### Hive
```
{
"spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver",
"spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": "true",
"spark.hadoop.fs.s3.folderObject.autoAction.disabled": "true",
"spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": "true",
"spark.sql.catalog.createDirectoryAfterTable.enabled": "true",
"spark.sql.catalog.dropDirectoryBeforeTable.enabled": "true"
}
```
### Apache Iceberg
```
{
"spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension",
"spark.sql.catalog.spark_catalog": "org.apache.iceberg.spark.SparkSessionCatalog",
"spark.sql.catalog.spark_catalog.warehouse": "s3://your-bucket/warehouse/",
"spark.sql.catalog.spark_catalog.client.region": "REGION",
"spark.sql.catalog.spark_catalog.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.sql.catalog.spark_catalog.glue.account-id": "ACCOUNT_ID",
"spark.sql.catalog.spark_catalog.glue.lakeformation-enabled": "true"
}
```
### Tablas de Amazon S3
```
{
"spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension",
"spark.sql.catalog.{catalogName}": "org.apache.iceberg.spark.SparkCatalog",
"spark.sql.catalog.{catalogName}.warehouse": "arn:aws:s3tables:{region}:{accountId}:bucket/{bucketName}",
"spark.sql.catalog.{catalogName}.catalog-impl": "org.apache.iceberg.aws.glue.GlueCatalog",
"spark.sql.catalog.{catalogName}.glue.id": "{accountId}:s3tablescatalog/{bucketName}",
"spark.sql.catalog.{catalogName}.glue.lakeformation-enabled": "true",
"spark.sql.catalog.{catalogName}.client.region": "REGION",
"spark.sql.catalog.{catalogName}.glue.account-id": "ACCOUNT_ID"
}
```
### Delta Lake
```
{
"spark.sql.extensions": "io.delta.sql.DeltaSparkSessionExtension",
"spark.sql.catalog.spark_catalog": "org.apache.spark.sql.delta.catalog.DeltaCatalog",
"spark.hadoop.fs.s3.credentialsResolverClass": "com.amazonaws.glue.accesscontrol.AWSLakeFormationCredentialResolver",
"spark.hadoop.fs.s3.useDirectoryHeaderAsFolderObject": "true",
"spark.hadoop.fs.s3.folderObject.autoAction.disabled": "true",
"spark.sql.catalog.skipLocationValidationOnCreateTable.enabled": "true",
"spark.sql.catalog.createDirectoryAfterTable.enabled": "true",
"spark.sql.catalog.dropDirectoryBeforeTable.enabled": "true"
}
```
## Condiciones y limitaciones
+ El acceso completo a tablas es compatible con tablas de Hive, Iceberg, Tablas de Amazon S3 y Delta. Las tablas de Hudi son compatibles con el acceso completo a las tablas.
+ Para añadir nuevos catálogos a una sesión activa, utilice `spark.conf.set` con nuevas configuraciones de catálogo.
+ Las configuraciones del catálogo son inmutables. Si desea actualizar la configuración de un catálogo, cree un nuevo catálogo mediante `spark.conf.set`.
+ Añada solo los catálogos que necesite a la sesión de Spark.
+ Para cambiar el catálogo predeterminado: `spark.catalog.setCurrentCatalog("s3tablesbucket")`
+ Si tiene caracteres especiales en el nombre de su catálogo, como `-`, úselos con el carácter de escape en la consulta de la siguiente manera:
```
SELECT sales_amount as nums FROM `my-s3-tables-bucket`.`s3namespace`.`daily_sales` LIMIT 100
```
# Habilitación del cifrado de Apache Spark
Puede habilitar el cifrado de Apache Spark en Athena. Al hacerlo, se cifran los datos en tránsito entre los nodos de Spark y también se cifran los datos en reposo que Spark almacena de manera local. Para mejorar la seguridad de estos datos, Athena utiliza la siguiente configuración de cifrado:
```
spark.io.encryption.keySizeBits="256"
spark.io.encryption.keygen.algorithm="HmacSHA384"
```
Para habilitar el cifrado de Spark, puede usar la consola, la AWS CLI o la API de Athena.
## Uso de la consola de Athena para habilitar el cifrado de Spark en un nuevo cuaderno
**Para crear un cuaderno nuevo con el cifrado de Spark habilitado**
1. Abra la consola de Athena en [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Si el panel de navegación de la consola no está visible, elija el menú de expansión de la izquierda.
1. Realice una de las siguientes acciones:
+ En **Notebook explorer** (Explorador de cuadernos), elija **Create notebook** (Crear cuaderno).
+ En **Notebook editor** (Editor de cuadernos), elija **Create notebook** (Crear cuaderno) o elija el icono con el signo más (**\$1**) para agregar un cuaderno.
1. En **Nombre del cuaderno**, ingrese un nombre para el cuaderno.
1. Amplíe la opción **Propiedades de Spark**.
1. Seleccione **Activar el cifrado de Spark**.
1. Seleccione **Crear**.
La sesión del cuaderno que cree estará cifrada. Use el nuevo cuaderno como lo haría normalmente. Cuando más adelante inicie nuevas sesiones que usen el cuaderno, las nuevas sesiones también estarán cifradas.
## Uso de la consola de Athena para habilitar el cifrado de Spark en un cuaderno existente
También puede utilizar la consola de Athena para habilitar el cifrado de Spark en un cuaderno existente.
**Para habilitar el cifrado en un cuaderno existente**
1. [Abra una nueva sesión](notebooks-spark-managing.md#opening-a-previously-created-notebook) para un cuaderno ya creado.
1. En el editor de cuadernos, en el menú **Session** (Sesión) de la esquina superior derecha, elija **Edit session** (Editar sesión).
1. En el cuadro de diálogo **Editar detalles de la sesión**, amplíe **Propiedades de Spark**.
1. Seleccione **Activar el cifrado de Spark**.
1. Seleccione **Save**.
La consola inicia una nueva sesión con el cifrado habilitado. Las sesiones posteriores que cree para este cuaderno también tendrán el cifrado habilitado.
## Uso de la AWS CLI para habilitar el cifrado de Spark
Puede usar la AWS CLI para habilitar el cifrado al iniciar una sesión mediante la especificación de las propiedades de Spark correspondientes.
**Para usar la AWS CLI a fin de habilitar el cifrado de Spark**
1. Use un comando como el siguiente para crear un objeto JSON de configuración del motor que especifique las propiedades de cifrado de Spark.
```
ENGINE_CONFIGURATION_JSON=$(
cat <
Para habilitar el cifrado de Spark con la API de Athena, use la acción [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html) y el parámetro [EngineConfiguration](https://docs.aws.amazon.com/athena/latest/APIReference/API_EngineConfiguration.html) de `SparkProperties` a fin de especificar la configuración de cifrado en su solicitud `StartSession`.
# Configuración del acceso entre cuentas de AWS Glue en Athena para Spark
En este tema, se muestra cómo se pueden configurar la cuenta de consumidor *666666666666* y la cuenta de propietario *999999999999* para el acceso entre cuentas de AWS Glue. Cuando se configuran las cuentas, la cuenta del consumidor puede ejecutar consultas desde Athena para Spark en las bases de datos y tablas de AWS Glue del propietario.
## Paso 1: proporcionar acceso a los roles de consumidor en AWS Glue
En AWS Glue, el propietario crea una política que proporciona a los roles de consumidor acceso al catálogo de datos de AWS Glue del propietario.
**Para agregar una política de AWS Glue que permita a un rol de consumidor acceder al catálogo de datos del propietario**
1. Con la cuenta del propietario del catálogo, inicie sesión en la Consola de administración de AWS.
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, amplíe **Catálogo de datos** y, a continuación, elija **Configuración del catálogo**.
1. En la página **Configuración del catálogo de datos**, en la sección de **Permisos**, agregue una política como la siguiente. Esta política proporciona roles para que la cuenta de consumidor *666666666666* acceda al catálogo de datos en la cuenta de propietario *999999999999*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Cataloguers",
"Effect": "Allow",
"Principal": {
"AWS": [
"arn:aws:iam::666666666666:role/Admin",
"arn:aws:iam::666666666666:role/AWSAthenaSparkExecutionRole"
]
},
"Action": "glue:*",
"Resource": [
"arn:aws:glue:us-west-2:999999999999:catalog",
"arn:aws:glue:us-west-2:999999999999:database/*",
"arn:aws:glue:us-west-2:999999999999:table/*"
]
}
]
}
```
------
## Paso 2: configurar la cuenta de consumidor para el acceso
En la cuenta de consumidor, cree una política que permita el acceso a las bases de datos, las tablas y el AWS Glue Data Catalog del propietario, y adjunte la política a un rol. En el siguiente ejemplo, se utiliza la cuenta de consumidor *666666666666*.
**Para crear una política de AWS Glue a fin de acceder al AWS Glue Data Catalog**
1. Con la cuenta de consumidor, inicia sesión en la Consola de administración de AWS.
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. En el panel de navegación, amplíe **Administración de acceso** y, a continuación, seleccione **Políticas**.
1. Elija **Crear política**.
1. En la página **Especificar permisos**, seleccione **JSON**.
1. En el **Editor de políticas**, ingrese una instrucción JSON como la siguiente que permita realizar acciones de AWS Glue en el catálogo de datos de la cuenta de propietario.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "glue:*",
"Resource": [
"arn:aws:glue:us-east-1:999999999999:catalog",
"arn:aws:glue:us-east-1:999999999999:database/*",
"arn:aws:glue:us-east-1:999999999999:table/*"
]
}
]
}
```
------
1. Elija **Siguiente**.
1. En la página **Revisar y crear**, en **Nombre de la política**, ingrese un nombre para la política.
1. Elija **Crear política**.
Luego, utilice la consola de IAM de la cuenta de consumidor para adjuntar la política que acaba de crear al rol o los roles de IAM que utilizará la cuenta de consumidor a fin de acceder al catálogo de datos del propietario.
**Para adjuntar la política de AWS Glue a los roles de la cuenta de consumidor**
1. En el panel de navegación de la consola de IAM de la cuenta de consumidor, elija **Roles**.
1. En la página **Roles**, busque el rol al que desee adjuntar la política.
1. Elija **Agregar permisos** y luego **Adjuntar políticas**.
1. Busque la política que acaba de crear.
1. Seleccione la casilla de verificación de la política y, a continuación, elija **Agregar permisos**.
1. Repita los pasos para agregar la política a los demás roles que desee utilizar.
## Paso 3: configurar una sesión y crear una consulta
En Athena para Spark, en la cuenta de solicitante y con el rol especificado, cree una sesión para probar el acceso al [crear un cuaderno](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) o [editar una sesión actual](notebooks-spark-getting-started.md#notebooks-spark-getting-started-editing-session-details). Al [configurar las propiedades de la sesión](notebooks-spark-custom-jar-cfg.md#notebooks-spark-custom-jar-cfg-console), especifique una de las siguientes opciones:
+ **El separador de catálogos de AWS Glue**: con este enfoque, se incluye el ID de cuenta del propietario en las consultas. Utilice este método si va a utilizar la sesión para consultar catálogos de datos de distintos propietarios.
+ **El ID de catálogo de AWS Glue**: con este enfoque, se consulta directamente la base de datos. Este método es más práctico si va a utilizar la sesión para consultar solo el catálogo de datos de un único propietario.
### Uso del separador de catálogos de AWS Glue
Al editar las propiedades de la sesión, agregue lo siguiente:
```
{
"spark.hadoop.aws.glue.catalog.separator": "/"
}
```
Al ejecutar una consulta en una celda, utilice una sintaxis como la del siguiente ejemplo. Tenga en cuenta que en la cláusula `FROM` se requieren el ID de catálogo y el separador antes del nombre de la base de datos.
```
df = spark.sql('SELECT requestip, uri, method, status FROM `999999999999/mydatabase`.cloudfront_logs LIMIT 5')
df.show()
```
### Uso del ID de catálogo de AWS Glue
Al editar las propiedades de la sesión, ingrese la siguiente propiedad. Sustituya *999999999999* por el ID de cuenta del propietario.
```
{
"spark.hadoop.hive.metastore.glue.catalogid": "999999999999"
}
```
Al ejecutar una consulta en una celda, utilice una sintaxis como la siguiente. Tenga en cuenta que en la cláusula `FROM` no se requieren el ID de catálogo y el separador antes del nombre de la base de datos.
```
df = spark.sql('SELECT * FROM mydatabase.cloudfront_logs LIMIT 10')
df.show()
```
## Recursos adicionales
[Configuración del acceso entre cuentas a los catálogos de datos de AWS Glue](security-iam-cross-account-glue-catalog-access.md)
[Administración de los permisos entre cuentas mediante AWS Glue y Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/hybrid-cross-account.html) en la *Guía para desarrolladores de AWS Lake Formation*.
[Configurar el acceso entre cuentas a un AWS Glue Data Catalog compartido mediante Amazon Athena](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-a-shared-aws-glue-data-catalog-using-amazon-athena.html) en *Patrones de recomendaciones de AWS*.
# Descripción de las cuotas de servicio para Athena para Spark
Las *cuotas de servicio*, que también se denominan *límites*, establecen el número máximo de recursos u operaciones de servicio que puede usar en su Cuenta de AWS. Para obtener más información sobre las cuotas de otros servicios de AWS que puede utilizar con Amazon Athena para Spark, consulte [cuotas de servicio de AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html) en la *Referencia general de Amazon Web Services*.
**nota**
Los valores predeterminados son las cuotas iniciales establecidas por AWS, las cuales son independientes del valor real de la cuota aplicada y de la service quota máxima posible. Las nuevas Cuentas de AWS pueden tener cuotas iniciales más bajas que se pueden aumentar con el tiempo. Amazon Athena para Apache Spark supervisa el uso de la cuenta dentro de cada Región de AWS y luego aumenta automáticamente las cuotas en función de su uso. Si sus requisitos superan los límites establecidos, póngase en contacto con el servicio de atención al cliente.
En la siguiente tabla, se enumeran las cuotas de servicio de Amazon Athena para Apache Spark.
****
| Nombre | Predeterminado | Ajustable | Versión | Descripción |
| --- | --- | --- | --- | --- |
| Simultaneidad de DPU de Apache Spark | 160 | No | Versión 3 de PySpark | El número máximo de unidades de procesamiento de datos (DPU) que se pueden consumir de forma simultánea para los cálculos de Apache Spark de una sola cuenta en la Región de AWS actual. Una DPU es una medida relativa de la potencia de procesamiento que consta de 4 vCPU de capacidad de cómputo y 16 GB de memoria. |
| Simultaneidad de DPU en una sesión de Apache Spark | 60 | No | Versión 3 de PySpark | El número máximo de DPU que se pueden consumir de forma simultánea para un cálculo de Apache Spark en una sesión. |
| DPU bajo demanda | 4 | No | Apache Spark versión 3.5 | El número máximo de unidades de procesamiento de datos (DPU) que se pueden consumir de forma simultánea para las sesiones interactivas de Apache Spark en la Región de AWS actual. |
# Uso de las API de Athena Spark
**nota**
Los cuadernos de Athena y las API de cálculo están disponibles en la versión de lanzamiento del motor de Pyspark, versión 3. Los cuadernos y las API de cálculos no son compatibles con la versión de lanzamiento de Apache Spark, versión 3.5.
La siguiente lista contiene vínculos de referencia a las acciones de la API de cuadernos de Athena. Para ver las estructuras de datos y otras acciones de la API de Athena, consulte [https://docs.aws.amazon.com/athena/latest/APIReference/](https://docs.aws.amazon.com/athena/latest/APIReference/).
+ [CreateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreateNotebook.html)
+ [CreatePresignedNotebookUrl](https://docs.aws.amazon.com/athena/latest/APIReference/API_CreatePresignedNotebookUrl.html)
+ [DeleteNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_DeleteNotebook.html)
+ [ExportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ExportNotebook.html)
+ [GetCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecution.html)
+ [GetCalculationExecutionCode](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecutionCode.html)
+ [GetCalculationExecutionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetCalculationExecutionStatus.html)
+ [GetNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetNotebookMetadata.html)
+ [GetSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetSession.html)
+ [GetSessionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_GetSessionStatus.html)
+ [ImportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ImportNotebook.html)
+ [ListApplicationDPUSizes](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListApplicationDPUSizes.html)
+ [ListCalculationExecutions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListCalculationExecutions.html)
+ [ListExecutors](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListExecutors.html)
+ [ListNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListNotebookMetadata.html)
+ [ListNotebookSessions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListNotebookSessions.html)
+ [ListSessions](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListSessions.html)
+ [StartCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartCalculationExecution.html)
+ [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html)
+ [StopCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StopCalculationExecution.html)
+ [TerminateSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_TerminateSession.html)
+ [UpdateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html)
+ [UpdateNotebookMetadata](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebookMetadata.html)
# Solución de problemas de Athena para Spark
Utilice la siguiente información para solucionar los problemas que pueda tener al utilizar cuadernos y sesiones en Athena.
**Topics**
+ [Más información sobre los problemas conocidos en Athena para Spark](notebooks-spark-known-issues.md)
+ [Solución de problemas de grupos de trabajo habilitados para Spark](notebooks-spark-troubleshooting-workgroups.md)
+ [Uso de la instrucción EXPLAIN de Spark para solucionar problemas de Spark SQL](notebooks-spark-troubleshooting-explain.md)
+ [Registro de eventos de aplicaciones de Spark en Athena](notebooks-spark-logging.md)
+ [Utilice CloudTrail para solucionar problemas con las llamadas a la API de cuadernos de Athena](notebooks-spark-troubleshooting-cloudtrail.md)
+ [Superación del límite de tamaño para bloques de código de 68 000](notebooks-spark-troubleshooting-code-block-size-limit.md)
+ [Solución de errores de sesión](notebooks-spark-troubleshooting-sessions.md)
+ [Solución de errores de tabla](notebooks-spark-troubleshooting-tables.md)
+ [Cómo obtener ayuda](notebooks-spark-troubleshooting-support.md)
# Más información sobre los problemas conocidos en Athena para Spark
Esta página documenta algunos de los problemas conocidos de Athena para Apache Spark.
## Excepción de argumento ilegal al crear una tabla
Aunque Spark no permite crear bases de datos con una propiedad de ubicación vacía, las bases de datos en AWS Glue pueden tener una propiedad `LOCATION` vacía si se crean fuera de Spark.
Si crea una tabla y especifica una base de datos de AWS Glue que tiene un campo `LOCATION` vacío, puede producirse una excepción como la siguiente: IllegalArgumentException: Cannot create a path from an empty string. (IllegalArgumentException: no se puede crear una ruta a partir de una cadena vacía).
Por ejemplo, el siguiente comando lanza una excepción si la base de datos predeterminada en AWS Glue contiene un campo `LOCATION` vacío:
```
spark.sql("create table testTable (firstName STRING)")
```
**Solución sugerida A**: use AWS Glue para agregar una ubicación a la base de datos que está utilizando.
**Para agregar una ubicación a una base de datos de AWS Glue**
1. Inicie sesión en la Consola de administración de AWS y 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 **Databases** (Bases de datos).
1. En la lista de bases de datos, elija la base de datos que desea editar.
1. En la página de detalles de la base de datos, elija **Edit** (Editar).
1. En la página **Update a database** (Actualizar una base de datos), en **Location** (Ubicación), ingrese una ubicación de Amazon S3.
1. Elija **Update Database** (Actualizar base de datos).
**Solución sugerida B**: use una base de datos de AWS Glue diferente que tenga una ubicación válida y existente en Amazon S3. Por ejemplo, si tiene una base de datos denominada `dbWithLocation`, use el comando `spark.sql("use dbWithLocation")` para cambiar a esa base de datos.
**Solución sugerida C**: cuando use Spark SQL para crear la tabla, especifique un valor para `location`, como en el siguiente ejemplo.
```
spark.sql("create table testTable (firstName STRING)
location 's3://amzn-s3-demo-bucket/'").
```
**Solución sugerida D**: si especificó una ubicación al crear la tabla, pero el problema persiste, asegúrese de que la ruta de Amazon S3 que proporcione tenga una barra diagonal al final. Por ejemplo, el siguiente comando lanza una excepción de argumento ilegal:
```
spark.sql("create table testTable (firstName STRING)
location 's3://amzn-s3-demo-bucket'")
```
Para corregir este problema, agregue una barra al final de la ubicación (por ejemplo, `'s3://amzn-s3-demo-bucket/'`).
## Base de datos creada en una ubicación de grupo de trabajo
Si usa un comando como `spark.sql('create database db')` para crear una base de datos y no especifica una ubicación para la base de datos, Athena crea un subdirectorio en la ubicación de su grupo de trabajo y usa esa ubicación para la base de datos recién creada.
## Problemas con las tablas administradas por Hive en la base de datos de AWS Glue predeterminada
Si la propiedad `Location` de su base de datos predeterminada en AWS Glue no está vacía y especifica una ubicación válida en Amazon S3, y utiliza Athena para Spark a fin de crear una tabla administrada por Hive en su base de datos de AWS Glue predeterminada, los datos se escriben en la ubicación de Amazon S3 especificada en su grupo de trabajo de Athena para Spark en lugar de en la ubicación especificada en la base de datos de AWS Glue.
Este problema se debe a la forma en que Apache Hive gestiona su base de datos predeterminada. Apache Hive crea datos de tablas en la ubicación raíz del almacén de Hive, que puede ser diferente de la ubicación real predeterminada de la base de datos.
Cuando utiliza Athena para Spark a fin de crear una tabla administrada por Hive en la base de datos predeterminada de AWS Glue, los metadatos de la tabla de AWS Glue pueden apuntar a dos ubicaciones diferentes. Esto puede provocar un comportamiento inesperado al intentar realizar una operación `INSERT` o `DROP TABLE`.
Los pasos para reproducir el problema son los siguientes:
1. En Athena para Spark, utilice uno de los siguientes métodos para crear o guardar una tabla administrada por Hive:
+ Una instrucción SQL como `CREATE TABLE $tableName`.
+ Un comando de PySpark como `df.write.mode("overwrite").saveAsTable($tableName)` que no especifica la opción `path` en la API de Dataframe.
En este punto, es posible que la consola de AWS Glue muestre una ubicación incorrecta en Amazon S3 para la tabla.
1. En Athena para Spark, utilice la instrucción `DROP TABLE $table_name` para eliminar la tabla que ha creado.
1. Tras ejecutar la instrucción `DROP TABLE`, observará que los archivos subyacentes de Amazon S3 siguen presentes.
Para resolver este problema, siga uno de estos pasos:
**Solución A**: utilice una base de datos de AWS Glue diferente al crear tablas administradas por Hive.
**Solución B**: especifique una ubicación vacía para la base de datos predeterminada en AWS Glue. A continuación, cree las tablas administradas en la base de datos predeterminada.
## Incompatibilidad de formatos de archivos CSV y JSON entre Athena para Spark y Athena SQL
Debido a un problema conocido con el código abierto de Spark, al crear una tabla en Athena para Spark con datos CSV o JSON, es posible que la tabla no se pueda leer desde Athena SQL y viceversa.
Por ejemplo, puede crear una tabla en Athena para Spark de una de las siguientes maneras:
+ Con la siguiente sintaxis `USING csv`:
```
spark.sql('''CREATE EXTERNAL TABLE $tableName (
$colName1 $colType1,
$colName2 $colType2,
$colName3 $colType3)
USING csv
PARTITIONED BY ($colName1)
LOCATION $s3_location''')
```
+ Con la siguiente sintaxis de la API de [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html):
```
df.write.format('csv').saveAsTable($table_name)
```
Debido a un problema conocido con el código abierto de Spark, es posible que las consultas de Athena SQL en las tablas resultantes no se realicen correctamente.
**Solución sugerida**: intente crear la tabla en Athena para Spark con la sintaxis de Apache Hive. Para obtener más información, consulte [CREATE HIVEFORMAT TABLE](https://spark.apache.org/docs/latest/sql-ref-syntax-ddl-create-table-hiveformat.html) (Crear tabla con formato Hive) en la documentación de Apache Spark.
# Solución de problemas de grupos de trabajo habilitados para Spark
Utilice la siguiente información para solucionar problemas de grupos de trabajo habilitados para Spark en Athena.
## La sesión deja de responder cuando se usa un rol de IAM existente
Si no se creó un nuevo rol `AWSAthenaSparkExecutionRole` para su grupo de trabajo habilitado para Spark y, en su lugar, se actualizó o eligió un rol de IAM existente, es posible que su sesión deje de responder. En este caso, puede que necesite agregar las siguientes políticas de confianza y permisos al rol de ejecución de su grupo de trabajo habilitado para Spark.
A continuación, se muestra un ejemplo de una política de confianza. La política incluye una comprobación de suplente confuso para el rol de ejecución. Sustituya los valores de `111122223333`, `aws-region` y `workgroup-name` por el ID de Cuenta de AWS, la Región de AWS y el grupo de trabajo que esté utilizando.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "athena.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:athena:us-east-1:111122223333:workgroup/workgroup-name"
}
}
}
]
}
```
------
Agregue una política de permisos como la siguiente política predeterminada para grupos de trabajo habilitados para cuadernos. Modifique las ubicaciones de Amazon S3 y los ID de Cuenta de AWS de los marcadores de posición para que se correspondan con los que está utilizando. Sustituya los valores de `amzn-s3-demo-bucket`, `aws-region`, `111122223333` y `workgroup-name` por el bucket de Amazon S3, la Región de AWS, el ID de Cuenta de AWS y el grupo de trabajo que esté utilizando.
------
#### [ JSON ]
****
```
{ "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [
"s3:PutObject", "s3:ListBucket", "s3:DeleteObject", "s3:GetObject" ], "Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Effect": "Allow",
"Action": [ "athena:GetWorkGroup", "athena:CreatePresignedNotebookUrl",
"athena:TerminateSession", "athena:GetSession", "athena:GetSessionStatus",
"athena:ListSessions", "athena:StartCalculationExecution", "athena:GetCalculationExecutionCode",
"athena:StopCalculationExecution", "athena:ListCalculationExecutions",
"athena:GetCalculationExecution", "athena:GetCalculationExecutionStatus",
"athena:ListExecutors", "athena:ExportNotebook", "athena:UpdateNotebook" ], "Resource":
"arn:aws:athena:us-east-1:111122223333:workgroup/workgroup-name"
}, { "Effect": "Allow", "Action": [ "logs:CreateLogStream", "logs:DescribeLogStreams",
"logs:CreateLogGroup", "logs:PutLogEvents" ], "Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-athena:*",
"arn:aws:logs:us-east-1:111122223333:log-group:/aws-athena*:log-stream:*"
] }, { "Effect": "Allow", "Action": "logs:DescribeLogGroups", "Resource":
"arn:aws:logs:us-east-1:111122223333:log-group:*"
}, { "Effect": "Allow", "Action": [ "cloudwatch:PutMetricData" ], "Resource": "*", "Condition":
{ "StringEquals": { "cloudwatch:namespace": "AmazonAthenaForApacheSpark" } } } ] }
```
------
# Uso de la instrucción EXPLAIN de Spark para solucionar problemas de Spark SQL
Puede usar la instrucción `EXPLAIN` de Spark con Spark SQL para solucionar problemas de su código Spark. Los siguientes ejemplos de código y salida muestran este uso.
**Example – Instrucción SELECT de Spark**
```
spark.sql("select * from select_taxi_table").explain(True)
```
**Output**
```
Calculation started (calculation_id=20c1ebd0-1ccf-ef14-db35-7c1844876a7e) in
(session=24c1ebcb-57a8-861e-1023-736f5ae55386).
Checking calculation status...
Calculation completed.
== Parsed Logical Plan ==
'Project [*]
+- 'UnresolvedRelation [select_taxi_table], [], false
== Analyzed Logical Plan ==
VendorID: bigint, passenger_count: bigint, count: bigint
Project [VendorID#202L, passenger_count#203L, count#204L]
+- SubqueryAlias spark_catalog.spark_demo_database.select_taxi_table
+- Relation spark_demo_database.select_taxi_table[VendorID#202L,
passenger_count#203L,count#204L] csv
== Optimized Logical Plan ==
Relation spark_demo_database.select_taxi_table[VendorID#202L,
passenger_count#203L,count#204L] csv
== Physical Plan ==
FileScan csv spark_demo_database.select_taxi_table[VendorID#202L,
passenger_count#203L,count#204L]
Batched: false, DataFilters: [], Format: CSV,
Location: InMemoryFileIndex(1 paths)
[s3://amzn-s3-demo-bucket/select_taxi],
PartitionFilters: [], PushedFilters: [],
ReadSchema: struct
```
**Example – Marco de datos de Spark**
En el siguiente ejemplo de código, se muestra cómo utilizar `EXPLAIN` con un marco de datos de Spark.
```
taxi1_df=taxi_df.groupBy("VendorID", "passenger_count").count()
taxi1_df.explain("extended")
```
**Output**
```
Calculation started (calculation_id=d2c1ebd1-f9f0-db25-8477-3effc001b309) in
(session=24c1ebcb-57a8-861e-1023-736f5ae55386).
Checking calculation status...
Calculation completed.
== Parsed Logical Plan ==
'Aggregate ['VendorID, 'passenger_count],
['VendorID, 'passenger_count, count(1) AS count#321L]
+- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51,
passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55,
PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59,
extra#60,mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64,
total_amount#65,congestion_surcharge#66,airport_fee#67] parquet
== Analyzed Logical Plan ==
VendorID: bigint, passenger_count: bigint, count: bigint
Aggregate [VendorID#49L, passenger_count#52L],
[VendorID#49L, passenger_count#52L, count(1) AS count#321L]
+- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51,
passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55,
PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59,extra#60,
mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64,
total_amount#65,congestion_surcharge#66,airport_fee#67] parquet
== Optimized Logical Plan ==
Aggregate [VendorID#49L, passenger_count#52L],
[VendorID#49L, passenger_count#52L, count(1) AS count#321L]
+- Project [VendorID#49L, passenger_count#52L]
+- Relation [VendorID#49L,tpep_pickup_datetime#50,tpep_dropoff_datetime#51,
passenger_count#52L,trip_distance#53,RatecodeID#54L,store_and_fwd_flag#55,
PULocationID#56L,DOLocationID#57L,payment_type#58L,fare_amount#59,extra#60,
mta_tax#61,tip_amount#62,tolls_amount#63,improvement_surcharge#64,
total_amount#65,congestion_surcharge#66,airport_fee#67] parquet
== Physical Plan ==
AdaptiveSparkPlan isFinalPlan=false
+- HashAggregate(keys=[VendorID#49L, passenger_count#52L], functions=[count(1)],
output=[VendorID#49L, passenger_count#52L, count#321L])
+- Exchange hashpartitioning(VendorID#49L, passenger_count#52L, 1000),
ENSURE_REQUIREMENTS, [id=#531]
+- HashAggregate(keys=[VendorID#49L, passenger_count#52L],
functions=[partial_count(1)], output=[VendorID#49L,
passenger_count#52L, count#326L])
+- FileScan parquet [VendorID#49L,passenger_count#52L] Batched: true,
DataFilters: [], Format: Parquet,
Location: InMemoryFileIndex(1 paths)[s3://amzn-s3-demo-bucket/
notebooks/yellow_tripdata_2016-01.parquet], PartitionFilters: [],
PushedFilters: [],
ReadSchema: struct
```
# Registro de eventos de aplicaciones de Spark en Athena
El editor de cuadernos Athena permite el registro estándar de Jupyter, Spark y Python. Puede usar `df.show()` para mostrar el contenido de PySpark DataFrame o `print("Output")` para mostrar valores en la salida de la celda. Las salidas `stdout`, `stderr` y `results` de los cálculos se escriben en la ubicación del bucket de resultados de la consulta en Amazon S3.
## Registro de eventos de aplicaciones de Spark en Amazon CloudWatch
Sus sesiones de Athena también pueden introducir registros en [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html) en la cuenta que esté utilizando.
### Descripción de los flujos de registro y los grupos de registros
CloudWatch organiza la actividad de registro en flujos de registro y grupos de registros.
**Flujos de registro**: un flujo de registro de CloudWatch es una secuencia de eventos de registro que comparten el mismo origen. Cada fuente independiente de registros en Registros de CloudWatch constituye un flujo de registros independiente.
**Grupos de registro**: en Registros de CloudWatch, un grupo de registros es un grupo de flujos de registro que comparten la misma configuración de retención, supervisión y control de acceso.
No hay límites en el número de flujos de registros que pueden pertenecer a un grupo de registros.
En Athena, cuando inicia una sesión de cuaderno por primera vez, Athena crea un grupo de registro en CloudWatch que utiliza el nombre de su grupo de trabajo habilitado para Spark, como en el siguiente ejemplo.
```
/aws-athena/workgroup-name
```
Este grupo de registro recibe un flujo de registro por cada ejecutor de su sesión que produzca al menos un evento de registro. Un ejecutor es la unidad de cálculo más pequeña que una sesión de cuaderno puede solicitar a Athena. En CloudWatch, el nombre del flujo de registro comienza con el ID de sesión y el ID de ejecutor.
Para obtener más información sobre los flujos de registro y los grupos de registro de CloudWatch, consulte [Trabajo con grupos de registro y flujos de registro](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) en la guía del usuario de Registros de Amazon CloudWatch.
### Uso de objetos de registro estándar en Athena para Spark
En una sesión de Athena para Spark, puede utilizar los dos objetos de registro estándar globales siguientes para escribir registros en Amazon CloudWatch:
+ **athena\$1user\$1logger**: envía registros únicamente a CloudWatch. Utilice este objeto cuando desee registrar la información de sus aplicaciones de Spark directamente en CloudWatch, como en el siguiente ejemplo.
```
athena_user_logger.info("CloudWatch log line.")
```
El ejemplo escribe un evento de registro en CloudWatch como el siguiente:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: CloudWatch log line.
```
+ **athena\$1shared\$1logger**: envía el mismo registro tanto a CloudWatch como a AWS para fines de soporte. Puede utilizar este objeto para compartir registros con los equipos de servicio de AWS a fin de solucionar problemas, como en el siguiente ejemplo.
```
athena_shared_logger.info("Customer debug line.")
var = [...some variable holding customer data...]
athena_shared_logger.info(var)
```
El ejemplo registra la línea `debug` y el valor de la variable `var` en Registros de CloudWatch y envía una copia de cada línea a Soporte.
**nota**
Por motivos de privacidad, su código de cálculo y sus resultados no se comparten con AWS. Asegúrese de que sus llamadas a `athena_shared_logger` escriban solo la información para la que desea que sea visible Soporte.
Los registradores proporcionados escriben eventos a través de [Apache Log4j](https://logging.apache.org/log4j/) y heredan los niveles de registro de esta interfaz. Los valores posibles del nivel de registro son `DEBUG`, `ERROR`, `FATAL`, `INFO` y `WARN` o `WARNING`. Puede utilizar la función con nombre correspondiente en el registrador para generar estos valores.
**nota**
No vuelva a unir los nombres `athena_user_logger` ni `athena_shared_logger`. Al hacerlo, los objetos de registro no podrán escribir en CloudWatch durante el resto de la sesión.
### Ejemplo: registro de eventos de cuadernos en CloudWatch
El siguiente procedimiento muestra cómo registrar los eventos de cuaderno de Athena en Registros de Amazon CloudWatch.
**Para registrar los eventos de cuaderno de Athena en Registros de Amazon CloudWatch**
1. Siga [Introducción a Apache Spark en Amazon Athena](notebooks-spark-getting-started.md) para crear un grupo de trabajo compatible con Spark en Athena con un nombre único. Este tutorial utiliza el nombre del grupo de trabajo `athena-spark-example`.
1. Siga los pasos que se indican en [Paso 7: crear su propio cuaderno](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) para crear un cuaderno e iniciar una nueva sesión.
1. En el editor de cuadernos de Athena, en una nueva celda de cuaderno, introduzca el siguiente comando:
```
athena_user_logger.info("Hello world.")
```
1. Ejecute la celda.
1. Para recuperar el ID de sesión actual, realice una de las siguientes acciones:
+ Consulte la salida de la celda (por ejemplo, `... session=72c24e73-2c24-8b22-14bd-443bdcd72de4`).
+ En una celda nueva, ejecute el comando [mágico](notebooks-spark-magics.md) `%session_id`.
1. Guarde el ID de sesión.
1. Con la misma Cuenta de AWS que está utilizando para ejecutar la sesión del cuaderno, abra la consola de CloudWatch en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación de la consola de CloudWatch, elija **Log groups** (Grupos de registro).
1. En la lista de grupos de registro, seleccione el grupo de registro que tenga el nombre de su grupo de trabajo de Athena habilitado para Spark, como en el siguiente ejemplo.
```
/aws-athena/athena-spark-example
```
La sección **Log streams** (Flujos de registro) contiene una lista de uno o más enlaces de flujos de registro para el grupo de trabajo. Cada nombre de flujo de registro contiene el ID de sesión, el ID del ejecutor y el UUID único separados por caracteres de barra diagonal.
Por ejemplo, si el ID de sesión es `5ac22d11-9fd8-ded7-6542-0412133d3177` y el ID del ejecutor es `f8c22d11-9fd8-ab13-8aba-c4100bfba7e2`, el nombre del flujo de registro se parece al siguiente ejemplo.
```
5ac22d11-9fd8-ded7-6542-0412133d3177/f8c22d11-9fd8-ab13-8aba-c4100bfba7e2/f012d7cb-cefd-40b1-90b9-67358f003d0b
```
1. Elija el enlace de flujo de registro de su sesión.
1. En la página **Eventos de registro**, consulte la columna **Mensaje**.
El evento de registro de la celda que ejecutó es similar al siguiente:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: Hello world.
```
1. Vuelva al editor de cuadernos de Athena.
1. En una celda nueva, introduzca el siguiente código. El código registra una variable en CloudWatch:
```
x = 6
athena_user_logger.warn(x)
```
1. Ejecute la celda.
1. Vuelva a la página **Log events** (Eventos de registro) de la consola de CloudWatch para ver el mismo flujo de registro.
1. El flujo de registro ahora contiene una entrada de eventos de registro con un mensaje como el siguiente:
```
AthenaForApacheSpark: 2022-01-01 12:00:00,000 WARN builtins: 6
```
# Utilice CloudTrail para solucionar problemas con las llamadas a la API de cuadernos de Athena
Para solucionar problemas con las llamadas a la API de cuadernos, puede examinar los registros de CloudTrail de Athena para buscar anomalías o descubrir las acciones iniciadas por los usuarios. Para obtener información sobre el uso de CloudTrail con Athena, consulte [Registro de las llamadas a la API de Amazon Athena con AWS CloudTrail](monitor-with-cloudtrail.md).
Los siguientes son ejemplos de entradas de registro de CloudTrail para las API de cuadernos de Athena.
## StartSession
El siguiente ejemplo muestra el registro de CloudTrail de un evento [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html) de cuaderno.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:alias",
"arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/Admin",
"accountId": "123456789012",
"userName": "Admin"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:41:51Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T17:05:36Z",
"eventSource": "athena.amazonaws.com",
"eventName": "StartSession",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.10",
"userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
"requestParameters": {
"workGroup": "notebook-workgroup",
"engineConfiguration": {
"coordinatorDpuSize": 1,
"maxConcurrentDpus": 20,
"defaultExecutorDpuSize": 1,
"additionalConfigs": {
"NotebookId": "b8f5854b-1042-4b90-9d82-51d3c2fd5c04",
"NotebookIframeParentUrl": "https://us-east-1.console.aws.amazon.com"
}
},
"notebookVersion": "KeplerJupyter-1.x",
"sessionIdleTimeoutInMinutes": 20,
"clientRequestToken": "d646ff46-32d2-42f0-94d1-d060ec3e5d78"
},
"responseElements": {
"sessionId": "a2c1ebba-ad01-865f-ed2d-a142b7451f7e",
"state": "CREATED"
},
"requestID": "d646ff46-32d2-42f0-94d1-d060ec3e5d78",
"eventID": "b58ce998-eb89-43e9-8d67-d3d8e30561c9",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
},
"sessionCredentialFromConsole": "true"
}
```
## TerminateSession
El siguiente ejemplo muestra el registro de CloudTrail de un evento [TerminateSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_TerminateSession.html) de cuaderno.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:alias",
"arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/Admin",
"accountId": "123456789012",
"userName": "Admin"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:41:51Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T17:21:03Z",
"eventSource": "athena.amazonaws.com",
"eventName": "TerminateSession",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.11",
"userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
"requestParameters": {
"sessionId": "a2c1ebba-ad01-865f-ed2d-a142b7451f7e"
},
"responseElements": {
"state": "TERMINATING"
},
"requestID": "438ea37e-b704-4cb3-9a76-391997cf42ee",
"eventID": "49026c5a-bf58-4cdb-86ca-978e711ad238",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
},
"sessionCredentialFromConsole": "true"
}
```
## ImportNotebook
El siguiente ejemplo muestra el registro de CloudTrail de un evento [ImportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ImportNotebook.html) de cuaderno. Por motivos de seguridad, parte del contenido está oculto.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:alias",
"arn": "arn:aws:sts::123456789012:assumed-role/Admin/alias",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/Admin",
"accountId": "123456789012",
"userName": "Admin"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:41:51Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T17:08:54Z",
"eventSource": "athena.amazonaws.com",
"eventName": "ImportNotebook",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.12",
"userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/106.0.0.0 Safari/537.36",
"requestParameters": {
"workGroup": "notebook-workgroup",
"name": "example-notebook-name",
"payload": "HIDDEN_FOR_SECURITY_REASONS",
"type": "IPYNB",
"contentMD5": "HIDDEN_FOR_SECURITY_REASONS"
},
"responseElements": {
"notebookId": "05f6225d-bdcc-4935-bc25-a8e19434652d"
},
"requestID": "813e777f-6dac-41f4-82a7-e99b7b33f319",
"eventID": "4abec837-143b-4458-9c1f-fa9fb88ab69b",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
},
"sessionCredentialFromConsole": "true"
}
```
## UpdateNotebook
El siguiente ejemplo muestra el registro de CloudTrail de un evento [UpdateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html) de cuaderno. Por motivos de seguridad, parte del contenido está oculto.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"arn": "arn:aws:sts::123456789012:assumed-role/AWSAthenaSparkExecutionRole-om0yj71w5l/AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/service-role/AWSAthenaSparkExecutionRole-om0yj71w5l",
"accountId": "123456789012",
"userName": "AWSAthenaSparkExecutionRole-om0yj71w5l"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:48:06Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T16:52:22Z",
"eventSource": "athena.amazonaws.com",
"eventName": "UpdateNotebook",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.13",
"userAgent": "Boto3/1.24.84 Python/3.8.14 Linux/4.14.225-175.364.amzn2.aarch64 Botocore/1.27.84",
"requestParameters": {
"notebookId": "c87553ff-e740-44b5-884f-a70e575e08b9",
"payload": "HIDDEN_FOR_SECURITY_REASONS",
"type": "IPYNB",
"contentMD5": "HIDDEN_FOR_SECURITY_REASONS",
"sessionId": "9cc1ebb2-aac5-b1ca-8247-5d827bd8232f"
},
"responseElements": null,
"requestID": "baaba1d2-f73d-4df1-a82b-71501e7374f1",
"eventID": "745cdd6f-645d-4250-8831-d0ffd2fe3847",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
}
}
```
## StartCalculationExecution
El siguiente ejemplo muestra el registro de CloudTrail de un evento [StartCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartCalculationExecution.html) de cuaderno. Por motivos de seguridad, parte del contenido está oculto.
```
{
"eventVersion": "1.08",
"userIdentity": {
"type": "AssumedRole",
"principalId": "EXAMPLE_PRINCIPAL_ID:AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"arn": "arn:aws:sts::123456789012:assumed-role/AWSAthenaSparkExecutionRole-om0yj71w5l/AthenaExecutor-9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"accountId": "123456789012",
"accessKeyId": "EXAMPLE_KEY_ID",
"sessionContext": {
"sessionIssuer": {
"type": "Role",
"principalId": "EXAMPLE_PRINCIPAL_ID",
"arn": "arn:aws:iam::123456789012:role/service-role/AWSAthenaSparkExecutionRole-om0yj71w5l",
"accountId": "123456789012",
"userName": "AWSAthenaSparkExecutionRole-om0yj71w5l"
},
"webIdFederationData": {},
"attributes": {
"creationDate": "2022-10-14T16:48:06Z",
"mfaAuthenticated": "false"
}
}
},
"eventTime": "2022-10-14T16:52:37Z",
"eventSource": "athena.amazonaws.com",
"eventName": "StartCalculationExecution",
"awsRegion": "us-east-1",
"sourceIPAddress": "203.0.113.14",
"userAgent": "Boto3/1.24.84 Python/3.8.14 Linux/4.14.225-175.364.amzn2.aarch64 Botocore/1.27.84",
"requestParameters": {
"sessionId": "9cc1ebb2-aac5-b1ca-8247-5d827bd8232f",
"description": "Calculation started via Jupyter notebook",
"codeBlock": "HIDDEN_FOR_SECURITY_REASONS",
"clientRequestToken": "0111cd63-4fd0-4ad8-a738-fd350115fc21"
},
"responseElements": {
"calculationExecutionId": "82c1ebb4-bd08-e4c3-5631-a662fb2ff2c5",
"state": "CREATING"
},
"requestID": "1a107461-3f1b-481e-b8a2-7fbd524e2373",
"eventID": "b74dbd00-e839-4bd1-a1da-b75fbc70ab9a",
"readOnly": false,
"eventType": "AwsApiCall",
"managementEvent": true,
"recipientAccountId": "123456789012",
"eventCategory": "Management",
"tlsDetails": {
"tlsVersion": "TLSv1.2",
"cipherSuite": "ECDHE-RSA-AES128-GCM-SHA256",
"clientProvidedHostHeader": "athena.us-east-1.amazonaws.com"
}
}
```
# Superación del límite de tamaño para bloques de código de 68 000
Athena para Spark tiene un límite de tamaño para bloques de código de cálculo conocido de 68 000 caracteres. Cuando ejecuta un cálculo con un bloque de código por encima de este límite, puede recibir el siguiente mensaje de error:
“…” en “CodeBlock” no cumplió con la restricción: la longitud debe ser menor o igual a 68 000
La siguiente imagen muestra este error en el editor de cuadernos de la consola de Athena.
![\[Mensaje de error de tamaño del bloque de código en el editor de cuadernos de Athena\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-troubleshooting-code-block-size-limit-1.png)
El mismo error puede producirse cuando se utiliza la AWS CLI para ejecutar un cálculo que tiene un bloque de código grande, como en el siguiente ejemplo.
```
aws athena start-calculation-execution \
--session-id "{SESSION_ID}" \
--description "{SESSION_DESCRIPTION}" \
--code-block "{LARGE_CODE_BLOCK}"
```
El comando muestra el siguiente mensaje de error:
*\$1LARGE\$1CODE\$1BLOCK\$1* at 'codeBlock' failed to satisfy constraint: Member must have length less than or equal to 68000 (\$1LARGE\$1CODE\$1BLOCK\$1 en “codeBlock” no cumplió con la restricción: la longitud del miembro debe ser menor o igual a 68 000).
## Solución
Para solucionar este problema, cargue el archivo que contiene su código de cálculo o consulta a Amazon S3. A continuación, utilice boto3 para leer el archivo y ejecutar el código o SQL.
En los siguientes ejemplos se supone que ya ha cargado el archivo que contiene la consulta SQL o el código Python en Amazon S3.
### Ejemplo de SQL
El siguiente ejemplo de código lee el archivo `large_sql_query.sql` de un bucket de Amazon S3 y luego ejecuta la consulta grande que contiene el archivo.
```
s3 = boto3.resource('s3')
def read_s3_content(bucket_name, key):
response = s3.Object(bucket_name, key).get()
return response['Body'].read()
# SQL
sql = read_s3_content('bucket_name', 'large_sql_query.sql')
df = spark.sql(sql)
```
### Ejemplo de PySpark
El siguiente ejemplo de código lee el archivo `large_py_spark.py` de Amazon S3 y luego ejecuta el bloque de código grande que se encuentra en el archivo.
```
s3 = boto3.resource('s3')
def read_s3_content(bucket_name, key):
response = s3.Object(bucket_name, key).get()
return response['Body'].read()
# PySpark
py_spark_code = read_s3_content('bucket_name', 'large_py_spark.py')
exec(py_spark_code)
```
# Solución de errores de sesión
Utilice la información de esta sesión para solucionar problemas de sesión.
Cuando se produce un error de configuración personalizada durante el inicio de una sesión, la consola de Athena para Spark muestra un mensaje de error. Para solucionar los errores de inicio de sesión, puede comprobar los cambios de estado de la sesión o la información de registro.
## Visualización de la información sobre los cambios de estado de la sesión
Puede obtener detalles sobre un cambio de estado de sesión en el editor de cuadernos de Athena o en la API de Athena.
**Para visualizar la información del estado de la sesión en la consola de Athena**
1. En el editor de cuadernos de Athena, en el menú **Sesión** de la esquina superior derecha, elija **Ver detalles**.
1. Vea la pestaña **Sesión actual**. En la sección **Información de la sesión**, se muestra información como el identificador de la sesión, el grupo de trabajo, el estado y el motivo del cambio de estado.
En la siguiente de captura de pantalla de ejemplo, se muestra información en la sección **Motivo del cambio de estado** del cuadro de diálogo **Información de la sesión** sobre un error de sesión de Spark en Athena.
![\[Visualización de información de cambio de estado de la sesión en la consola de Athena para Spark.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/notebooks-spark-custom-jar-cfg-1.jpeg)
**Para visualizar la información del estado de la sesión con la API de Athena**
+ En la API de Athena, puede encontrar información sobre el cambio de estado de la sesión en el campo `StateChangeReason` del objeto [SessionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_SessionStatus.html).
**nota**
Tras detener manualmente una sesión, o si la sesión se detiene tras un tiempo de espera de inactividad (el valor predeterminado es de 20 minutos), el valor de **StateChangeReason** cambia a Se cerró la sesión por solicitud.
## Uso del registro para solucionar los errores de inicio de sesión
[Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) registra los errores de configuración personalizados que se producen durante el inicio de una sesión. En sus registros de CloudWatch, busque los mensajes de error de `AthenaSparkSessionErrorLogger` para solucionar un error de inicio de sesión.
Para obtener más información sobre el registro de Spark, consulte [Registro de eventos de aplicaciones de Spark en Athena](notebooks-spark-logging.md).
Para obtener más información sobre cómo solucionar problemas con las sesiones en Athena para Spark, consulte [Solución de errores de sesión](#notebooks-spark-troubleshooting-sessions).
## Problemas específicos de sesión
Utilice la información de esta sección para resolver algunos problemas específicos de sesión.
### Sesión en estado incorrecto
Si recibe el mensaje de error Session in unhealthy state. Please create a new session (Sesión en estado incorrecto. Cree una nueva sesión), finalice la sesión existente y cree una nueva.
### No se pudo establecer una conexión con el servidor de cuadernos
Al abrir un cuaderno, puede aparecer el siguiente mensaje de error:
```
A connection to the notebook server could not be established.
The notebook will continue trying to reconnect.
Check your network connection or notebook server configuration.
```
#### Causa
Cuando Athena abre un cuaderno, Athena crea una sesión y se conecta al cuaderno a través de una URL de cuaderno previamente firmada. La conexión al cuaderno utiliza el protocolo WSS ([WebSocket Secure](https://en.wikipedia.org/wiki/WebSocket)).
Este error puede producirse por las siguientes razones:
+ Un firewall local (por ejemplo, un firewall para toda la empresa) bloquea el tráfico de WSS.
+ El software antivirus o el proxy de su equipo local bloquea la conexión WSS.
#### Solución
Supongamos que tiene una conexión WSS en la región `us-east-1` como la siguiente:
```
wss://94c2bcdf-66f9-4d17-9da6-7e7338060183.analytics-gateway.us-east-1.amazonaws.com/
api/kernels/33c78c82-b8d2-4631-bd22-1565dc6ec152/channels?session_id=
7f96a3a048ab4917b6376895ea8d7535
```
Para resolver el error, utilice una de las siguientes estrategias.
+ Utilice la sintaxis del patrón comodín para permitir listar el tráfico de WSS en el puerto `443` a través de las Regiones de AWS y las Cuentas de AWS.
```
wss://*amazonaws.com
```
+ Utilice la sintaxis del patrón comodín para permitir listar el tráfico de WSS en el puerto `443` de una Región de AWS y a través de las Cuentas de AWS de la Región de AWS que especifique. El siguiente ejemplo utiliza `us-east-1`.
```
wss://*analytics-gateway.us-east-1.amazonaws.com
```
# Solución de errores de tabla
Utilice la información de esta sección para resolver errores de tabla de Athena para Spark.
## No se puede crear un error de ruta al crear una tabla
**Mensaje de error**: IllegalArgumentException: Cannot create a path from an empty string. (IllegalArgumentException: no se puede crear una ruta a partir de una cadena vacía).
**Causa**: este error puede producirse cuando usa Apache Spark en Athena para crear una tabla en una base de datos de AWS Glue y la base de datos tiene una propiedad `LOCATION` vacía.
**Solución sugerida**: para obtener más información y soluciones, consulte [Excepción de argumento ilegal al crear una tabla](notebooks-spark-known-issues.md#notebooks-spark-known-issues-illegal-argument-exception).
## AccessDeniedException al consultar tablas de AWS Glue
**Mensaje de error**: pyspark.sql.utils.AnalysisException: Unable to verify existence of default database: com.amazonaws.services.glue.model.AccessDeniedException: User: arn:aws:sts::*aws-account-id*:assumed-role/AWSAthenaSparkExecutionRole-*unique-identifier*/AthenaExecutor-*unique-identifier* is not authorized to perform: glue:GetDatabase on resource: arn:aws:glue:*aws-region*:*aws-account-id*:catalog because no identity-based policy allows the glue:GetDatabase action (Service: AWSGlue; Status Code: 400; Error Code: AccessDeniedException; Request ID: *request-id*; Proxy: null) (pyspark.sql.utils.AnalysisException: no se puede verificar la existencia de la base de datos predeterminada: com.amazonaws.services.glue.model.AccessDeniedException: El usuario: arn:aws:sts::aws-account-id:assumed-role/AWSAthenaSparkExecutionRole-unique-identifier/AthenaExecutor-unique-identifier no está autorizado a realizar: glue:GetDatabase en el recurso: arn:aws:glue:aws-region:aws-account-id:catalog porque ninguna política basada en identidades permite la acción glue:GetDatabase [Servicio: AWSGlue; Código de estado: 400; Código de error: AccessDeniedException; ID de solicitud: request-id; Proxy: null]).
**Causa**: al rol de ejecución de su grupo de trabajo habilitado para Spark le faltan permisos para acceder a los recursos de AWS Glue.
**Solución sugerida**: para resolver este problema, conceda a su rol de ejecución acceso a los recursos de AWS Glue y, a continuación, edite la política de su bucket de Amazon S3 para conceder acceso a su rol de ejecución.
En las siguientes secciones se describen los pasos de manera más detallada.
**Para conceder a su rol de ejecución acceso a los recursos de AWS Glue**
1. Abra la consola de Athena en [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home).
1. Si el panel de navegación de la consola no está visible, elija el menú de expansión de la izquierda.
![\[Elija el menú de expansión.\]](http://docs.aws.amazon.com/es_es/athena/latest/ug/images/nav-pane-expansion.png)
1. En el panel de navegación de la consola de Athena, elija **Grupos de trabajo**.
1. En la página **Grupos de trabajo**, elija el enlace del grupo de trabajo que quiere ver.
1. En la página **Overview Details** (Detalles de información general) del grupo de trabajo, elija el enlace **Role ARN** (ARN del rol). El enlace abre el rol de ejecución de Spark en la consola de IAM.
1. En la sección **Permissions policies** (Políticas de permisos), seleccione el nombre de la política de rol vinculada.
1. Elija **Edit policy** (Editar política) y, a continuación, elija **JSON**.
1. Agregue acceso a AWS Glue al rol. Normalmente, se agregan permisos para las acciones `glue:GetDatabase` y `glue:GetTable`. Para obtener más información sobre la configuración de roles de IAM, consulte [Adición y eliminación de permisos de identidad de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html) en la guía del usuario de IAM.
1. Elija **Revisar política** y, a continuación, elija **Guardar cambios**.
1. Edite la política de su bucket de Amazon S3 para conceder acceso al rol de ejecución. Tenga en cuenta que debe conceder al rol acceso tanto al bucket como a los objetos del bucket. Para conocer los pasos, consulte [Agregar una política de bucket mediante la consola de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-bucket-policy.html) en la guía del usuario de Amazon Simple Storage Service.
# Cómo obtener ayuda
Para obtener ayuda de AWS, seleccione **Support** (Soporte), **Support Center** (Centro de soporte) en la Consola de administración de AWS. Para facilitar su experiencia, tenga la siguiente información disponible:
+ ID de consulta de Athena
+ ID de sesión
+ ID de cálculo