本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 對 Athena for Spark 進行疑難排解
<a name="notebooks-spark-troubleshooting"></a>

請使用以下資訊，對在 Athena 上使用筆記本和工作階段時可能遇到的問題進行疑難排解。

**Topics**
+ [了解 Athena for Spark 中的已知問題](notebooks-spark-known-issues.md)
+ [對已啟用 Spark 的工作群組進行疑難排解](notebooks-spark-troubleshooting-workgroups.md)
+ [使用 Spark EXPLAIN 陳述式，以對 Spark SQL 進行疑難排解](notebooks-spark-troubleshooting-explain.md)
+ [記錄 Athena 中的 Spark 應用程式事件](notebooks-spark-logging.md)
+ [使用 CloudTrail 對 Athena 筆記本 API 呼叫進行疑難排解](notebooks-spark-troubleshooting-cloudtrail.md)
+ [克服 68k 程式碼區塊大小限制](notebooks-spark-troubleshooting-code-block-size-limit.md)
+ [對工作階段錯誤進行疑難排解](notebooks-spark-troubleshooting-sessions.md)
+ [對資料表錯誤進行疑難排解](notebooks-spark-troubleshooting-tables.md)
+ [取得支援](notebooks-spark-troubleshooting-support.md)

# 了解 Athena for Spark 中的已知問題
<a name="notebooks-spark-known-issues"></a>

本頁說明了 Athena for Apache Spark 中的一些已知問題。

## 建立資料表時的非法引數例外狀況
<a name="notebooks-spark-known-issues-illegal-argument-exception"></a>

雖然 Spark 不允許使用空的位置屬性建立資料庫，但如果在 Spark 外部建立資料庫，則 中的資料庫 AWS Glue 可以有空`LOCATION`屬性。

如果您建立資料表並指定具有空白`LOCATION`欄位的 AWS Glue 資料庫，可能會發生類似下列的例外狀況：IllegalArgumentException：無法從空白字串建立路徑。

例如，如果 AWS Glue 中的預設資料庫包含空 `LOCATION` 欄位，則下列命令會擲出例外狀況：

```
spark.sql("create table testTable (firstName STRING)")
```

**建議的解決方案 A** – 使用 AWS Glue 將位置新增至您正在使用的資料庫。

**將位置新增至 AWS Glue 資料庫**

1. 登入 AWS 管理主控台 並在 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 開啟 AWS Glue 主控台。

1. 在導覽窗格中，選擇 **Databases** (資料庫)。

1. 在資料庫清單中，選擇您要編輯的資料庫。

1. 在資料庫的詳細資訊頁面上，選擇 **Edit** (編輯)。

1. 在 **Update a database** (更新資料庫) 頁面上，針對 **Location** (位置)，輸入 Amazon S3 位置。

1. 選擇 **Update Database** (更新資料庫)。

**Suggested solution B** (建議的解決方案 B) – 使用在 Amazon S3 中具有現有有效位置的不同 AWS Glue 資料庫。例如，如果您有名為 `dbWithLocation` 的資料庫，請使用命令 `spark.sql("use dbWithLocation")` 切換至該資料庫。

**Suggested solution C** (建議的解決方案 C) – 當您使用 Spark SQL 建立資料表時，請指定 `location` 的值，如下列範例所示。

```
spark.sql("create table testTable (firstName STRING) 
       location 's3://amzn-s3-demo-bucket/'").
```

**Suggested solution D** (建議的解決放哪 D) – 如果您在建立資料表時指定了位置，但仍然發生該問題，則請確定您提供的 Amazon S3 路徑具有尾隨正斜線。例如，下列命令會擲出非法引數例外狀況：

```
spark.sql("create table testTable (firstName STRING) 
       location 's3://amzn-s3-demo-bucket'")
```

若要更正此問題，請在位置新增尾隨斜線 (例如，`'s3://amzn-s3-demo-bucket/'`)。

## 在工作群組位置中建立的資料庫
<a name="notebooks-spark-known-issues-database-created-in-a-workgroup-location"></a>

如果您使用類似 `spark.sql('create database db')` 的命令建立資料庫，但未指定資料庫的位置，則 Athena 會在您的工作群組位置中建立子目錄，並將該位置用於新建立的資料庫。

## AWS Glue 預設資料庫中 Hive 受管資料表的問題
<a name="notebooks-spark-known-issues-managed-tables"></a>

