# 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