如果在 中預設資料庫的 `Location` 屬性 AWS Glue 是非空的，並指定 Amazon S3 中的有效位置，而且您使用 Athena for Spark 在 AWS Glue 預設資料庫中建立 Hive 受管資料表，則資料會寫入 Athena Spark 工作群組中指定的 Amazon S3 位置，而不是 AWS Glue 資料庫指定的位置。

因為 Apache Hive 如何處理其預設資料庫，就會發生這個問題。Apache Hive 在 Hive 倉庫根位置中建立資料表，該位置可能與實際的預設資料庫位置不同。

當您使用 Athena for Spark 在預設資料庫下建立 Hive 受管資料表時 AWS Glue， AWS Glue 資料表中繼資料可以指向兩個不同的位置。當您嘗試 `INSERT` 或 `DROP TABLE` 作業時，這可能會導致非預期的行為。

重現問題的步驟如下：

1. 在 Athena for Spark 中，您可以使用下列其中一種方法來建立或儲存 Hive 管理的資料表：
   + 一個 SQL 陳述式 `CREATE TABLE $tableName`
   + 像 `df.write.mode("overwrite").saveAsTable($tableName)` 這樣的 PySpark 命令不會在 Dataframe API 中指定 `path` 選項。

   此時， AWS Glue 主控台可能會在 Amazon S3 中顯示資料表的不正確位置。

1. 在 Athena for Spark 中，您可以使用 `DROP TABLE $table_name` 陳述式刪除您所建立的資料表。

1. 執行 `DROP TABLE` 陳述式之後，您會注意到 Amazon S3 中的基礎檔案仍然存在。

要解決此問題，請執行下列項目之一：

**解決方案 A** – 建立 Hive 受管資料表時使用不同的 AWS Glue 資料庫。

**解決方案 B** – 在 AWS Glue中指定預設資料庫的空白位置。然後，在預設資料庫中建立受管理的資料表。

## Athena for Spark 和 Athena SQL 之間的 CSV 和 JSON 檔案格式不相容
<a name="notebooks-spark-known-issues-csv-and-json-file-format-incompatibility"></a>

由於開放原始碼 Spark 的已知問題，當您在 Athena for Spark 中就 CSV 或 JSON 資料建立資料表時，該資料表可能無法從 Athena SQL 讀取，反之亦然。

例如，您可使用下列其中一種方式在 Athena for Spark 中建立資料表：
+ 使用下列 `USING csv` 語法：

  ```
  spark.sql('''CREATE EXTERNAL TABLE $tableName ( 
  $colName1 $colType1, 
  $colName2 $colType2, 
  $colName3 $colType3) 
  USING csv 
  PARTITIONED BY ($colName1) 
  LOCATION $s3_location''')
  ```
+  使用下列 [DataFrame](https://spark.apache.org/docs/latest/api/python/reference/pyspark.sql/dataframe.html) API 語法：

  ```
  df.write.format('csv').saveAsTable($table_name)
  ```

由於開放原始碼 Spark 的已知問題，Athena SQL 對結果資料表的查詢可能無法成功。

**建議的解決方案** – 嘗試使用 Apache Hive 語法在 Athena for Spark 中建立資料表。如需詳細資訊，請參閱 Apache Spark 文件中的[建立 HIVEFORMAT 資料表](https://spark.apache.org/docs/latest/sql-ref-syntax-ddl-create-table-hiveformat.html)。

# 對已啟用 Spark 的工作群組進行疑難排解
<a name="notebooks-spark-troubleshooting-workgroups"></a>

使用以下資訊，以對 Athena 中已啟用 Spark 的工作群組進行疑難排解。

## 使用現有 IAM 角色時，工作階段會停止回應
<a name="notebooks-spark-troubleshooting-workgroups-existing-role"></a>

如果您沒有為已啟用 Spark 的工作群組建立新的 `AWSAthenaSparkExecutionRole`，而是更新或選擇現有 IAM 角色，則您的工作階段可能會停止回應。在此情況下，您可能需要將下列信任和許可政策新增至已啟用 Spark 的工作群組執行角色。

新增下列信任政策範例。此政策包含執行角色的混淆代理人檢查。以您使用的 `111122223333` `aws-region` `workgroup-name` ID 和工作群組取代 AWS 帳戶 AWS 區域、 和 的值。

------
#### [ 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"
                }
            }
        }
    ]
}
```

------

新增許可政策，如下列已啟用筆記本之工作群組的預設政策。修改預留位置 Amazon S3 位置和 ID，以對應至您正在使用的 Amazon S3 位置和 AWS 帳戶 IDs。將 `amzn-s3-demo-bucket`、`aws-region`、`111122223333` 和 `workgroup-name` 的值取代為您正在使用的 Amazon S3 儲存貯體、 AWS 區域、 AWS 帳戶 ID 和工作群組。

------
#### [ 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" } } } ] }
```

------

# 使用 Spark EXPLAIN 陳述式，以對 Spark SQL 進行疑難排解
<a name="notebooks-spark-troubleshooting-explain"></a>

您可以使用含有 Spark SQL 的 Spark `EXPLAIN` 陳述式，以對您的 Spark 程式碼進行疑難排解。下列程式碼和輸出範例說明了這種用法。

**Example – Spark SELECT 陳述式**  

```
spark.sql("select * from select_taxi_table").explain(True)
```
**輸出**  

```
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<VendorID:bigint,passenger_count:bigint,count:bigint>
```

**Example – Spark 資料框架**  
以下範例顯示如何搭配使用 `EXPLAIN` 與 Spark 資料框架。  

```
taxi1_df=taxi_df.groupBy("VendorID", "passenger_count").count()
taxi1_df.explain("extended")
```
**輸出**  

```
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<VendorID:bigint,passenger_count:bigint>
```

# 記錄 Athena 中的 Spark 應用程式事件
<a name="notebooks-spark-logging"></a>

Athena 筆記本編輯器允許標準的 Jupyter、Spark 和 Python 記錄。您可以使用 `df.show()` 顯示 PySpark DataFrame 內容，或使用 `print("Output")` 在儲存格輸出中顯示值。計算的 `stdout`、`stderr` 和 `results` 輸出會寫入 Amazon S3 中的查詢結果儲存貯體位置。

## 將 Spark 應用程式事件記錄到 Amazon CloudWatch
<a name="notebooks-spark-logging-logging-spark-application-events-to-amazon-cloudwatch"></a>

您的 Athena 工作階段也可以在您使用的帳戶中將日誌寫入 [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html)。

### 了解日誌串流和日誌群組
<a name="notebooks-spark-logging-understanding-log-streams-and-log-groups"></a>

CloudWatch 會將日誌活動整理至日誌串流和日誌群組中。

**Log streams** (日誌串流) –CloudWatch Logs 日誌串流是一系列共用相同來源的日誌事件。CloudWatch Logs 中的每個單獨日誌來源組成單獨的日誌串流。

**Log groups** (日誌群組) – 在 CloudWatch Logs 中，日誌群組是共享相同保留、監控和存取控制設定的日誌串流群組。

可以屬於一個日誌群組的日誌串流數量並沒有限制。

在 Athena 中，當您第一次啟動筆記本工作階段時，Athena 會在 CloudWatch 中建立一個使用已啟用 Spark 之工作群組名稱的日誌群組，如下列範例所示。

```
/aws-athena/workgroup-name
```

此日誌群組會為工作階段中的每個執行器接收日誌串流，其中該日誌串流會產生至少一個日誌事件。執行器是筆記本工作階段可向 Athena 請求的最小運算單位。在 CloudWatch 中，日誌串流的名稱以工作階段 ID 和執行器 ID 開頭。

如需有關 CloudWatch 日誌群組和日誌串流的詳細資訊，請參閱《Amazon CloudWatch Logs 使用者指南》中的[使用日誌群組和日誌串流](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html)。

### 在 Athena for Spark 中，使用標準記錄器物件
<a name="notebooks-spark-logging-using-standard-logger-objects-in-athena-for-spark"></a>

在 Athena for Spark 工作階段中，您可以使用下列兩個全球標準記錄器物件將日誌寫入到 Amazon CloudWatch：
+ **athena\$1user\$1logger** – 僅將日誌傳送到 CloudWatch。當您想要將 Spark 應用程式的資訊直接記錄到 CloudWatch 時，請使用此物件，如下列範例所示。

  ```
  athena_user_logger.info("CloudWatch log line.")
  ```

  此範例會將日誌事件寫入 CloudWatch，如下所示：

  ```
  AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: CloudWatch log line.
  ```
+ **athena\$1shared\$1logger** – 基於 AWS 支援目的，將相同的日誌傳送至 CloudWatch 和 。您可以使用此物件與服務 AWS 團隊共用日誌以進行故障診斷，如下列範例所示。

  ```
  athena_shared_logger.info("Customer debug line.")
  var = [...some variable holding customer data...]
  athena_shared_logger.info(var)
  ```

  此範例會將 `var` 變數的 `debug` 行和值記錄到 CloudWatch Logs，並將每行的複本傳送到 支援。
**注意**  
為了您的隱私權，您的計算程式碼和結果不會與 共用 AWS。確定您的 `athena_shared_logger` 呼叫僅寫入您想要 支援顯示的資訊。

提供的記錄器會透過 [Apache Log4j](https://logging.apache.org/log4j/) 寫入事件，並繼承此介面的日誌記錄層級。可能的日誌層級值為 `DEBUG`、`ERROR`、`FATAL`、`INFO` 和 `WARN` 或 `WARNING`。您可以使用記錄器上相應的具名函數來產生這些值。

**注意**  
請勿重新繫結名稱 `athena_user_logger` 或 `athena_shared_logger`。如此一來，記錄物件無法在剩餘的工作階段寫入 CloudWatch。

### 範例：將筆記本事件記錄到 CloudWatch
<a name="notebooks-spark-logging-example-logging-notebook-events-to-cloudwatch"></a>

以下程序說明如何將 Athena 筆記本事件記錄到 Amazon CloudWatch Logs。

**若要將 Athena 筆記本事件記錄到 Amazon CloudWatch Logs**

1. 請遵循 [開始在 Amazon Athena 上使用 Apache Spark](notebooks-spark-getting-started.md)，以使用唯一名稱在 Athena 中建立已啟用 Spark 的工作群組。本教學課程使用工作群組名稱 `athena-spark-example`。

1. 請遵循 [步驟 7：建立您自己的筆記本](notebooks-spark-getting-started.md#notebooks-spark-getting-started-creating-your-own-notebook) 中的步驟，以建立筆記本並啟動新的工作階段。

1. 在 Athena 筆記本編輯器的新筆記本儲存格中，輸入下列命令：

   ```
   athena_user_logger.info("Hello world.")         
   ```

1. 執行儲存格。

1. 執行下列其中一項動作，擷取目前工作階段 ID：
   + 檢視儲存格輸出 (例如，`... session=72c24e73-2c24-8b22-14bd-443bdcd72de4`)。
   + 在新的儲存格中，執行[魔術](notebooks-spark-magics.md)命令 `%session_id`。

1. 儲存工作階段 ID。

1. 使用與您用來執行筆記本工作階段 AWS 帳戶 相同的 ，開啟位於 https：//[https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 的 CloudWatch 主控台。

1. 在 CloudWatch 主控台導覽窗格中，選擇 **Log groups** (日誌群組)。

1. 在日誌群組清單中，選擇具有已啟用 Spark 之 Athena 工作群組名稱的日誌群組，如下列範例所示。

   ```
   /aws-athena/athena-spark-example
   ```

   **Log streams** (日誌串流) 區段包含工作群組的一或多個日誌串流連結清單。每個日誌串流名稱都包含工作階段 ID、執行器 ID 和由正斜線字元分隔的唯一 UUID。

   例如，如果工作階段 ID 為 `5ac22d11-9fd8-ded7-6542-0412133d3177` 且執行器 ID 為 `f8c22d11-9fd8-ab13-8aba-c4100bfba7e2`，日誌串流的名稱會類似下列範例。

   ```
   5ac22d11-9fd8-ded7-6542-0412133d3177/f8c22d11-9fd8-ab13-8aba-c4100bfba7e2/f012d7cb-cefd-40b1-90b9-67358f003d0b
   ```

1. 選擇工作階段的日誌串流連結。

1. 在 **Log events** (日誌事件) 頁面上，檢視 **Message** (訊息) 資料欄。

   您執行之儲存格的日誌事件類似下列：

   ```
   AthenaForApacheSpark: 2022-01-01 12:00:00,000 INFO builtins: Hello world.
   ```

1. 返回 Athena 筆記本編輯器。

1. 在新的儲存格中，輸入下列程式碼。程式碼會將變數記錄到 CloudWatch：

   ```
   x = 6
   athena_user_logger.warn(x)
   ```

1. 執行儲存格。

1. 返回相同日誌串流的 CloudWatch 主控台 **Log events** (日誌事件) 頁面。

1. 日誌串流現在包含日誌事件項目，其中包含類似下列訊息：

   ```
   AthenaForApacheSpark: 2022-01-01 12:00:00,000 WARN builtins: 6
   ```

# 使用 CloudTrail 對 Athena 筆記本 API 呼叫進行疑難排解
<a name="notebooks-spark-troubleshooting-cloudtrail"></a>

若要對筆記本 API 呼叫進行疑難排解，您可以檢查 Athena CloudTrail 日誌，以調查異常狀況或探索使用者發起的動作。如需有關搭配使用 CloudTrail 與 Athena 的詳細資訊，請參閱 [使用 記錄 Amazon Athena API 呼叫 AWS CloudTrail](monitor-with-cloudtrail.md)。

以下範例會示範 Athena 筆記本 API 的 CloudTrail 日誌項目。

## StartSession
<a name="notebooks-spark-troubleshooting-cloudtrail-startsession"></a>

下列範例會顯示筆記本的 CloudTrail 日誌 [StartSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartSession.html) 事件。

```
{
    "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
<a name="notebooks-spark-troubleshooting-cloudtrail-terminatesession"></a>

下列範例會顯示筆記本的 CloudTrail 日誌 [TerminateSession](https://docs.aws.amazon.com/athena/latest/APIReference/API_TerminateSession.html) 事件。

```
{
    "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
<a name="notebooks-spark-troubleshooting-cloudtrail-importnotebook"></a>

下列範例會顯示筆記本的 CloudTrail 日誌 [ImportNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_ImportNotebook.html) 事件。為了安全起見，某些內容會隱藏。

```
{
    "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
<a name="notebooks-spark-troubleshooting-cloudtrail-updatenotebook"></a>

下列範例會顯示筆記本的 CloudTrail 日誌 [UpdateNotebook](https://docs.aws.amazon.com/athena/latest/APIReference/API_UpdateNotebook.html) 事件。為了安全起見，某些內容會隱藏。

```
{
    "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
<a name="notebooks-spark-troubleshooting-cloudtrail-startcalculationexecution"></a>

下列範例會顯示筆記本的 CloudTrail 日誌 [StartCalculationExecution](https://docs.aws.amazon.com/athena/latest/APIReference/API_StartCalculationExecution.html) 事件。為了安全起見，某些內容會隱藏。

```
{
    "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"
    }
}
```

# 克服 68k 程式碼區塊大小限制
<a name="notebooks-spark-troubleshooting-code-block-size-limit"></a>

Athena for Spark 的已知計算程式碼區塊大小限制為 68000 個字元。當您使用超過此限制的程式碼區塊執行計算時，您可能會收到下列錯誤訊息：

「程式碼區塊」的 '...' 無法滿足限制條件：成員的長度必須小於或等於 68000

下圖顯示了 Athena 主控台筆記本編輯器中的此錯誤。

![\[Athena 筆記本編輯器中的程式碼區塊大小錯誤訊息\]](http://docs.aws.amazon.com/zh_tw/athena/latest/ug/images/notebooks-spark-troubleshooting-code-block-size-limit-1.png)


當您使用 AWS CLI 執行具有大型程式碼區塊的計算時，可能會發生相同的錯誤，如下列範例所示。

```
aws athena start-calculation-execution \ 
    --session-id "{SESSION_ID}" \ 
    --description "{SESSION_DESCRIPTION}" \ 
    --code-block "{LARGE_CODE_BLOCK}"
```

該命令會提供以下錯誤訊息：

「程式碼區塊」的 *\$1LARGE\$1CODE\$1BLOCK\$1* 無法滿足限制條件：成員的長度必須小於或等於 68000

## 解決方法
<a name="notebooks-spark-troubleshooting-code-block-size-limit-workaround"></a>

若要解決此問題，請將具有您的查詢或計算程式碼的檔案上傳至 Amazon S3。然後，使用 boto3 讀取檔案並執行 SQL 或程式碼。

下列範例假設，您已將具有 SQL 查詢或 Python 程式碼的檔案上傳至 Amazon S3。

### SQL 範例
<a name="notebooks-spark-troubleshooting-code-block-size-limit-sql-example"></a>

下列範例程式碼會從 Amazon S3 儲存貯體讀取 `large_sql_query.sql` 檔案，然後執行檔案包含的大型查詢。

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

### PySpark 範例
<a name="notebooks-spark-troubleshooting-code-block-size-limit-pyspark-example"></a>

下列程式碼範例會從 Amazon S3 讀取 `large_py_spark.py` 檔案，然後執行檔案中的大型程式碼區塊。

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

# 對工作階段錯誤進行疑難排解
<a name="notebooks-spark-troubleshooting-sessions"></a>

使用本節中的資訊來對工作階段問題進行疑難排解。

當工作階段啟動期間發生自訂組態錯誤時，Athena for Spark 主控台會顯示錯誤訊息橫幅。若要對工作階段啟動錯誤進行疑難排解，您可以檢查工作階段狀態變更或記錄資訊。

## 檢視工作階段狀態變更資訊
<a name="notebooks-spark-troubleshooting-sessions-viewing-session-state-change"></a>

您可以從 Athena 筆記本編輯器或 Athena API 取得有關工作階段狀態變更的詳細資訊。

**在 Athena 主控台中檢視工作階段狀態資訊**

1. 在 Athena 筆記本編輯器中，從右上角的**工作階段**選單中，選擇**檢視詳細資訊**。

1. 檢視**目前工作階段**索引標籤。**工作階段資訊**區段會顯示工作階段 ID、工作群組、狀態和狀態變更原因等資訊。

   下列螢幕擷取範例會針對 Athena 中的 Spark 工作階段錯誤，顯示**工作階段資訊**對話方塊中**狀態變更原因**區段中的資訊。  
![\[在 Athena for Spark 主控台中檢視工作階段狀態變更資訊。\]](http://docs.aws.amazon.com/zh_tw/athena/latest/ug/images/notebooks-spark-custom-jar-cfg-1.jpeg)

**使用 Athena API 檢視工作階段狀態資訊**
+ 在 Athena API 中，您可以在 [SessionStatus](https://docs.aws.amazon.com/athena/latest/APIReference/API_SessionStatus.html) 物件的 `StateChangeReason` 欄位中尋找工作階段狀態變更資訊。

**注意**  
手動停止工作階段之後，或者如果工作階段在閒置逾時 (預設值為 20 分鐘) 之後停止，則 **StateChangeReason** 的值會變更為根據請求終止工作階段。

## 使用記錄對工作階段啟動錯誤進行疑難排解
<a name="notebooks-spark-troubleshooting-sessions-using-logging"></a>

[Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/WhatIsCloudWatch.html) 會記錄工作階段開始期間發生的自訂組態錯誤。在 CloudWatch Logs 中，從 `AthenaSparkSessionErrorLogger` 中搜尋錯誤訊息，以便對失敗的工作階段啟動進行疑難排解。

如需有關 Spark 記錄的詳細資訊，請參閱 [記錄 Athena 中的 Spark 應用程式事件](notebooks-spark-logging.md)。

如需有關在 Athena for Spark 中疑難排解工作階段的詳細資訊，請參閱 [對工作階段錯誤進行疑難排解](#notebooks-spark-troubleshooting-sessions)。

## 特定工作階段問題
<a name="notebooks-spark-troubleshooting-sessions-specific-error-messages"></a>

使用本節中的資訊來對一些特定工作階段問題進行疑難排解。

### 工作階段處於狀況不良狀態
<a name="notebooks-spark-troubleshooting-sessions-unhealthy"></a>

如果您收到錯誤訊息 Session in unhealthy state (工作階段處於狀況不良狀態)。請建立新的工作階段，終止現有的工作階段並建立新的工作階段。

### 無法建立與筆記本伺服器的連線
<a name="notebooks-spark-troubleshooting-sessions-wss-blocked"></a>

當您開啟筆記本時，可能會看到下列錯誤訊息：

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

#### 原因
<a name="notebooks-spark-troubleshooting-sessions-wss-blocked-cause"></a>

Athena 開啟筆記本時，Athena 會建立工作階段，並使用預先簽章的筆記本 URL 連線至筆記本。與筆記本的連線會使用 WSS ([WebSocket Secure](https://en.wikipedia.org/wiki/WebSocket)) 通訊協定。

錯誤的發生原因如下：
+ 本機防火牆 (例如，適用於全公司範圍的防火牆) 會封鎖 WSS 流量。
+ 本機電腦上的代理或防毒軟體會封鎖 WSS 連線。

#### 解決方案
<a name="notebooks-spark-troubleshooting-sessions-wss-blocked-solution"></a>

假設您在 `us-east-1` 區域中有一個 WSS 連線，如下所示：

```
wss://94c2bcdf-66f9-4d17-9da6-7e7338060183.analytics-gateway.us-east-1.amazonaws.com/
api/kernels/33c78c82-b8d2-4631-bd22-1565dc6ec152/channels?session_id=
7f96a3a048ab4917b6376895ea8d7535
```

若要解決錯誤，請使用以下其中一種策略。
+ 使用萬用字元模式語法，允許列出`443`跨 AWS 區域 和 連接埠的 WSS 流量 AWS 帳戶。

  ```
  wss://*amazonaws.com
  ```
+ 使用萬用字元模式語法，允許列出 AWS 區域 您指定之 `443` 中連接埠 AWS 區域 上的 AWS 帳戶 WSS 流量。以下範例使用 `us-east-1`。

  ```
  wss://*analytics-gateway.us-east-1.amazonaws.com
  ```

# 對資料表錯誤進行疑難排解
<a name="notebooks-spark-troubleshooting-tables"></a>

使用本節中的資訊，對 Athena for Spark 資料表錯誤進行疑難排解。

## 建立資料表時無法建立路徑錯誤
<a name="notebooks-spark-troubleshooting-tables-illegal-argument-exception"></a>

**錯誤訊息**：IllegalArgumentException: Cannot create a path from an empty string. (IllegalArgumentException：無法從空字串建立路徑。)

**原因**：當您在 Athena 中使用 Apache Spark 在 AWS Glue 資料庫中建立資料表，且資料庫具有空白`LOCATION`屬性時，可能會發生此錯誤。

**建議的解決方案**：如需詳細資訊和解決方案，則請參閱 [建立資料表時的非法引數例外狀況](notebooks-spark-known-issues.md#notebooks-spark-known-issues-illegal-argument-exception)

## 查詢 AWS Glue 資料表時的 AccessDeniedException
<a name="notebooks-spark-troubleshooting-tables-glue-access-denied"></a>

**錯誤訊息**：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)

**原因**：已啟用 Spark 的工作群組的執行角色缺少存取 AWS Glue 資源的許可。

**建議的解決方案**：若要解決此問題，請授予執行角色對 AWS Glue 資源的存取權，然後編輯 Amazon S3 儲存貯體政策，以授予對執行角色的存取權。

下列程序更詳細地說明了這些步驟。

**授予執行角色對 AWS Glue 資源的存取權**

1. 前往 [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home) 開啟 Athena 主控台。

1. 如果未顯示主控台的導覽窗格，請選擇左側的展開選單。  
![\[選擇展開選單。\]](http://docs.aws.amazon.com/zh_tw/athena/latest/ug/images/nav-pane-expansion.png)

1. 在 Athena 主控台導覽窗格中，選擇 **Workgroups** (工作群組)。

1. 在 **Workgroups** (工作群組) 頁面上，請選擇您要檢視的工作群組連結。

1. 在工作群組的 **Overview Details** (概觀詳細資訊) 頁面上，選擇 **Role ARN** (角色 ARN) 連結。此連結會在 IAM 主控台中開啟 Spark 執行角色。

1. 在 **Permissions policies** (許可政策) 區段中，選擇連結角色政策名稱。

1. 選擇 **Edit policy** (編輯政策)，然後選擇 **JSON**。

1. 將 AWS Glue 存取權新增至角色。通常，您可以為 `glue:GetDatabase` 和 `glue:GetTable` 動作新增許可。如需有關設定 IAM 角色的詳細資訊，請參閱《IAM 使用者指南》中的[新增和移除 IAM 身分許可](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html)。

1. 選擇 **Review policy (檢閱政策)**，然後選擇 **Save changes (儲存變更)**。

1. 編輯 Amazon S3 儲存貯體政策，以授予執行角色存取權。請注意，您必須授予角色儲存貯體和儲存貯體中的物件存取權。如需相關步驟，請參閱《Amazon Simple Storage Service 使用者指南》中的[使用 Amazon S3 主控台新增儲存貯體政策](https://docs.aws.amazon.com/AmazonS3/latest/userguide/add-bucket-policy.html)。

# 取得支援
<a name="notebooks-spark-troubleshooting-support"></a>

如需協助 AWS，請從 選擇**支援**、**支援中心** AWS 管理主控台。為增強您的體驗，請準備以下資訊：
+ Athena 查詢 ID
+ 工作階段 ID
+ 計算 ID