本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。 # AWS Glue Spark 和 PySpark 任務 AWS Glue 支援 Spark 和 PySpark 任務。Spark 任務是在 管理的 Apache Spark 環境中執行 AWS Glue。它會分批次處理資料。串流 ETL 任務類似 Spark 任務，不同之處在於它會在資料串流上執行 ETL。它使用 Apache Spark 結構化串流框架。某些 Spark 任務功能不適用於串流 ETL 任務。 下列各節提供 AWS Glue Spark 和 PySpark 任務的相關資訊。 **Topics** + [在 中設定 Spark 任務的任務屬性 AWS Glue](add-job.md) + [編輯 AWS Glue 主控台中的 Spark 指令碼](edit-script-spark.md) + [任務 (舊版)](console-edit-script.md) + [使用任務書籤追蹤處理的資料](monitor-continuations.md) + [儲存 Spark 隨機資料](monitor-spark-shuffle-manager.md) + [監控 AWS Glue Spark 任務](monitor-spark.md) + [Glue 中 Apache Spark 的生成式 AI AWS 疑難排解](troubleshoot-spark.md) + [搭配 Glue AWS 使用具體化視觀表](materialized-views.md) # 在 中設定 Spark 任務的任務屬性 AWS Glue 當您在 AWS Glue 主控台上定義任務時，您可以為屬性提供值，以控制 AWS Glue 執行時間環境。 ## 定義 Spark 任務的任務屬性 以下清單說明 Spark 任務的屬性。如需了解 Python shell 任務的屬性，請參閱 [為 Python shell 任務定義任務屬性](add-job-python.md#create-job-python-properties)。如需了解串流 ETL 任務的屬性，請參閱 [定義串流 ETL 任務的任務屬性](add-job-streaming.md#create-job-streaming-properties)。 這些屬性會依在 AWS Glue 主控台上**新增任務**精靈上顯示的順序列出。 **名稱** 提供長度上限為 255 個字元的 UTF-8 字串。 **Description** 提供最多 2,048 個字元的選用描述。 **IAM 角色** 指定 IAM 角色以授權使用執行工作和存取資料存放區所需的資源。如需在 中執行任務之許可的詳細資訊 AWS Glue，請參閱 [Glue AWS 的身分和存取管理](security-iam.md)。 **Type** ETL 任務的類型。這是根據您選取的資料來源類型自動設定的。 + **Spark** 使用任務命令 `glueetl` 執行​ Apache Spark ETL 指令碼。 + **Spark 串流**使用任務命令 `gluestreaming` 執行​ Apache Spark 串流 ETL 指令碼。如需詳細資訊，請參閱[在 AWS Glue 中串流 ETL 任務](add-job-streaming.md)。 + **Python Shell**​ 使用任務命令 `pythonshell` 執行 Python 指令碼。如需詳細資訊，請參閱[在 AWS Glue 中設定 Python Shell 任務的任務屬性](add-job-python.md)。 **AWS Glue 版本** AWS Glue 版本會決定任務可用的 Apache Spark 和 Python 版本，如下表所示。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/add-job.html) **Language** ETL 指令碼中的程式碼定義了任務的邏輯。指令碼可在 Python 或 Scala 中編寫。您可以選擇任務執行的指令碼是由 產生 AWS Glue 或由您提供。您可以在 Amazon Simple Storage Service (Amazon S3) 中提供指令碼名稱和位置。請確認路徑中沒有跟指令碼目錄名稱相同的檔案。若要進一步了解如何編寫指令碼，請參閱 [AWS Glue 程式設計指南](edit-script.md)。 **工作者類型** 可使用以下工作者類型： AWS Glue 工作者可用的資源是以 DPUs測量。DPU 是處理能力的相對測量，包含 4 個 vCPUs的運算容量和 16 GB 的記憶體。 + **G.025X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者都會映射到 0.25 個 DPU (2 個 vCPU、4 GB 記憶體)，外加 84 GB 磁碟 (大約 34 GB 可用)。我們建議低容量串流任務採用這種工作者類型。此工作者類型僅適用於 3.0 AWS Glue 版或更新版本的串流任務。 + **G.1X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者映射到 1 個 DPU (4 個 vCPUs，16 GB 記憶體），其中包含 94GB 磁碟 （大約 44GB 可用）。我們建議將此工作者類型用於資料轉換、聯結和查詢等工作負載，以提供可擴展且符合成本效益的方式來執行大部分任務。 + **G.2X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者映射到 2 個 DPU (8 個 vCPUs，32 GB 記憶體） 和 138GB 磁碟 （大約 78GB 可用）。我們建議將此工作者類型用於資料轉換、聯結和查詢等工作負載，以提供可擴展且符合成本效益的方式來執行大部分任務。 + **G.4X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者映射到 4 個 DPU (16 個 vCPUs，64 GB 記憶體） 和 256GB 磁碟 （大約 230GB 可用）。我們建議工作負載包含最嚴苛轉換、彙總、聯結和查詢的任務採用這種工作者類型。 + **G.8X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者映射到 8 個 DPU (32 個 vCPUs，128 GB 記憶體） 和 512GB 磁碟 （大約 485GB 可用）。我們建議工作負載包含最嚴苛轉換、彙總、聯結和查詢的任務採用這種工作者類型。 + **G.12X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者映射到 12 個 DPU (48 個 vCPUs，192 GB 記憶體） 和 768GB 磁碟 （大約 741GB 可用）。對於具有需要大量運算容量且資源密集的大型工作負載任務，我們建議使用此工作者類型。 + **G.16X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者映射到 16 個 DPU (64 個 vCPUs，256 GB 記憶體） 和 1024GB 磁碟 （大約 996GB 可用）。對於具有需要最大運算容量的最大且資源最密集的工作負載的任務，我們建議使用此工作者類型。 + **R.1X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者都會映射到 1 個具有記憶體最佳化組態的 DPU。對於經常遇到記憶體不足錯誤或需要高記憶體與 CPU 比率的記憶體密集型工作負載，建議使用此工作者類型。 + **R.2X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者都會映射到 2 個具有記憶體最佳化組態的 DPU。對於經常遇到記憶體不足錯誤或需要高記憶體與 CPU 比率的記憶體密集型工作負載，建議使用此工作者類型。 + **R.4X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者都會映射到 4 個具有記憶體最佳化組態的 DPU。對於經常遇到記憶體不足錯誤或需要高記憶體與 CPU 比率的大型記憶體密集型工作負載，建議使用此工作者類型。 + **R.8X** – 選擇這種類型時，您也要提供 **工作者數目** 的值。每個工作者都會映射到 8 個具有記憶體最佳化組態的 DPU。對於經常遇到記憶體不足錯誤或需要高記憶體與 CPU 比率的超大型記憶體密集型工作負載，建議使用此工作者類型。 **工作者類型規格** 下表提供了所有可用 G 工作者類型的詳細規格： **G 工作者類型規格** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/add-job.html) **重要：**G.12X 和 G.16X 工作者類型以及所有 R 工作者類型 (R.1X 到 R.8X) 具有更高的啟動延遲。 我們會根據您執行 ETL 任務所使用的 DPU 數量，以小時費率計費。如需詳細資訊，請參閱 [AWS Glue 定價頁面](https://aws.amazon.com/glue/pricing/)。 對於 1.0 版或更早 AWS Glue 版本的任務，當您使用主控台設定任務並指定**標準****工作者類型**時，會設定**最大容量**，且**工作者數量**會變成**最大容量** - 1 的值。如果您使用 AWS Command Line Interface (AWS CLI) 或 AWS SDK，您可以指定**最大容量**參數，也可以同時指定**工作者類型**和**工作者數量**。 對於 2.0 AWS Glue 版或更新版本的任務，您無法指定**最大容量**。反之，您必須指定 **Worker type (工作者類型)** 與 **Number of workers (工作者數目)**。 **G.4X** 和 **G.8X** 工作者類型僅適用於下列 AWS 區域中的 3.0 AWS Glue 版或更新版本 Spark ETL 任務：美國東部 （俄亥俄）、美國東部 （維吉尼亞北部）、美國西部 （加利佛尼亞北部）、美國西部 （奧勒岡）、亞太區域 （孟買）、亞太區域 （首爾）、亞太區域 （新加坡）、亞太區域 （雪梨）、亞太區域 （東京）、加拿大 （中部）、歐洲 （法蘭克福）、歐洲 （愛爾蘭）、歐洲 （倫敦）、歐洲 （西班牙）、歐洲 （斯德哥爾摩） 和南美洲 （聖保羅）。 **G.12X**、 和 **R.1X** 透過**R.8X**工作者類型僅適用於下列 AWS 區域中的 4.0 AWS Glue 版或更新版本 Spark ETL 任務：美國東部 （維吉尼亞北部）**G.16X**、美國西部 （奧勒岡）、美國東部 （俄亥俄）、歐洲 （愛爾蘭） 和歐洲 （法蘭克福）。未來版本將支援其他區域。 **請求的工作者數目** 對於大多數工作者類型，您必須指定任務時執行所分配的工作者數目。 **工作書籤** 指定任務執行時 AWS Glue 處理狀態資訊的方式。您可以讓任務書籤記住之前處理過的資料、更新狀態資訊，或是忽略狀態資訊。如需詳細資訊，請參閱[使用任務書籤追蹤處理的資料](monitor-continuations.md)。 **任務執行佇列** 指定任務執行是否在稍後因服務配額而無法立即執行時排入佇列。 核取時，會為任務執行啟用任務執行佇列。如果未填入，系統不會考慮將任務執行排入佇列。 如果此設定與任務執行中設定的值不相符，則會使用任務執行欄位中的值。 **Flex 執行** 當您使用 AWS Studio 或 API 設定任務時，您可以指定標準或彈性任務執行類別。您的任務可能具有不同程度的優先順序和時間敏感度。標準執行類別非常適合需要快速的任務啟動和專用資源的時間敏感型工作負載。 彈性執行類別適用於非緊急任務，例如生產前任務、測試和一次性資料載入。使用 3.0 AWS Glue 版或更新版本和 `G.1X` 或 `G.2X` 工作者類型的任務支援彈性任務執行。新的工作者類型 (`G.12X`、`G.16X` 和 `R.1X` 至 `R.8X`) 不支援彈性執行。 [![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/FnHCoTuDLXU/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/FnHCoTuDLXU) 彈性任務執行基於在任何時間點執行的工作者數目計費。針對執行中的彈性任務執行，可新增或移除工作者數目。計費方式不是簡單的 `Max Capacity` \$1 `Execution Time`，每個工作者都會計入任務執行期間的時間。計費為 (`Number of DPUs per worker` \$1 `time each worker ran`) 的總和。 如需詳細資訊，請參閱 AWS Studio 中的說明面板，或 [任務](aws-glue-api-jobs-job.md)和 [任務執行](aws-glue-api-jobs-runs.md)。 **重試次數** 指定 AWS Glue 在任務失敗時自動重新啟動任務的次數，從 0 到 10。達到逾時限制的任務不會重新啟動。 **任務逾時** 設定執行時間上限 (單位為分鐘)。上限為 7 天或 10,080 分鐘。否則，任務會擲回例外狀況。 在值保留空白時，逾時預設為 2,880 分鐘。 逾時值大於 7 天的任何現有 AWS Glue 任務將預設為 7 天。例如，如果您為批次任務指定了 20 天的逾時，則會在第 7 天停止。 **任務逾時的最佳實務** 任務會根據執行時間計費。為了避免意外費用，請設定適合您任務預期執行時間的逾時值。 **進階屬性** **指令碼檔案名稱** 您的任務的唯一指令碼名稱。無法命名為**未命名任務**。 **指令碼路徑** 指令碼的 Amazon S3 位置。該路徑的格式必須是 `s3://bucket/prefix/path/`。其必須以斜線 (`/`) 結尾，且不包含任何檔案。 **任務指標** 當此任務執行時，開啟或關閉建立 Amazon CloudWatch 指標。若要檢視分析資料，您必須啟用此選項。如需如何開啟和視覺化呈現指標的詳細資訊，請參閱[任務監控與偵錯](monitor-profile-glue-job-cloudwatch-metrics.md)。 **任務可觀測性指標** 在此任務執行時，開啟建立其他可觀測性 CloudWatch 指標。如需詳細資訊，請參閱[使用 AWS Glue 可觀測性指標進行監控](monitor-observability.md)。 **連續記錄** 開啟連續記錄到 Amazon CloudWatch。如果未啟用此選項，則只有在任務完成後才能使用日誌。如需詳細資訊，請參閱 [記錄 AWS Glue 任務](monitor-continuous-logging.md)。 **Spark 使用者介面** 啟用 Spark UI 來監控此任務。如需詳細資訊，請參閱[為 AWS Glue 任務啟用 Apache Spark web UI](monitor-spark-ui-jobs.md)。 **Spark UI 日誌路徑** 啟用 Spark UI 時寫入日誌的路徑。 **Spark UI 記錄和監控組態** 請選擇下列其中一個選項： + *標準*：使用 AWS Glue 任務執行 ID 做為檔案名稱寫入日誌。在 AWS Glue 主控台中開啟 Spark UI 監控。 + *舊版*：使用 'spark-application-\$1timestamp\$1' 作為檔案名稱寫入日誌。請勿開啟 Spark UI 監控。 + *標準和舊版*：將日誌同時寫入標準和舊版位置。在 AWS Glue 主控台中開啟 Spark UI 監控。 **並行上限** 設定此任務允許並行執行的最大數量。預設為 1。達到此閾值時，會傳回錯誤。可指定的最大值由服務限制來控制。例如，新的執行個體啟動時，如果有先前的任務仍在執行，您可能會想要傳回錯誤，以防相同任務的兩個執行個體同時執行。 **暫時路徑** 提供工作目錄在 Amazon S3 中的位置，其中暫時性中繼結果會在 AWS Glue 執行指令碼時寫入。請確認路徑中沒有跟暫時目錄名稱相同的檔案。當 AWS Glue 讀取和寫入 Amazon Redshift 和特定 AWS Glue 轉換時，會使用此目錄。 AWS Glue 如果儲存貯體尚未存在於區域中， 會為任務建立暫時儲存貯體。此儲存貯體可能允許公開存取。您可以修改 Amazon S3 中的儲存貯體以設定的公有存取封鎖，或稍後在該區域的所有任務完成後刪除儲存貯體。 **延遲通知閾值 (分鐘)** 設定傳送延遲通知之前所要經過的時間閾值 (以分鐘為單位)。您可以設定這個閾值，以在 `RUNNING`、`STARTING` 或 `STOPPING` 任務執行所花的時間超過預期分鐘數時傳送通知。 **安全組態** 從清單中選擇安全組態。安全設定指定在 Amazon S3 目標上如何加密資料：不加密、使用 AWS KMS受管金鑰 (SSE-KMS) 或 Amazon S3 管理的加密金鑰 (SSE-S3) 進行伺服器端加密。 **伺服器端加密** 如果您選擇此選項，則 ETL 任務寫入 Amazon S3 時，資料會在靜態時加密 (使用 SSE-S3 加密)。您的 Amazon S3 資料目標和寫入 Amazon S3 暫時目錄的任何資料都會加密。系統會以任務參數的形式傳遞此選項。如需詳細資訊，請參閱 *Amazon Simple Storage Service 使用者指南*中的[透過 Amazon S3 受管加密金鑰 (SSE-S3) 使用伺服器端加密來保護資料](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingServerSideEncryption.html)。 如果指定安全組態，則會忽略此選項。 **使用 Glue 資料目錄做為 Hive 中繼存放區** 選取 以使用 AWS Glue Data Catalog 做為 Hive 中繼存放區。此任務所用的 IAM 角色必須具有 `glue:CreateDatabase` 許可。稱為「預設」的資料庫隨即在 Data Catalog 中建立 (如當時該資料庫尚未存在)。 **連線** 選擇 VPC 組態，以存取位於虛擬私有雲端 (VPC) 中的 Amazon S3 資料來源。您可以在 AWS Glue中建立和管理網路連線。如需詳細資訊，請參閱[連線至資料](glue-connections.md)。 **Libraries (程式庫)** **Python 程式庫路徑，相依的 JAR 路徑和參考檔案路徑** 如果您的指令碼需要這些選項，請進行指定。定義此任務時，您可以為這些選項定義以逗號分隔的 Amazon S3 路徑。執行任務時，您可以覆寫這些路徑。如需詳細資訊，請參閱[提供您的自訂指令碼](console-custom-created.md)。 **工作參數** 一組金鑰/值對，會以具名參數的形式傳遞至指令碼。這些是指令碼執行時使用的預設值，但您可以在觸發時或在執行任務階段覆寫。您必須在索引鍵名稱前加上 `--`；例如：`--myKey`。使用 時，您會傳遞任務參數做為映射 AWS Command Line Interface。 如需範例，請參閱 [在 AWS Glue 中傳遞和存取 Python 參數](aws-glue-programming-python-calling.md#aws-glue-programming-python-calling-parameters) 的 Python 參數。 **Tags (標籤)** 使用 **Tag key (標籤金鑰)** 和選用的 **Tag value (標籤值)**，標記您的任務。標籤鍵在建立後，將是唯讀狀態。應用標籤至某些資源，有助於您對其進行整理和識別。如需詳細資訊，請參閱[AWS 中的標籤 AWS Glue](monitor-tags.md)。 ## 存取 Lake Formation 受管資料表任務的限制 建立從 讀取或寫入由 管理之資料表的任務時，請記住下列注意事項和限制 AWS Lake Formation： + 使用儲存格層級篩選條件存取資料表的任務不支援下列功能： + [任務書籤](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html)和[限制執行](https://docs.aws.amazon.com/glue/latest/dg/bounded-execution.html) + [Push-down 述詞](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-pushdowns) + [伺服器端類別目錄分割述詞](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html#aws-glue-programming-etl-partitions-cat-predicates) + [enableUpdateCatalog](https://docs.aws.amazon.com/glue/latest/dg/update-from-job.html) # 編輯 AWS Glue 主控台中的 Spark 指令碼 指令碼包含從來源擷取資料、轉換資料的程式碼，並將其載入到 target。 會在啟動任務時 AWS Glue 執行指令碼。 AWS Glue ETL 指令碼可以在 Python 或 Scala 中進行程式碼編寫。Python 指令碼使用了 PySpark Python 分支的延伸語言，適用於擷取、轉換和載入 (ETL) 任務。此指令碼包含了*延伸的架構*，來處理 ETL 的轉換作業。當您針對任務自動產生原始程式碼邏輯時，指令碼也會隨之產生。您可以編輯這個指令碼，也可以提供自己的指令碼來處理您的 ETL 任務。 如需有關在 AWS Glue 中定義和編輯指令碼的資訊，請參閱 [AWS Glue 程式設計指南](edit-script.md)。 ## 其他程式庫或檔案 如果指令碼需要其他程式庫或檔案，您可加以指定，如下所示： **Python 程式庫路徑** 以逗號分隔的 Amazon Simple Storage Service (Amazon S3) 路徑，連接至您指令碼所需的 Python 程式庫。 只能使用純 Python 程式庫。目前尚未支援使用 C 延伸模組的程式庫 (例如 pandas Python 資料分析程式庫)。 **相依 jar 路徑** 以逗號分隔的 Amazon S3 路徑，連接至指令碼所需的 JAR 檔案。 目前只有純 Java 或 Scala (2.11) 程式庫才可使用。 **參考檔案路徑** 以逗號分隔的 Amazon S3 路徑，連接至指令碼所需的其他檔案 (例如組態檔案)。 # 任務 (舊版) 指令碼包含執行擷取、轉換和載入 (ETL) 任務的程式碼。您可以提供自己的指令碼，或者 AWS Glue 可依照您的指引產生指令碼。如需編寫自己專用指令碼的詳細資訊，請參閱[提供您的自訂指令碼](console-custom-created.md)。 您可以在 AWS Glue 主控台編輯指令碼。編輯指令碼時，您可以新增來源、目標和轉換。 **編輯指令碼** 1. 登入 AWS 管理主控台 並在 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 開啟 AWS Glue主控台。接著選擇 **Jobs** (任務) 索引標籤。 1. 在清單中選擇任務，然後選擇 **Action**, **Edit script** (動作，編輯指令碼) 以開啟指令碼編輯器。 您也可以從任務詳細資訊頁面存取指令碼編輯器。選擇 **Script (指令碼)** 索引標籤，接著選擇 **Edit script (編輯指令碼)**。 ## 指令碼編輯器 AWS Glue 指令碼編輯器可讓您插入、修改、刪除指令碼中的來源、目標和轉換。指令碼編輯器會顯示指令碼以及圖表，協助您將資料流程視覺化。 要建立指令碼的圖表，請選擇 **Generate diagram (產生圖表)**。AWS Glue 在指令碼中使用以 **\$1\$1** 開頭的註釋行來呈現圖表。要在圖表中正確展示指令碼，您必須讓註釋中的參數和 Apache Spark 程式碼中的參數保持同步。 無論您的游標置於指令碼中何處，指令碼編輯器都能讓您新增程式碼範本。在編輯器最上方，從下列選項中選擇： + 若要新增來源資料表到指令碼，請選擇 **Source** (來源)。 + 若要新增目標到指令碼，請選擇 **Target** (目標)。 + 若要新增目標位置到指令碼，請選擇 **Target location** (目標位置)。 + 若要新增轉換到指令碼，請選擇 **Transform** (轉換)。如需在指令碼中呼叫函數的詳細資訊，請參閱 [在 PySpark 中程式設計 AWS Glue ETL 指令碼](aws-glue-programming-python.md)。 + 若要新增 Spigot 轉換到指令碼，請選擇 **Spigot**。 在插入的程式碼中，修改註釋和 Apache Spark 程式碼中的 `parameters`。例如您新增了 **Spigot** 轉換，請確認 `path` 在 `@args` 註釋和 `output` 程式碼中都已被取代。 **Logs** (日誌) 索引標籤會顯示任務執行時與其關聯的日誌。顯示範圍為最近的 1,000 行。 **Schema (結構描述)** 索引標籤會顯示在 Data Catalog 中所選來源和目標的結構描述。 # 使用任務書籤追蹤處理的資料 AWS Glue 會持續保留前次執行 ETL 任務的狀態資訊，以追蹤在該任務執行期間所處理的資料。此保存狀態資訊稱為*任務書籤*。任務書籤可協助 AWS Glue 維護狀態資訊，以及防止重新處理舊資料。透過任務書籤，您可以在依排定間隔重新執行時處理新資料。任務書籤包括各種任務元素的狀態，例如來源、轉換和目標。例如，ETL 任務可能會讀取 Amazon S3 檔案中的新分割區。AWS Glue 會追蹤已由任務成功處理的分割區，避免重複處理以及任務目標資料存放區中出現重複的資料。 任務書籤實作於 JDBC 資料來源、Relationalize 轉換和部分 Amazon Simple Storage Service (Amazon S3) 來源。下表列出 AWS Glue 針對任務書籤支援的 Amazon S3 來源格式。 | AWS Glue 版本 | Amazon S3 來源格式 | | --- | --- | | 0.9 版 | JSON、CSV、Apache Avro、XML | | 1.0 版和更新版本 | JSON、CSV、Apache Avro、XML、Parquet、ORC | 如需 AWS Glue 版本的詳細資訊，請參閱[定義 Spark 任務的任務屬性](add-job.md#create-job)。 透過 AWS Glue 指令碼存取時，任務書籤功能具有其他功能。瀏覽產生的指令碼時，您可能會看到與此功能相關的轉換內容。如需詳細資訊，請參閱[使用任務書籤](programming-etl-connect-bookmarks.md)。 **Topics** + [在 AWS Glue 中使用任務書籤](#monitor-continuations-implement) + [任務書籤功能的操作詳細資訊](#monitor-continuations-script) ## 在 AWS Glue 中使用任務書籤 當任務開始之後，會將任務書籤選項當成參數傳遞。下表說明在 AWS Glue 主控台中設定任務書籤的選項。 **** | 工作書籤 | Description | | --- | --- | | Enable | 讓任務在執行之後更新狀態，以追蹤先前處理的資料。如果您任務的來源具有任務書籤支援，則會追蹤已處理的資料，而且在任務執行時，會處理最後一個檢查點之後的新資料。 | | 停用 | 不會使用任務書籤，而且任務一律會處理整個資料集。您需負責管理之前工作執行的輸出。這是預設值。 | | 暫停 | 處理上次成功執行後的遞增資料，或由下列子選項識別範圍內的資料，而不更新最後一個書籤的狀態。您需負責管理之前工作執行的輸出。這兩個子選項是： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitor-continuations.html) 指定此選項組時，不會更新任務書籤狀態。 子選項是可選的，但是當使用時，必須提供這兩個子選項。 | 有關在命令列傳遞至任務的參數 (特別是任務標籤) 的詳細資訊，請參閱 [在 Glue AWS 任務中使用任務參數](aws-glue-programming-etl-glue-arguments.md)。 若是 Amazon S3 輸入來源，AWS Glue 任務書籤會檢查物件的上次修改時間，以確認需要重新處理哪些物件。如果自上次任務執行之後已修改您的輸入來源資料，則在您重新執行任務時重新處理檔案。 如為 JDBC 來源，則適用的規定如下： + AWS Glue 會針對每個資料表使用一個或多個欄做為書籤索引鍵，以決定新資料和已處理的資料。書籤索引鍵結合在一起，形成單一複合索引鍵。 + 依預設，AWS Glue 會使用主索引鍵作為書籤索引鍵，但條件是其依序遞增或遞減 (沒有間隙)。 + 您可以指定要在 AWS Glue 指令碼中用作書籤索引鍵的資料欄。如需在 AWS Glue 指令碼中使用任務書籤的詳細資訊，請參閱 [使用任務書籤](programming-etl-connect-bookmarks.md)。 + AWS Glue 不支援使用名稱區分大小寫的資料欄作為任務書籤索引鍵。 您可以將 AWS Glue Spark ETL 任務的任務書籤倒轉至任何之前的任務執行。現在，您可以透過將任務書籤倒轉至任何之前的任務執行，更好地支援資料回填方案，從而在後續的任務執行中，僅重新處理已加入書籤的任務執行中的資料。 如果您想要使用相同的任務來重新處理所有資料，則請重設任務書籤。若要重設任務書籤狀態，請使用 AWS Glue 主控台、[ResetJobBookmark 動作 (Python: reset\$1job\$1bookmark)](aws-glue-api-jobs-runs.md#aws-glue-api-jobs-runs-ResetJobBookmark) API 操作或 AWS CLI。例如，使用 AWS CLI輸入下列命令： ``` aws glue reset-job-bookmark --job-name my-job-name ``` 當您倒轉或重設書籤時，AWS Glue 不會清除目標檔案，因為可能有多個目標，且未使用任務書籤追蹤目標。只有來源檔案會使用任務書籤來追蹤。您可以在倒轉和重新處理來源檔案時建立不同的輸出目標，以避免輸出中的資料重複。 AWS Glue 會依任務來追蹤任務書籤。如果您刪除任務，任務書籤將不會保留。 在某些情況下，您可能已啟用 AWS Glue 任務書籤，但 ETL 任務正在重新處理已在稍早執行中處理的資料。如需解決此錯誤常見原因的資訊，請參閱[對 Glue 常見設定錯誤進行故障診斷](glue-troubleshooting-errors.md)。 ## 任務書籤功能的操作詳細資訊 本節說明如何使用任務書籤的更多操作詳細資訊。 任務書籤會存放任務的狀態。都會依任務名稱和版本號碼輸入狀態的每個執行個體。指令碼呼叫 `job.init` 時，會擷取其狀態，而且一律會取得最新版本。在狀態內，有多個狀態元素，即指令碼中每個來源、轉換和目的地執行個體所特有的。這些狀態元素是依連接到指令碼中對應元素 (來源、轉換或目的地) 的轉換內容所識別。從使用者指令碼呼叫 `job.commit` 時，會自動儲存狀態元素。指令碼會從引數取得任務名稱以及任務書籤的控制選項。 任務書籤中的狀態元素是來源、轉換或目的地特定的資料。例如，假設您想要從上游任務或程序持續寫入的 Amazon S3 位置讀取遞增資料。在此情況下，指令碼必須判斷到目前為止已處理哪些項目。Amazon S3 來源的任務書籤實作會儲存資訊，因此，在重新執行任務時，只能使用儲存的資訊來篩選新物件，以及重新計算下次執行任務的狀態。時間戳記用來篩選新的檔案。 除了狀態元素之外，任務書籤還會有*執行次數*、*嘗試次數*和*版本號碼*。執行次數會追蹤任務的執行，而嘗試次數會記錄任務執行的嘗試。任務執行次數是每次成功執行所遞增的依序增加數目。嘗試次數會追蹤每次執行的嘗試，而且只有在失敗嘗試之後執行時才會遞增。版本號碼會依序遞增，並追蹤任務書籤的更新。 在 AWS Glue 服務資料庫中，所有轉換的書籤狀態會儲存為索引鍵/值對： ``` { "job_name" : ..., "run_id": ..., "run_number": .., "attempt_number": ... "states": { "transformation_ctx1" : { bookmark_state1 }, "transformation_ctx2" : { bookmark_state2 } } } ``` **最佳實務** 下列是使用任務書籤的最佳實務。 + *不要在已啟用書籤的情況下更改資料來源屬性*。例如，有一個資料來源 0 指向 Amazon S3 輸入路徑 A，且該任務啟用了書籤並從已執行了好幾輪的來源進行讀取。如果您將資料來源 0 的輸入路徑變更為 Amazon S3 路徑 B，而不變更 `transformation_ctx`， AWS Glue 任務將使用儲存的舊書籤狀態。這會導致輸入路徑 B 中的檔案遺失或略過檔案， AWS Glue 如同假設這些檔案已在先前的執行中處理過一樣。 + *使用帶有書籤的目錄表，以便更好地管理分割區*。書籤既適用於 Data Catalog 中的資料來源，也適用於來自選項的資料來源。但是，使用來自選項的方法會難以刪除/新增分割區。將目錄表與爬蟲程式結合使用可以提供更好的自動化來追蹤新增的[分割區](https://docs.aws.amazon.com/glue/latest/dg/tables-described.html#tables-partition)，並可讓您靈活地使用 [pushdown 述詞](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-partitions.html)選擇特定的分割區。 + *將 [AWS Glue Amazon S3 檔案清單建立工具](https://aws.amazon.com/premiumsupport/knowledge-center/glue-oom-java-heap-space-error/)用於大型資料集*。書籤將列出每個輸入分割區下的所有檔案並執行篩選，因此如果單個分割區下的檔案太多，書籤可能會遇到驅動程式 OOM 的問題。使用 AWS Glue Amazon S3 檔案清單工具，避免一次列出記憶體中的所有檔案。 # 儲存 Spark 隨機資料 隨機排序是每當資料分割區之間重新排列 Spark 任務的重要步驟。這是必需的，因為諸如 `join`、` groupByKey`、`reduceByKey` 以及 `repartition` 等廣泛轉換需要來自其他分割區的資訊才能完成處理。Spark 會從每個分割區收集所需的資料，並將其結合成一個新的分割區。在隨機排序期間，資料會寫入磁碟並透過網路傳輸。因此，隨機排序操作與本機磁碟容量密切相關。當執行器沒有足夠的磁碟空間並且沒有復原時，Spark 擲出 `No space left on device` 或 ` MetadataFetchFailedException` 錯誤。 **注意** AWS Glue 僅 AWS Glue ETL 任務支援具有 Amazon S3 的 Spark 隨機播放外掛程式。 **解決方案** 透過 AWS Glue，您現在可以使用 Amazon S3 來存放 Spark 隨機排序資料。Amazon S3 是一項物件儲存服務，提供領先業界的可擴展性、資料可用性、安全性和效能。此解決方案可為您的 Spark 任務分解運算和儲存，並提供完整的彈性和低成本的隨機排序儲存，讓您可靠地執行最密集的隨機排序工作負載。 ![\[Spark workflow showing Map and Reduce stages using Amazon S3 for shuffle data storage.\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/gs-s3-shuffle-diagram.png) 我們正推出新的 Apache Spark 雲端隨機排序儲存外掛程式，以便您有效地使用 Amazon S3。如果已知任務受到大型隨機操作的本機磁碟容量限制，您可以開啟 Amazon S3 隨機排序來可靠地執行您的 AWS Glue 任務，而不會失敗。在某些情況下，如果您有大量的小分割區或隨機排序檔案已寫入 Amazon S3，則隨機排序到 Amazon S3 會比本機磁碟 (或 EBS) 稍慢一些。 ## 使用雲端隨機排序儲存外掛程式的先決條件 若要搭配 AWS Glue ETL 任務使用 Cloud Shuffle Storage Plugin，您需要下列項目： + 與任務執行位於相同區域的 Amazon S3 儲存貯體，用於存放中繼隨機排序和溢出的資料。您可以使用 `--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket/prefix/` 指定隨機排序儲存的 Amazon S3 字首，如下列範例所示： ``` --conf spark.shuffle.glue.s3ShuffleBucket=s3://glue-shuffle-123456789-us-east-1/glue-shuffle-data/ ``` + 在*字首*上設定 Amazon S3 儲存生命週期政策 (如 `glue-shuffle-data`)，因為隨機排序管理器在任務完成後不會清除檔案。任務完成後，應刪除中繼隨機排序和溢出的資料。使用者可以在字首上設定簡短的生命週期政策。如需設定 Amazon S3 生命週期政策的說明，請參閱《Amazon Simple Storage Service 使用者指南》中的[設定儲存貯體的生命週期組態](https://docs.aws.amazon.com//AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html)。 ## 從 AWS 主控台使用 AWS Glue Spark 隨機播放管理員 若要在設定任務時，使用 AWS Glue 主控台或 AWS Glue Studio 設定 AWS Glue Spark 隨機排序管理器：選擇 **--write-shuffle-files-to-s3** 任務參數以開啟該任務的 Amazon S3 隨機排序。 ![\[Job parameters interface showing --write-shuffle-files- parameter and option to add more.\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/gs-s3-shuffle.png) ## 使用 AWS Glue Spark 隨機排序外掛程式 下列任務參數會開啟並微調 AWS Glue 隨機排序管理器。這些參數是旗標，因此不會考慮提供的任何值。 + `--write-shuffle-files-to-s3`：主要旗標，啟用 AWS Glue Spark 隨機排序管理器以使用 Amazon S3 儲存貯體來寫入和讀取隨機排序資料。當未指定旗標時不使用隨機排序管理器。 + `--write-shuffle-spills-to-s3` – (僅對 AWS Glue 2.0 版本提供支援)。此為選用旗標，可讓您將溢出檔案卸載到 Amazon S3 儲存貯體，這可為 Spark 任務提供額外的彈性。只有將大量資料溢出到磁碟的大型工作負載才需要它。如果未指定旗標，則不會寫入中繼溢出檔案。 + ` --conf spark.shuffle.glue.s3ShuffleBucket=s3://` — 另一個可選標記，它指定您在其中寫入隨機排序檔案的 Amazon S3 儲存貯體。根據預設，`--TempDir`/shuffle-data. AWS Glue 3.0\$1 支援將隨機播放檔案寫入多個儲存貯體，方法是使用逗號分隔符號指定儲存貯體，如 所示`--conf spark.shuffle.glue.s3ShuffleBucket=s3://shuffle-bucket-1/prefix,s3://shuffle-bucket-2/prefix/`。使用多個儲存貯體可改善效能。 您需要提供安全組態設定，才能為隨機資料啟用靜態加密。如需安全組態的詳細資訊，請參閱 [設定 AWS Glue 中的加密](set-up-encryption.md)。AWS Glue 支援 Spark 提供的所有其他隨機顯示相關組態。 **雲端隨機排序儲存外掛程式的軟體二進位檔** 您也可以依據 Apache 2.0 許可證下載 Apache Spark 雲端隨機排序儲存外掛程式的軟體二進位檔，並在任何 Spark 環境中執行該二進位檔。這個新的外掛程式隨附對 Amazon S3 的立即支援，也可以輕鬆設定為使用其他形式的雲端儲存，例如 [Google Cloud Storage 和 Microsoft Azure Blob 儲存體](https://github.com/aws-samples/aws-glue-samples/blob/master/docs/cloud-shuffle-plugin/README.md)。如需詳細資訊，請參閱 [Apache Spark 雲端隨機排序儲存外掛程式](https://docs.aws.amazon.com/glue/latest/dg/cloud-shuffle-storage-plugin.html)。 **備註與限制** 以下是 AWS Glue 隨機排序管理器的備註或限制： + AWS Glue 隨機播放管理員不會在任務完成後自動刪除存放在 Amazon S3 儲存貯體中的 （暫時） 隨機播放資料檔案。若要確保資料保護，請在啟用雲端隨機排序儲存外掛程式之前遵循 [使用雲端隨機排序儲存外掛程式的先決條件](#monitor-spark-shuffle-manager-prereqs) 中的說明進行操作。 + 如果資料偏斜，您可以使用此功能。 # Apache Spark 雲端隨機排序儲存外掛程式 雲端隨機排序儲存外掛程式是與 [`ShuffleDataIO` API](https://github.com/apache/spark/blob/master/core/src/main/java/org/apache/spark/shuffle/api/ShuffleDataIO.java) 相容的 Apache Spark 外掛程式，允許在雲端儲存系統 (如 Amazon S3) 上儲存隨機排序資料。此外掛程式可以幫助您補充或更換本機磁碟儲存容量，以進行大型隨機排序操作，此類操作通常由 Spark 應用程式中的轉換 (例如 `join`、`reduceByKey`、`groupByKey` 和 `repartition`) 觸發，從而減少無伺服器資料分析任務和管道的常見故障或對價格/效能的負面影響。 **AWS Glue** AWS Glue 3.0 和 4.0 版本隨附預先安裝的外掛程式，並可啟用對 Amazon S3 的隨機排序，而無需任何額外的步驟。如需詳細資訊，請參閱 [AWS Glue Spark 隨機排序外掛程式與 Amazon S3](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-shuffle-manager.html)，以啟用 Spark 應用程式的功能。 **其他 Spark 環境** 該外掛程式需要在其他 Spark 環境中設定以下 Spark 組態： + `--conf spark.shuffle.sort.io.plugin.class=com.amazonaws.spark.shuffle.io.cloud.ChopperPlugin`：這會通知 Spark 使用此外掛程式對 IO 進行隨機排序。 + `--conf spark.shuffle.storage.path=s3://bucket-name/shuffle-file-dir`：隨機排序檔案的存放路徑。 **注意** 該外掛程式會覆寫一個 Spark 核心類別。因此，需要在 Spark jar 之前載入外掛程式 jar。如果在 AWS Glue 外部使用此外掛程式，您可以在內部部署 YARN 環境中使用 `userClassPathFirst` 來達成此目的。 ## 將外掛程式與 Spark 應用程式綁定在一起 您可以在本機開發 Spark 應用程式時，透過在 Maven `pom.xml` 中新增外掛程式相依性，將外掛程式與 Spark 應用程式和 Spark 發行版本 (3.1 及更高版本) 綁定在一起。如需有關此外掛程式和 Spark 版本的詳細資訊，請參閱[外掛程式版本](#cloud-shuffle-storage-plugin-versions)。 ``` ... aws-glue-etl-artifacts https://aws-glue-etl-artifacts.s3.amazonaws.com/release/ ... com.amazonaws chopper-plugin 3.1-amzn-LATEST ``` 或者，您也可以直接從 AWS Glue Maven 成品下載二進位檔，並將其包含在 Spark 應用程式中，如下所示。 ``` #!/bin/bash sudo wget -v https://aws-glue-etl-artifacts.s3.amazonaws.com/release/com/amazonaws/chopper-plugin/3.1-amzn-LATEST/chopper-plugin-3.1-amzn-LATEST.jar -P /usr/lib/spark/jars/ ``` spark-submit 範例 ``` spark-submit --deploy-mode cluster \ --conf spark.shuffle.storage.s3.path=s3:/// \ --conf spark.driver.extraClassPath= \ --conf spark.executor.extraClassPath= \ --class s3:/// \ ``` ## 選用組態 這些是控制 Amazon S3 隨機排序行為的選用組態值。 + `spark.shuffle.storage.s3.enableServerSideEncryption`：啟用/停用將檔案隨機排序和溢位的 S3 SSE。預設值為 `true`。 + `spark.shuffle.storage.s3.serverSideEncryption.algorithm`：要使用的 SSE 演算法。預設值為 `AES256`。 + `spark.shuffle.storage.s3.serverSideEncryption.kms.key`：啟用 SSE aws:kms 時的 KMS 金鑰 ARN。 除了這些組態之外，您可能需要設定組態，例如 `spark.hadoop.fs.s3.enableServerSideEncryption` 和**其他特定於環境的組態**，以確保針對您的使用案例套用適當加密。 ## 外掛程式版本 與每個版本相關聯的 Spark AWS Glue 版本支援此外掛程式。下表顯示 AWS Glue 版本、Spark 版本和相關的外掛程式版本，以及外掛程式軟體二進位檔的 Amazon S3 位置。 | AWS Glue 版本 | Spark 版本 | 外掛程式版本 | Amazon S3 位置 | | --- | --- | --- | --- | | 3.0 | 3.1 | 3.1-amzn-LATEST | s3://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.1-amzn-0/chopper-plugin-3.1-amzn-LATEST.jar | | 4.0 | 3.3 | 3.3-amzn-LATEST | s3://aws-glue-etl-artifacts/release/com/amazonaws/chopper-plugin/3.3-amzn-0/chopper-plugin-3.3-amzn-LATEST.jar | ## 授權 此外掛程式的軟體二進位檔依據 Apache 2.0 許可證獲得授權。 # 監控 AWS Glue Spark 任務 **Topics** + [中可用的 Spark 指標 AWS Glue Studio](#console-jobs-details-metrics-spark) + [使用 Apache Spark web UI 監控任務](monitor-spark-ui.md) + [使用 AWS Glue 任務執行洞察進行監控](monitor-job-insights.md) + [使用 Amazon CloudWatch 監控](monitor-cloudwatch.md) + [任務監控與偵錯](monitor-profile-glue-job-cloudwatch-metrics.md) ## 中可用的 Spark 指標 AWS Glue Studio **Metrics (指標)** 索引標籤會顯示在任務執行時和分析功能開啟時，所收集到的指標。Spark 任務中會顯示下列圖表： + ETL 資料移動 + 記憶體使用狀況：驅動程式和執行器 選擇 **View additional metrics (檢視其他指標)**，來顯示下列的圖表： + ETL 資料移動 + 記憶體使用狀況：驅動程式和執行器 + 在執行器之間的資料隨機移動 + CPU 負載：驅動程式和執行器 + 任務執行：運作中的執行器、已完成的階段和所需執行器的數量上限 如果任務已啟用收集指標，則這些圖表的資料會推送到 CloudWatch 指標。如需如何開啟指標和解讀圖表的詳細資訊，請參閱 [任務監控與偵錯](monitor-profile-glue-job-cloudwatch-metrics.md)。 **Example ETL 資料移動圖表** ETL 資料移動圖表顯示下列指標： + 所有執行器從 Amazon S3 讀取的位元組數量—[`glue.ALL.s3.filesystem.read_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes) + 所有執行器寫入至 Amazon S3 位元組數量—[`glue.ALL.s3.filesystem.write_bytes`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes) ![\[ETL 資料移動圖表 (位於 AWS Glue 主控台的「指標」索引標籤中)。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/job_detailed_etl.png) **Example 記憶體使用狀況圖表** 記憶體使用狀況圖表顯示下列指標： + 此驅動程式的 JVM 堆疊所使用的記憶體佔比 (比例：0-1)，依驅動程式、由 *executorId* 所辨識的執行器，或所有執行器劃分 — + [`glue.driver.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage) + [`glue.executorId.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.usage) + [`glue.ALL.jvm.heap.usage`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage) ![\[記憶體使用狀況圖表 (位於 AWS Glue 主控台的「指標」索引標籤中)。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/job_detailed_mem.png) **Example 執行器之間的資料隨機移動圖表** 執行器之間的資料隨機移動圖表顯示下列指標： + 所有執行器讀取的位元組數量 (以在這些執行器之間隨機移動資料) — [`glue.driver.aggregate.shuffleLocalBytesRead`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead) + 所有執行器寫入的位元組數量 (以在這些執行器之間隨機移動資料) — [`glue.driver.aggregate.shuffleBytesWritten`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten) ![\[執行器之間的資料隨機移動圖表 (位於 AWS Glue 主控台的「指標」索引標籤中)。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/job_detailed_data.png) **Example CPU 負載圖表** CPU 負載圖表顯示下列指標： + 驅動程式、由 *executorId* 所辨識的執行器，或所有執行器使用的 CPU 系統負載佔比 (比例：0-1) — + [`glue.driver.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.system.cpuSystemLoad) + [`glue.executorId.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.system.cpuSystemLoad) + [`glue.ALL.system.cpuSystemLoad`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.system.cpuSystemLoad) ![\[CPU 負載圖表 (位於 AWS Glue 主控台的「指標」索引標籤中)。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/job_detailed_cpu.png) **Example 任務執行圖表** 任務執行圖表顯示下列指標： + 目前正在運作中執行器的數量 — [`glue.driver.ExecutorAllocationManager.executors.numberAllExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors) + 已完成階段的數量 — [`glue.aggregate.numCompletedStages`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages) + 所需執行器數量的上限 — [`glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors`](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors) ![\[任務執行圖表 (位於 AWS Glue 主控台的「指標」索引標籤中)。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/job_detailed_exec.png) # 使用 Apache Spark web UI 監控任務 您可以使用 Apache Spark Web UI 來監控和偵錯在 AWS Glue 任務系統上執行的 AWS Glue ETL 任務，以及在 AWS Glue 開發端點上執行的 Spark 應用程式。Spark UI 可讓您為每個任務檢查下列項目： + 每個 Spark 階段的事件時間軸 + 任務的有向無環圖 (DAG) + SparkSQL 查詢的實體和邏輯計畫 + 每個任務的基礎 Spark 環境變數 如需有關使用 Spark Web UI 的詳細資訊，請參閱《Spark 文件》中的 [Web UI](https://spark.apache.org/docs/3.3.0/web-ui.html)。如需如何解譯 Spark UI 結果以改善任務效能的指引，請參閱 AWS 方案指南中 [AWS Glue Apache Spark 任務效能調校的最佳實務](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-aws-glue-for-apache-spark/introduction.html)。 您可以在 AWS Glue 主控台中查看 Spark UI。當 AWS Glue 任務以標準 （而非舊版） 格式產生的日誌在 AWS Glue 3.0 或更新版本上執行時，即可使用此功能，這是較新任務的預設值。如果您的日誌檔案大於 0.5 GB，您可以為在 AWS Glue 4.0 或更新版本上執行的任務啟用滾動日誌支援，以簡化日誌封存、分析和故障診斷。 您可以使用 AWS Glue主控台或 AWS Command Line Interface () 啟用 Spark UI AWS CLI。當您啟用 Spark UI 時，AWS Glue 開發端點上的 AWS Glue ETL 任務和 Spark 應用程式可以將 Spark 事件日誌備份到您在 Amazon Simple Storage Service (Amazon S3) 中指定的位置。可搭配使用 Amazon S3 中已備份的事件日誌與 Spark UI，即可在工作運作時即時使用，也可在工作完成後使用。當日誌保留在 Amazon S3 中時， AWS Glue 主控台中的 Spark UI 可以檢視它們。 ## 許可 若要在 AWS Glue 主控台中使用 Spark UI，您可以使用`UseGlueStudio`或新增所有個別服務 APIs。所有 API 都需要完全使用 Spark UI，但使用者可以在 IAM 許可中新增其服務 API 來存取 SparkUI 功能，以進行精細存取。 `RequestLogParsing` 最為重要，因為其會執行日誌剖析。其餘 API 用於讀取各自的剖析資料。例如，`GetStages` 可讓您存取 Spark 任務所有階段的資料。 映射到 `UseGlueStudio` 的 Spark UI 服務 API 清單如以下範例政策中所示。下面的政策提供僅限使用 Spark UI 功能的存取權。若要新增更多許可，例如 Amazon S3 和 IAM，請參閱[為 建立自訂 IAM 政策 AWS Glue Studio。 ](https://docs.aws.amazon.com/glue/latest/dg/getting-started-min-privs.html#getting-started-all-gs-privs.html) 映射到 `UseGlueStudio` 的 Spark UI 服務 API 清單如以下範例政策中所示。使用 Spark UI 服務 API 時，請使用下列命名空間：`glue:`。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "AllowGlueStudioSparkUI", "Effect": "Allow", "Action": [ "glue:RequestLogParsing", "glue:GetLogParsingStatus", "glue:GetEnvironment", "glue:GetJobs", "glue:GetJob", "glue:GetStage", "glue:GetStages", "glue:GetStageFiles", "glue:BatchGetStageFiles", "glue:GetStageAttempt", "glue:GetStageAttemptTaskList", "glue:GetStageAttemptTaskSummary", "glue:GetExecutors", "glue:GetExecutorsThreads", "glue:GetStorage", "glue:GetStorageUnit", "glue:GetQueries", "glue:GetQuery" ], "Resource": [ "*" ] } ] } ``` ------ ## 限制 + AWS Glue 主控台中的 Spark UI 不適用於 2023 年 11 月 20 日之前發生的任務執行，因為它們是舊版日誌格式。 + AWS Glue 主控台中的 Spark UI 支援滾動日誌 for AWS Glue 4.0，例如串流任務中預設產生的日誌。所有產生的滾動日誌事件檔案總和上限為 2 GB。對於沒有滾動日誌支援 AWS Glue 的任務，SparkUI 支援的日誌事件檔案大小上限為 0.5 GB。 + 對於只能由您的 VPC 存取的 Amazon S3 儲存貯體中存放的 Spark 事件日誌，Serverless Spark UI 不適用。 ## 範例：Apache Spark Web UI 此範例顯示如何使用 Spark UI 了解工作效能。螢幕擷取畫面顯示自我管理的 Spark 歷史記錄伺服器提供的 Spark Web UI。 AWS Glue 主控台中的 Spark UI 提供類似的檢視。如需有關使用 Spark Web UI 的詳細資訊，請參閱《Spark 文件》中的 [Web UI](https://spark.apache.org/docs/3.3.0/web-ui.html)。 以下是 Spark 應用程式的範例，它會讀取兩個資料來源、執行聯結轉換，然後以 Parquet 格式將其寫入至 Amazon S3。 ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from pyspark.sql.functions import count, when, expr, col, sum, isnull from pyspark.sql.functions import countDistinct from awsglue.dynamicframe import DynamicFrame args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME']) df_persons = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/persons.json") df_memberships = spark.read.json("s3://awsglue-datasets/examples/us-legislators/all/memberships.json") df_joined = df_persons.join(df_memberships, df_persons.id == df_memberships.person_id, 'fullouter') df_joined.write.parquet("s3://aws-glue-demo-sparkui/output/") job.commit() ``` 下列 DAG 視覺化顯示此 Spark 任務中的不同階段。 ![\[Spark UI 的螢幕擷取畫面顯示任務 0 的 2 個已完成階段。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/spark-ui1.png) 下列任務的事件時間軸顯示不同 Spark 執行器的啟動、執行和終止。 ![\[Spark UI 的螢幕擷取畫面顯示不同 Spark 執行器的完成、失敗和作用中階段。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/spark-ui2.png) 下列畫面顯示 SparkSQL 查詢計畫的詳細資訊： + 已剖析的邏輯計畫 + 已分析的邏輯計畫 + 已最佳化的邏輯計畫 + 要執行的實體計畫 ![\[SparkSQL 查詢計畫：已剖析、已分析和已最佳化的邏輯計畫，以及要執行的實體計畫。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/spark-ui3.png) **Topics** + [許可](#monitor-spark-ui-limitations-permissions) + [限制](#monitor-spark-ui-limitations) + [範例：Apache Spark Web UI](#monitor-spark-ui-limitations-example) + [為 AWS Glue 任務啟用 Apache Spark web UI](monitor-spark-ui-jobs.md) + [啟動 Spark 歷史記錄伺服器](monitor-spark-ui-history.md) # 為 AWS Glue 任務啟用 Apache Spark web UI 您可以使用 Apache Spark Web UI 來監控和偵錯在 AWS Glue 任務系統上執行的 AWS Glue ETL 任務。您可以使用 AWS Glue 主控台或 AWS Command Line Interface (AWS CLI) 來設定 Spark UI。 每 30 秒，AWS Glue 會將 Spark 事件日誌備份至您指定的 Amazon S3 路徑。 **Topics** + [設定 Spark UI (主控台)](#monitor-spark-ui-jobs-console) + [設定 Spark UI (AWS CLI)](#monitor-spark-ui-jobs-cli) + [使用筆記本為工作階段設定 Spark UI](#monitor-spark-ui-sessions) + [啟用滾動日誌](#monitor-spark-ui-rolling-logs) ## 設定 Spark UI (主控台) 使用 AWS 管理主控台，依照以下步驟來設定 Spark UI。建立 AWS Glue 任務時，預設會啟用 Spark UI。 **建立或編輯工作時開啟 Spark UI** 1. 登入 AWS 管理主控台 並在 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 開啟 AWS Glue主控台。 1. 在導覽窗格中，選擇 **Jobs (任務)**。 1. 選擇**新增任務**，或選取現有任務。 1. 在**任務詳細資料**中，開啟**進階屬性**。 1. 在 **Spark UI** 索引標籤下方，選擇將 **Spark UI 日誌寫入 Amazon S3**。 1. 指定 Amazon S3 路徑以用於存放任務的 Spark 事件日誌。請注意，如果在工作中使用安全組態，加密也會套用至 Spark UI 日誌檔案。如需詳細資訊，請參閱[加密 寫入的資料 AWS Glue](encryption-security-configuration.md)。 1. 在 **Spark UI 記錄和監控組態**下方： + 如果您要在 AWS Glue 主控台中產生要檢視的日誌，請選取**標準**。 + 如果要產生日誌以在 Spark 歷史記錄伺服器中檢視，請選取**舊版**。 + 您也可以選擇產生兩者。 ## 設定 Spark UI (AWS CLI) 若要產生使用 Spark UI 檢視的日誌，請在 AWS Glue 主控台中使用 AWS CLI 將下列任務參數傳遞給AWS Glue任務。如需詳細資訊，請參閱[在 Glue AWS 任務中使用任務參數](aws-glue-programming-etl-glue-arguments.md)。 ``` '--enable-spark-ui': 'true', '--spark-event-logs-path': 's3://s3-event-log-path' ``` 若要將日誌分發至其舊版位置，請將 `--enable-spark-ui-legacy-path` 參數設定為 `"true"`。如果您不想要產生這兩種格式的日誌，請移除 `--enable-spark-ui` 參數。 ## 使用筆記本為工作階段設定 Spark UI **警告** AWS Glue 互動式工作階段目前不支援主控台中的 Spark UI。設定 Spark 歷史記錄伺服器。 如果您使用 AWS Glue 筆記本，請在開始工作階段之前設定 SparkUI 組態。為此，請使用 `%%configure` 儲存格魔術命令： ``` %%configure { “--enable-spark-ui”: “true”, “--spark-event-logs-path”: “s3://path” } ``` ## 啟用滾動日誌 為 AWS Glue 任務啟用 SparkUI 和滾動日誌事件檔案有幾個優點： + 滾動日誌事件檔案 – 啟用滾動日誌事件檔案後， 會針對任務執行的每個步驟 AWS Glue 產生個別日誌檔案，讓您更輕鬆地識別特定階段或轉換的特定問題並進行疑難排解。 + 更好的日誌管理 – 滾動日誌事件檔案有助於更有效率地管理日誌檔案。日誌不是單一但可能很大的日誌檔案，而是會根據任務執行階段分區成更小、更易於管理的檔案。這可以簡化日誌封存、分析和故障診斷。 + 改善容錯能力 – 如果 AWS Glue 任務失敗或中斷，滾動日誌事件檔案可以提供有關最後一個成功階段的寶貴資訊，讓您更輕鬆地從該點繼續任務，而不是從頭開始。 + 成本最佳化 – 透過啟用滾動日誌事件檔案，可以節省與日誌檔案相關聯的儲存成本。您可以儲存更小、更易於管理的日誌檔案，而非儲存單一、可能很大的日誌檔案，這可能更具成本效益，尤其對於長時間執行或複雜任務。 在新環境中，使用者可以透過以下方法明確啟用滾動日誌： ``` '—conf': 'spark.eventLog.rolling.enabled=true' ``` 或 ``` '—conf': 'spark.eventLog.rolling.enabled=true —conf spark.eventLog.rolling.maxFileSize=128m' ``` 啟動滾動日誌時，`spark.eventLog.rolling.maxFileSize` 會指定事件日誌檔案的大小上限，然後再滾動。如果未指定此可選參數，其會預設為 128 MB。最小值為 10 MB。 所有產生的滾動日誌事件檔案總和上限為 2 GB。對於沒有滾動日誌支援 AWS Glue 的任務，SparkUI 支援的日誌事件檔案大小上限為 0.5 GB。 可以透過傳遞其他組態來關閉串流工作的滾動日誌。請注意，非常大的日誌檔案可能需要昂貴的維護成本。 若要關閉滾動日誌，請提供下列組態： ``` '--spark-ui-event-logs-path': 'true', '--conf': 'spark.eventLog.rolling.enabled=false' ``` # 啟動 Spark 歷史記錄伺服器 可使用 Spark 歷史記錄伺服器，在您自己的基礎設施中視覺化 Spark 日誌。您可以在 AWS Glue 主控台中看到在 AWS Glue 4.0 或更新版本上執行 AWS Glue 任務的相同視覺效果，其中包含以標準 （而非舊版） 格式產生的日誌。如需詳細資訊，請參閱[使用 Apache Spark web UI 監控任務](monitor-spark-ui.md)。 您可以使用在 EC2 執行個體上託管伺服器的 AWS CloudFormation 範本來啟動 Spark 歷史記錄伺服器，或使用 Docker 在本機啟動。 **Topics** + [使用 啟動 Spark 歷史記錄伺服器並檢視 Spark UI AWS CloudFormation](#monitor-spark-ui-history-cfn) + [啟動 Spark 歷史記錄伺服器並使用 Docker 檢視 Spark UI](#monitor-spark-ui-history-local) ## 使用 啟動 Spark 歷史記錄伺服器並檢視 Spark UI AWS CloudFormation 您可以使用 AWS CloudFormation 範本來啟動 Apache Spark 歷史記錄伺服器，並檢視 Spark Web UI。這些範本是範例，您應加以修改以符合您的需求。 **使用 啟動 Spark 歷史記錄伺服器並檢視 Spark UI CloudFormation** 1. 選擇下表中的其中一個 **Launch Stack (啟動堆疊)** 按鈕。這會在 CloudFormation 主控台上啟動堆疊。 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitor-spark-ui-history.html) 1. 在 **Specify template (指定範本)** 頁面上，選擇 **Next (下一步)**。 1. 在 **Specify stack details (指定堆疊詳細資訊)** 頁面上，輸入 **Stack name (堆疊名稱)**。在 **Parameters** (參數) 下輸入其他資訊。 1. **Spark UI 組態** 請提供下列資訊： + **IP address range (IP 地址範圍)** - 可用於檢視 Spark UI 的 IP 地址範圍。如果您想要限制來自特定 IP 地址範圍的存取，您應該使用自訂值。 + **History server port (歷史記錄伺服器連接埠)** - Spark UI 的連接埠。您可以使用預設值。 + **Event log directory (事件日誌目錄)** - 選擇從 AWS Glue 任務或開發端點存放 Spark 事件日誌的位置。您必須使用 **s3a://** 做為事件日誌路徑配置。 + **Spark package location (Spark 套件位置)** - 您可以使用預設值。 + **Keystore path (金鑰存放區路徑)** - HTTPS 的 SSL/TLS 金鑰存放區路徑。如果您要使用自訂金鑰存放區檔案，可以在此指定 S3 路徑 `s3://path_to_your_keystore_file`。如果您將此參數保留空白，將會產生並使用以自我簽署憑證為基礎的金鑰存放區。 + **Keystore password** (金鑰存放區密碼) – 輸入 HTTPS 的 SSL/TLS 金鑰存放區密碼。 1. **EC2 執行個體組態** 請提供下列資訊： + **Instance type (執行個體類型)** - 託管 Spark 歷史記錄伺服器的 Amazon EC2 執行個體類型。由於此範本啟動您帳戶中的 Amazon EC2 執行個體，因此會另外向您的帳戶收取 Amazon EC2 費用。 + **Latest AMI ID (最新的 AMI ID)** - Spark 歷史記錄伺服器執行個體之 Amazon Linux 2 的 AMI ID。您可以使用預設值。 + **VPC ID ** - Spark 歷史記錄伺服器執行個體的 Virtual Private Cloud (VPC) ID。您可以使用您帳戶中可用的任何 VPC，不建議使用預設 VPC 搭配[預設網路 ACL](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-network-acls.html#default-network-acl)。如需詳細資訊，請參閱 *Amazon VPC 使用者指南*中的[預設 VPC 和預設子網路](https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html)以及[建立 VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC)。 + **Subnet ID (子網路 ID)** - Spark 歷史記錄伺服器執行個體的 ID。您可以使用 VPC 中的任何子網路。您必須能夠從用戶端連線到網路以連接至子網路。如果您要透過網際網路存取，必須使用在路由表中具有網際網路閘道的公有子網路。 1. 選擇**下一步**。 1. 在 **Configure stack options** (設定堆疊選項) 頁面上，若要使用目前使用者憑證來決定 CloudFormation 如何在堆疊中建立、修改或刪除資源，請選擇 **Next** (下一步)。您也可以在**許可**區段指定一個角色，而非使用目前使用者的許可，然後選擇**下一步**。 1. 在 **Review (檢閱)** 頁面上檢閱範本。 選取**我確認 CloudFormation 可能會建立 IAM 資源**，然後選擇**建立堆疊**。 1. 等待堆疊建立。 1. 開啟 **Outputs (輸出)** 標籤。 1. 如果您使用公有子網路，請複製 **SparkUiPublicUrl** 的 URL。 1. 如果您使用私有子網路 , 請複製 **SparkUiPrivateUrl** 的 URL。 1. 開啟 Web 瀏覽器，然後貼入該 URL。這可讓您使用 HTTPS 在指定連接埠上存取伺服器。您的瀏覽器可能會無法辨識伺服器的憑證，在此情況下，您必須覆寫其保護並繼續。 ## 啟動 Spark 歷史記錄伺服器並使用 Docker 檢視 Spark UI 如果您偏好本機存取 (不使用 EC2 執行個體做為 Apache Spark 歷史記錄伺服器)，您也可以使用 Docker 來啟動 Apache Spark 歷史記錄伺服器，並在本機檢視 Spark UI。此 Dockerfile 為範例，您應該修改以符合您的需求。 **先決條件** 如需有關如何在筆記型電腦上安裝 Docker 的資訊，請參閱 [Docker 引擎社群](https://docs.docker.com/install/)。 **啟動 Spark 歷史記錄伺服器並使用 Docker 在本機檢視 Spark UI** 1. 從 GitHub 下載檔案。 從 [ AWS Glue 程式碼範例](https://github.com/aws-samples/aws-glue-samples/tree/master/utilities/Spark_UI/)下載 Dockerfile 和 `pom.xml`。 1. 決定是否要使用您的使用者憑證或聯合身分使用者憑證來存取 AWS。 + 若要使用目前的使用者登入資料進行存取 AWS，請在 `docker run`命令`AWS_SECRET_ACCESS_KEY`中取得要用於 ` AWS_ACCESS_KEY_ID`和 的值。如需詳細資訊，請參閱《 IAM 使用者指南》**中的[管理 IAM 使用者的存取金鑰](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html)。 + 若要使用 SAML 2.0 聯合身分使用者存取 AWS，請取得 ` AWS_ACCESS_KEY_ID`、 `AWS_SECRET_ACCESS_KEY`和 的值` AWS_SESSION_TOKEN`。如需詳細資訊，請參閱[請求暫時安全憑證](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_request.html)。 1. 判斷您的事件日誌目錄的位置，以在 `docker run` 命令中使用。 1. 使用本機目錄中的檔案建置 Docker 映像檔，對其使用名稱 ` glue/sparkui` 以及標籤 `latest`。 ``` $ docker build -t glue/sparkui:latest . ``` 1. 建立並啟動 Docker 容器。 在下列命令中，使用先前在步驟 2 與 3 中取得的值。 1. 若要使用您的使用者憑證建立 Docker 容器，請使用類似如下的命令。 ``` docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog -Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY" -p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer" ``` 1. 要使用暫時憑證建立 Docker 容器，請使用 ` org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider` 做為提供者，並提供在步驟 2 中取得的憑證值。如需詳細資訊，請參閱 *Hadoop：與 Amazon Web Services 整合*文件中的[將工作階段憑證與 TemporaryAWSCredentialsProvider 搭配使用](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html#Using_Session_Credentials_with_TemporaryAWSCredentialsProvider)。 ``` docker run -itd -e SPARK_HISTORY_OPTS="$SPARK_HISTORY_OPTS -Dspark.history.fs.logDirectory=s3a://path_to_eventlog -Dspark.hadoop.fs.s3a.access.key=AWS_ACCESS_KEY_ID -Dspark.hadoop.fs.s3a.secret.key=AWS_SECRET_ACCESS_KEY -Dspark.hadoop.fs.s3a.session.token=AWS_SESSION_TOKEN -Dspark.hadoop.fs.s3a.aws.credentials.provider=org.apache.hadoop.fs.s3a.TemporaryAWSCredentialsProvider" -p 18080:18080 glue/sparkui:latest "/opt/spark/bin/spark-class org.apache.spark.deploy.history.HistoryServer" ``` **注意** 這些組態參數來自 [ Hadoop-AWS 模組](https://hadoop.apache.org/docs/stable/hadoop-aws/tools/hadoop-aws/index.html)。您可能需要根據您的使用案例來新增具體的組態。例如：隔離區域中的使用者需要設定 ` spark.hadoop.fs.s3a.endpoint`。 1. 在瀏覽器中開啟 `http://localhost:18080` 以在本機檢視 Spark UI。 # 使用 AWS Glue 任務執行洞察進行監控 AWS Glue 任務執行洞見是 的一項功能 AWS Glue ，可簡化 AWS Glue 任務的任務偵錯和最佳化。 AWS Glue 提供 [Spark UI](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui.html)，以及用於監控 AWS Glue 任務的 [CloudWatch 日誌和指標](https://docs.aws.amazon.com/glue/latest/dg/monitor-cloudwatch.html)。使用此功能，您可以取得 AWS Glue 任務執行的相關資訊： + 失敗 AWS Glue 的任務指令碼行號。 + 在任務失敗之前，Spark 查詢計劃中最近執行的 Spark 動作。 + 與時間排序日誌串流中顯示的故障相關的 Spark 異常事件。 + 根本原因分析和修正問題的建議動作 (例如調校指令碼)。 + 常見的 Spark 事件 (與 Spark 動作相關的日誌訊息)，其中包含解決根本原因的建議動作。 您可以使用 AWS Glue CloudWatch 日誌中的兩個新日誌串流來取得所有這些洞見。 ## 要求 AWS Glue 任務執行洞見功能適用於 2.0 版和更新 AWS Glue 版本。您可以遵循現有任務的[遷移指南](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html)，從較舊 AWS Glue 版本升級這些任務。 ## 啟用 AWS Glue ETL 任務的任務執行洞察 您可以透過 AWS Glue Studio 或 CLI 啟用任務執行洞察。 ### AWS Glue Studio 透過 建立任務時 AWS Glue Studio，您可以在任務**詳細資訊**索引標籤下啟用或停用任務執行洞見。檢查是否已選中**產生任務洞見**。 ![\[在 AWS Glue Studio中啟用任務執行見解。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-job-run-insights-1.png) ### 命令列 如果透過 CLI 建立任務，則可以使用單個新的[任務參數](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-glue-arguments.html)啟動任務：`--enable-job-insights = true`。 預設情況下，在 [AWS Glue 連續記錄](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html)使用的相同預設日誌群組下建立任務執行見解日誌串流, 即 `/aws-glue/jobs/logs-v2/`。您可以使用相同的連續記錄引數集來設定自訂日誌群組名稱、日誌篩選條件和日誌群組組態。如需詳細資訊，請參閱[啟用 AWS Glue 任務的持續記錄](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging-enable.html)。 ## 存取 CloudWatch 中的任務執行見解日誌串流 啟用任務執行見解功能後，當任務執行失敗時，可能會建立兩個日誌串流。任務成功完成後，兩個串流均不會產生。 1. *異常分析日誌串流*：`-job-insights-rca-driver`。此串流提供下列資訊： + 造成失敗 AWS Glue 的任務指令碼行號。 + 在 Spark 查詢計劃 (DAG) 中最近執行的 Spark 動作。 + Spark 驅動程式和執行器中與異常相關的簡明時間排序事件。您可以從中找到詳細資訊，例如完整的錯誤訊息、失敗的 Spark 任務及其執行器 ID，這些資訊可協助您專注於特定執行器的日誌串流，以便在需要時進行更深入的調查。 1. *基於規則的見解串流*： + 根本原因分析和關於如何修正錯誤的建議 (例如使用特定的任務參數以最佳化效能)。 + 作為根本原因分析基礎的相關 Spark 事件和建議的動作。 **注意** 僅當任何異常 Spark 事件可用於失敗的任務執行時，第一個串流才會存在；只有在見解可用於失敗的任務執行時，第二個串流才存在。例如，如果您的任務成功完成，則不會產生任何串流；如果任務失敗，但沒有可以與故障場景相符的服務定義規則，則僅產生第一個串流。 如果任務是從 建立 AWS Glue Studio，則任務執行詳細資訊索引標籤 （任務執行洞見） 下也會提供上述串流的連結，例如「簡潔和合併錯誤日誌」和「錯誤分析和指引」。 ![\[Job Run Details (任務執行詳細資訊) 頁面包含指向日誌串流的連結。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-job-run-insights-2.png) ## AWS Glue 任務執行洞察的範例 在本部分中，我們展示任務執行見解功能如何協助您解決失敗任務中問題的範例。在此範例中，使用者忘記在 AWS Glue 任務中匯入所需的模組 （張量流程），以分析和建置其資料的機器學習模型。 ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job from pyspark.sql.types import * from pyspark.sql.functions import udf,col args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) data_set_1 = [1, 2, 3, 4] data_set_2 = [5, 6, 7, 8] scoresDf = spark.createDataFrame(data_set_1, IntegerType()) def data_multiplier_func(factor, data_vector): import tensorflow as tf with tf.compat.v1.Session() as sess: x1 = tf.constant(factor) x2 = tf.constant(data_vector) result = tf.multiply(x1, x2) return sess.run(result).tolist() data_multiplier_udf = udf(lambda x:data_multiplier_func(x, data_set_2), ArrayType(IntegerType(),False)) factoredDf = scoresDf.withColumn("final_value", data_multiplier_udf(col("value"))) print(factoredDf.collect()) ``` 如果沒有任務執行見解功能，當任務失敗時，您只會看到 Spark 擲回的訊息： `An error occurred while calling o111.collectToPython. Traceback (most recent call last):` 該訊息含糊不清，並限制了您的偵錯體驗。在此情況下，此功能為您提供了兩個 CloudWatch 日誌串流中的其他見解： 1. `job-insights-rca-driver` 日誌串流： + *異常事件*：此日誌串流提供與從 Spark 驅動程式和不同分佈式工作者收集的故障相關的 Spark 異常事件。這些事件可協助您了解例外狀況的時間順序傳播，因為故障的程式碼會跨分散在 AWS Glue 工作者的 Spark 任務、執行器和階段執行。 + *行號*：此日誌串流標識第 21 行，該行叫用以匯入導致失敗的 Python 模組；它還標識第 24 行，其中叫用 Spark Action `collect()`，作為指令碼中最後執行的一行。 ![\[job-insights-rca-driver 日誌串流。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-job-run-insights-3.png) 1. `job-insights-rule-driver` 日誌串流： + *根本原因和建議*：除了指令碼中故障的行號和上次執行的行號之外，此日誌串流會顯示根本原因分析和建議，讓您遵循 AWS Glue 文件並設定必要的任務參數，以便在 AWS Glue 任務中使用額外的 Python 模組。 + *基礎事件*：此日誌串流還顯示了使用服務定義規則評估的 Spark 異常事件，以推斷根本原因並提供建議。 ![\[job-insights-rule-driver 日誌串流。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-job-run-insights-4.png) # 使用 Amazon CloudWatch 監控 您可以使用 Amazon CloudWatch 來監控 AWS Glue；該服務會收集並處理來自 AWS Glue 的原始資料，進而將這些資料轉換為便於讀取且幾近即時的指標。這些統計資料會記錄兩週的時間，讓您可以存取歷史資訊，以更清楚 Web 應用程式或服務的執行效能。根據預設，系統會自動將 AWS Glue 指標資料傳送至 CloudWatch。如需更多詳細資訊，請參閱 *Amazon CloudWatch 使用者指南*中的[什麼是 Amazon CloudWatch？](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/WhatIsCloudWatch.html)，以及 [AWS Glue 指標](monitoring-awsglue-with-cloudwatch-metrics.md#awsglue-metrics)。 **連續記錄** AWS Glue 也支援即時持續記錄 AWS Glue 任務。當任務的持續記錄啟用時，您就可以在 AWS Glue 主控台或 CloudWatch 主控台儀表板檢視即時日誌。如需詳細資訊，請參閱[記錄 AWS Glue 任務](monitor-continuous-logging.md)。 **可觀測性指標** 啟用**任務可觀測性指標**時，會在任務執行時產生其他 Amazon CloudWatch 指標。使用 AWS Glue 可觀測性指標產生 AWS Glue 內部所發生之事件的深入解析，以改善問題的分類和分析。 **Topics** + [使用 Amazon CloudWatch 指標監控 AWS Glue](monitoring-awsglue-with-cloudwatch-metrics.md) + [在 AWS Glue 任務設定檔上設定 Amazon CloudWatch 警示](monitor-profile-glue-job-cloudwatch-alarms.md) + [記錄 AWS Glue 任務](monitor-continuous-logging.md) + [使用 AWS Glue 可觀測性指標進行監控](monitor-observability.md) # 使用 Amazon CloudWatch 指標監控 AWS Glue 您可以使用 AWS Glue 任務分析器來分析及監控 AWS Glue 操作。它會收集來自 AWS Glue 任務的原始資料，將這些資料處理成可讀取且幾近即時的指標並存放於 Amazon CloudWatch。系統會將這些統計資料保留於 CloudWatch 中並加以彙整，以便您存取歷史資訊，讓您更深入掌握應用程式的執行情況。 **注意** 啟用任務指標並建立 CloudWatch 自訂指標時，您可能會產生額外費用。如需詳細資訊，請參閱 [Amazon CloudWatch 定價](https://aws.amazon.com/cloudwatch/pricing/)。 ## AWS Glue 指標概觀 當您與 AWS Glue 互動時，它會傳送指標至 CloudWatch。您可使用 AWS Glue 主控台 (偏好的方法)、CloudWatch 主控台儀表板或 AWS Command Line Interface (AWS CLI) 中檢視這些指標。 **使用 AWS Glue 主控台儀表板檢視指標** 您能檢視任務指標的摘要或詳細圖表，或是任務執行的詳細圖表。 1. 登入 AWS 管理主控台 並在 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 開啟 AWS Glue 主控台。 1. 在導覽窗格中，選擇**任務執行監控**。 1. 在**任務執行**中，選擇**動作**以停止目前正在執行的任務、檢視任務或倒轉任務書籤。 1. 選取任務，然後選擇**檢視執行詳細資訊**，以檢視有關任務執行的其他資訊。 **使用 CloudWatch 主控台儀表板檢視指標** 指標會先依服務命名空間分組，再依各命名空間內不同的維度組合分類。 1. 在 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 開啟 CloudWatch 主控台。 1. 在導覽窗格中，選擇**指標**。 1. 選擇 **Glue (Glue)** 命名空間。 **使用 檢視指標 AWS CLI** + 在命令提示中，使用下列命令。 ``` 1. aws cloudwatch list-metrics --namespace Glue ``` AWS Glue 每 30 秒就會向 CloudWatch 回報指標，且 CloudWatch 指標儀表板也設定成每分鐘顯示一次指標。AWS Glue 指標表示先前回報數值中的差異值。適當時，指標儀表板將會彙總 (加總) 30 秒的值，以取得最後完整一分鐘的值。 ### AWS Glue Spark 任務的指標行為 當指令碼中的 `GlueContext` 進行初始化時，系統便已啟用 AWS Glue 指標。通常，唯有在 Apache Spark 任務快結束時，系統才會更新指標。這些指標代表目前所有完成的 Spark 任務彙總值。 但是，AWS Glue 傳遞至 CloudWatch 的 Spark 指標通常是絕對值，可代表這些指標在回報時的目前狀態。AWS Glue 每 30 秒就會向 CloudWatch 回報這些指標，且指標儀表板通常會顯示過去 1 分鐘內收到的資料點平均值。 AWS Glue 指標名稱皆有以下其中一個類型的前綴： + `glue.driver.` – 若是以此字首為名稱開頭，即代表該指標屬於 Spark 驅動程式中所有執行器的彙總 AWS Glue 指標，或是對應至 Spark 驅動程式的 Spark 指標。 + `glue.`*executorId*`.` – *executorId* 是特定 Spark 執行器的數量。它對應至日誌中的執行器。 + `glue.ALL.` – 名稱開頭為此字首的指標即是所有 Spark 執行器的彙總值。 ## AWS Glue 指標 AWS Glue 設定檔，並每 30 秒將下列指標傳送至 CloudWatch，指標 AWS Glue 儀表板每分鐘報告一次： | 指標 | Description | | --- | --- | | `glue.driver.aggregate.bytesRead` | 由所有執行器中執行的所有已完成 Spark 任務，從所有資料來源讀取的位元組數。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：位元組 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 此指標的使用方式與 `glue.ALL.s3.filesystem.read_bytes` 指標相同，差別在於此指標會在 Spark 任務結束時更新並擷取非 S3 資料來源。 | | `glue.driver.aggregate.elapsedTime` | ETL 經過時間 (以毫秒為單位) (不包括任務啟動程序時間)。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：毫秒 可用於判斷任務執行平均所需的時間。 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numCompletedStages` | 任務中已完成階段的數量。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numCompletedTasks` | 任務中已完成任務的數目。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.numFailedTasks` | 失敗的任務數量。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 這些資料可用來設定警示，以防止增加失敗，這些失敗可能會提出資料、叢集或指令碼的異常情況。 | | `glue.driver.aggregate.numKilledTasks` | 終止的任務數量。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.recordsRead` | 由所有執行器中執行的所有已完成 Spark 任務，從所有資料來源讀取的記錄數。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 此指標的使用方式類似於 `glue.ALL.s3.filesystem.read_bytes` 指標，差別在於此指標會在 Spark 任務結束時更新。 | | `glue.driver.aggregate.shuffleBytesWritten` | 自上一個報告以來，所有執行器寫入隨機播放資料的位元組數 （由 AWS Glue 指標儀表板彙總為上一分鐘為此目的寫入的位元組數）。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：位元組 可用於監視：任務中的資料隨機播放 (大型聯結、GroupBy、重新分割、聯合)。 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.aggregate.shuffleLocalBytesRead` | 自上一個報告以來，所有執行器讀取以在它們之間隨機播放資料的位元組數 （由 AWS Glue 指標儀表板彙總為上一分鐘為此目的讀取的位元組數）。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 單位：位元組 可用於監視：任務中的資料隨機播放 (大型聯結、GroupBy、重新分割、聯合)。 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.BlockManager.disk.diskSpaceUsed_MB` | 在所有執行器中使用的 MB 磁碟空間數目。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（規格）。 有效的統計數字：平均。這是 Spark 指標，報告為絕對值。 單位：MB 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.ExecutorAllocationManager.executors.numberAllExecutors` | 目前正在執行中任務執行器的數量。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（規格）。 有效的統計數字：平均。這是 Spark 指標，報告為絕對值。 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors` | 滿足目前負載所需的最大值 (主動執行中和擱置中) 任務執行器數目。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（規格）。 有效的統計數字：上限。這是 Spark 指標，報告為絕對值。 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.jvm.heap.usage` `glue.`*executorId*`.jvm.heap.usage` `glue.ALL.jvm.heap.usage` | 此驅動程式之 JVM 堆疊所使用的記憶體佔比 (比例：0-1)、由 executorId 所辨識的執行器，或所有執行器。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（規格）。 有效的統計數字：平均。這是 Spark 指標，報告為絕對值。 單位：百分比 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.jvm.heap.used` `glue.`*executorId*`.jvm.heap.used` `glue.ALL.jvm.heap.used` | JVM 堆積針對驅動程式、由 *executorId* 識別的執行器或所有執行器，所使用的記憶體位元組數目。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（規格）。 有效的統計數字：平均。這是 Spark 指標，報告為絕對值。 單位：位元組 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.s3.filesystem.read_bytes` `glue.`*executorId*`.s3.filesystem.read_bytes` `glue.ALL.s3.filesystem.read_bytes` | 自上次報告以來，驅動程式、*executorId* 識別的執行器或 ALL 執行器從 Amazon S3 讀取的位元組數 （由 AWS Glue 指標儀表板彙總為上一分鐘讀取的位元組數）。 有效維度：`JobName`、`JobRunId` 以及 `Type` (計量)。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 AWS Glue 指標儀表板曲線下的區域可用來視覺化比較兩個不同任務執行讀取的位元組。 單位：位元組。 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 產生的資料可用於： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.s3.filesystem.write_bytes` `glue.`*executorId*`.s3.filesystem.write_bytes` `glue.ALL.s3.filesystem.write_bytes` | 自上次報告以來，驅動程式、*executorId* 識別的執行器或 ALL 執行器寫入 Amazon S3 的位元組數 （由 AWS Glue 指標儀表板彙總為前一分鐘內寫入的位元組數）。 有效維度：`JobName`、`JobRunId` 以及 `Type` (計量)。 有效的統計數字：總和。此指標是來自上次報告值的差異值，因此在 AWS Glue 指標儀表板上，SUM 統計資料會用於彙總。 AWS Glue 指標儀表板曲線下的區域可用來視覺化比較兩個不同任務執行所寫入的位元組。 單位：位元組 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.streaming.numRecords` | 在微批次中接收的記錄數目。此指標僅適用於 2.0 版及更高 AWS Glue 版本的 AWS Glue 串流任務。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和、上限、下限、平均、百分位數 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.streaming.batchProcessingTimeInMs` | 處理批次所需的時間 (以毫秒為單位)。此指標僅適用於 2.0 版及更高 AWS Glue 版本的 AWS Glue 串流任務。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（計數）。 有效的統計數字：總和、上限、下限、平均、百分位數 單位：計數 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | | `glue.driver.system.cpuSystemLoad` `glue.`*executorId*`.system.cpuSystemLoad` `glue.ALL.system.cpuSystemLoad` | 驅動程式使用的 CPU 系統負載佔比 (比例：0-1)、由 *executorId* 所辨識的執行器，或所有執行器。 有效維度： `JobName`( AWS Glue 任務的名稱）、 `JobRunId`(JobRun ID 或 `ALL`) 和 `Type`（規格）。 有效的統計數字：平均。此指標會報告為絕對值。 單位：百分比 可用於監控： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) 使用資料的一些方法： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/monitoring-awsglue-with-cloudwatch-metrics.html) | ## AWS Glue 指標的維度 AWS Glue 指標使用 AWS Glue 命名空間，並提供下列維度的指標： | 維度 | Description | | --- | --- | | `JobName` | 此維度會篩選特定任務之所有 AWS Glue 任務執行的指標。 | | `JobRunId` | 此維度會依 JobRun ID 或 篩選特定 AWS Glue 任務執行的指標`ALL`。 | | `Type` | 此維度會依 `count` (彙總數字) 或 `gauge` (某個時間點的值) 篩選指標。 | 如需更多資訊，請參閱 [Amazon CloudWatch 使用者指南](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)。 # 在 AWS Glue 任務設定檔上設定 Amazon CloudWatch 警示 AWS Glue 指標也可於 Amazon CloudWatch 中使用。您可以針對已排程任務的任何 AWS Glue 指標，來設定警示。 下列是設定警示的幾個常見案例： + 執行任務的記憶體用盡 (OOM)：設定警示，當 AWS Glue 任務的驅動程式或執行器之記憶體使用量超過正常平均值時，發出警示。 + 落後的執行器：設定警示，當 AWS Glue 任務中執行器的數量長時間持續低於某個閾值時，發出警示。 + 資料後端記錄或重新處理：使用 CloudWatch 的數學表達式，比較任務流程中個別任務的指標。然後，您就可以根據產生的運算式數值 (例如任務所寫入位元組的比率，以及後續任務所讀取的位元組數)，來觸發警示。 如需設定警示的詳細指示，請參閱 *[Amazon CloudWatch Events 使用者指南](https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/)*中的[建立或編輯 CloudWatch 警示](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ConsoleAlarms.html)。 如需使用 CloudWatch 的監控與除錯案例，請參閱[任務監控與偵錯](monitor-profile-glue-job-cloudwatch-metrics.md)。 # 記錄 AWS Glue 任務 在 AWS Glue 5.0 中，所有任務都具有即時記錄功能。此外，可以指定自訂組態選項來量身打造記錄行為。這些選項包括設定 Amazon CloudWatch 日誌群組名稱、 Amazon CloudWatch 日誌串流字首 （在 AWS Glue 任務執行 ID 和驅動程式/執行器 ID 之前），以及日誌訊息的日誌轉換模式。這些組態可讓您在具有不同過期政策的自訂 Amazon CloudWatch 日誌群組中彙總日誌。此外，可以使用自訂日誌串流字首和轉換模式，更有效地分析日誌。此自訂層級可讓您根據特定需求來最佳化日誌管理和分析。 ## AWS Glue 5.0 中的記錄行為 根據預設，系統會將系統日誌、Spark 協助程式日誌和使用者 AWS Glue 日誌寫入 中的`/aws-glue/jobs/error`日誌群組 Amazon CloudWatch。另一方面，使用者 stdout (標準輸出) 和 stderr (標準錯誤) 日誌預設會寫入到 `/aws-glue/jobs/output` 日誌群組。 ## 自訂記錄 可以使用下列任務引數來自訂預設日誌群組和日誌串流字首： + `--custom-logGroup-prefix`：可讓您指定 `/aws-glue/jobs/error` 和 `/aws-glue/jobs/output` 日誌群組的自訂字首。如果您提供自訂字首，日誌群組名稱的格式如下： + `/aws-glue/jobs/error` 將為 `/error` + `/aws-glue/jobs/output ` 將為 `/output` + `--custom-logStream-prefix`：可讓您為日誌群組中的日誌串流名稱指定自訂字首。如果您提供自訂字首，日誌串流名稱的格式如下： + `jobrunid-driver` 將為 `-driver` + `jobrunid-executorNum` 將為 `-executorNum` 自訂字首的驗證規則和限制： + 整個日誌串流名稱的長度必須介於 1 到 512 個字元之間。 + 自訂字首本身限制為 400 個字元。 + 自訂字首必須符合規則表達式模式 `[^:\$1]\$1` (允許的特殊字元為 '\$1'、'-' 和 '/')。 ## 使用自訂指令碼記錄器記錄應用程式特定訊息 您可以使用 AWS Glue 記錄器，在指令碼中記錄即時傳送到驅動程式日誌串流的任何應用程式特定訊息。 以下範例顯示 Python 指令碼。 ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) logger = glueContext.get_logger() logger.info("info message") logger.warn("warn message") logger.error("error message") ``` 以下範例顯示 Scala 指令碼。 ``` import com.amazonaws.services.glue.log.GlueLogger object GlueApp { def main(sysArgs: Array[String]) { val logger = new GlueLogger logger.info("info message") logger.warn("warn message") logger.error("error message") } } ``` ## 啟用進度列來顯示任務進度 AWS Glue 在`JOB_RUN_ID-progress-bar`日誌串流下提供即時進度列，以檢查 AWS Glue 任務執行狀態。目前它僅支援初始化 `glueContext` 的任務。如果您在未初始化 的情況下執行純 Spark 任務`glueContext`，則不會顯示 AWS Glue 進度列。 進度列每 5 秒顯示一次以下的最新進度。 ``` Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage] ``` ## 記錄的安全組態 Amazon CloudWatch 為 Amazon CloudWatch 日誌啟用安全組態時， 會使用包含安全組態名稱的特定命名模式 AWS Glue 建立日誌群組。 ### 使用安全組態命名日誌群組 預設和自訂日誌群組將如下所示： + **預設錯誤日誌群組：**`/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/error` + **預設輸出日誌群組：**`/aws-glue/jobs/Security-Configuration-Name-role/glue-job-role/output` + **自訂錯誤日誌群組 (AWS Glue 5.0)：** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/error` + **自訂輸出日誌群組 (AWS Glue 5.0)：** `custom-log-group-prefix/Security-Configuration-Name-role/glue-job-role/output` ### 所需的 IAM 許可 如果使用 Amazon CloudWatch Logs 啟用安全組態，則需要將 `logs:AssociateKmsKey` 許可新增至您的 IAM 角色許可。如果未包含該許可，則會停用連續記錄。 此外，若要設定 Amazon CloudWatch 日誌的加密，請遵循《Amazon [ Logs 使用者指南》中的使用 在 Amazon CloudWatch 日誌中加密日誌資料 AWS Key Management Service](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html)的指示。 Amazon CloudWatch ### 其他資訊 如需建立安全組態的詳細資訊，請參閱在 [AWS Glue 主控台上管理安全組態](https://docs.aws.amazon.com/glue/latest/dg/console-security-configurations.html)。 **Topics** + [AWS Glue 5.0 中的記錄行為](#monitor-logging-behavior-glue-50) + [自訂記錄](#monitor-logging-custom) + [使用自訂指令碼記錄器記錄應用程式特定訊息](#monitor-logging-script) + [啟用進度列來顯示任務進度](#monitor-logging-progress) + [記錄的安全組態 Amazon CloudWatch](#monitor-security-config-logging) + [啟用持續記錄 AWS Glue 4.0 和舊版任務](monitor-continuous-logging-enable.md) + [檢視 AWS Glue 任務的日誌](monitor-continuous-logging-view.md) # 啟用持續記錄 AWS Glue 4.0 和舊版任務 **注意** 在 AWS Glue 4.0 和舊版中，持續記錄是可用的功能。不過，隨著 AWS Glue 5.0 的推出，所有任務都具有即時記錄功能。如需 AWS Glue 5.0 中記錄功能和組態選項的詳細資訊，請參閱[記錄 AWS Glue 任務](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuous-logging.html)。 您可以使用 AWS Glue 主控台或透過 AWS Command Line Interface () 啟用持續記錄AWS CLI。 在您建立新任務、編輯現有任務，或是透過 AWS CLI啟用任務時，可以啟用持續記錄。 您也可以指定自訂組態選項，例如 Amazon CloudWatch 日誌群組名稱、 AWS Glue 任務執行 ID 驅動程式/執行器 ID 之前的 CloudWatch 日誌串流字首，以及日誌訊息的日誌轉換模式。這些組態可協助您在具有不同過期政策的自訂 CloudWatch 日誌群組中設定彙總日誌，並使用自訂日誌串流字首和轉換模式進一步分析它們。 **Topics** + [使用 AWS 管理主控台](#monitor-continuous-logging-enable-console) + [使用自訂指令碼記錄器記錄應用程式特定訊息](#monitor-continuous-logging-script) + [啟用進度列來顯示任務進度](#monitor-continuous-logging-progress) + [具有連續記錄的安全組態](#monitor-logging-encrypt-log-data) ## 使用 AWS 管理主控台 請依照下列步驟，使用 主控台在建立或編輯 AWS Glue 任務時啟用持續記錄。 **建立具有持續記錄的新 AWS Glue 任務** 1. 登入 AWS 管理主控台 並在 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 開啟 AWS Glue 主控台。 1. 在導覽窗格中，選擇 **ETL 任務**。 1. 選擇**視覺化的 ETL**。 1. 在**任務詳細資訊**索引標籤中，展開**進階屬性**部分。 1. 在**持續記錄**下，選取在 **CloudWatch 中啟用日誌**。 **啟用現有 AWS Glue 任務的持續記錄** 1. 在 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 開啟 AWS Glue 主控台。 1. 在導覽窗格中，選擇 **Jobs (任務)**。 1. 從 **Jobs (任務)** 清單中選擇現有的任務。 1. 選擇 **Action (動作)**、**Edit job (編輯任務)**。 1. 在**任務詳細資訊**索引標籤中，展開**進階屬性**部分。 1. 在**持續記錄**下，選取在 **CloudWatch 中啟用日誌**。 ### 使用 AWS CLI 若要啟用持續記錄，您可以將任務參數傳遞至 AWS Glue 任務。傳遞下列特殊任務參數，類似於其他 AWS Glue 任務參數。如需詳細資訊，請參閱[在 Glue AWS 任務中使用任務參數](aws-glue-programming-etl-glue-arguments.md)。 ``` '--enable-continuous-cloudwatch-log': 'true' ``` 您可以指定自訂 Amazon CloudWatch 日誌群組名稱。如果未指定，則預設日誌群組名稱為 `/aws-glue/jobs/logs-v2`。 ``` '--continuous-log-logGroup': 'custom_log_group_name' ``` 您可以指定自訂 Amazon CloudWatch 日誌串流字首。如果未指定，則預設日誌資料流字首為任務執行 ID。 ``` '--continuous-log-logStreamPrefix': 'custom_log_stream_prefix' ``` 您可以指定自訂持續記錄轉換模式。如果未指定，則預設轉換模式為 `%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n`。請注意，轉換模式僅適用於驅動程式日誌和執行程式日誌。它不會影響 AWS Glue 進度列。 ``` '--continuous-log-conversionPattern': 'custom_log_conversion_pattern' ``` ## 使用自訂指令碼記錄器記錄應用程式特定訊息 您可以使用 AWS Glue 記錄器，在指令碼中記錄即時傳送到驅動程式日誌串流的任何應用程式特定訊息。 以下範例顯示 Python 指令碼。 ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) logger = glueContext.get_logger() logger.info("info message") logger.warn("warn message") logger.error("error message") ``` 以下範例顯示 Scala 指令碼。 ``` import com.amazonaws.services.glue.log.GlueLogger object GlueApp { def main(sysArgs: Array[String]) { val logger = new GlueLogger logger.info("info message") logger.warn("warn message") logger.error("error message") } } ``` ## 啟用進度列來顯示任務進度 AWS Glue 在`JOB_RUN_ID-progress-bar`日誌串流下提供即時進度列，以檢查 AWS Glue 任務執行狀態。目前它僅支援初始化 `glueContext` 的任務。如果您在未初始化 的情況下執行純 Spark 任務`glueContext`，則不會顯示 AWS Glue 進度列。 進度列每 5 秒顯示一次以下的最新進度。 ``` Stage Number (Stage Name): > (numCompletedTasks + numActiveTasks) / totalNumOfTasksInThisStage] ``` ## 具有連續記錄的安全組態 如果為 CloudWatch 日誌啟用安全組態， AWS Glue 會為連續日誌建立名為 的日誌群組，如下所示： ``` - ``` 預設和自訂日誌群組將如下所示： + 預設的連續日誌群組為 `/aws-glue/jobs/error-` + 自訂的連續日誌群組為 `-` 您需要新增 `logs:AssociateKmsKey` 至您的 IAM 角色許可 (如果您使用 CloudWatch Logs 啟用安全組態)。如果未包含該許可，則會停用連續記錄。此外，若要設定 CloudWatch Logs 的加密，請依照 *Amazon CloudWatch Logs 使用者指南*中的[使用 AWS Key Management Service加密 CloudWatch Logs 中的日誌資料](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html)指示進行。 如需建立安全組態的詳細資訊，請參閱[在 AWS Glue 主控台上使用安全組態](console-security-configurations.md)。 **注意** 啟用日誌記錄並建立其他 CloudWatch 日誌事件時，可能會產生額外費用。如需詳細資訊，請參閱 [Amazon CloudWatch 定價](https://aws.amazon.com/cloudwatch/pricing/)。 # 檢視 AWS Glue 任務的日誌 您可以使用 AWS Glue 主控台或 Amazon CloudWatch 主控台檢視即時日誌。 **使用 AWS Glue 主控台儀表板檢視即時日誌** 1. 登入 AWS 管理主控台 並在 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 開啟 AWS Glue 主控台。 1. 在導覽窗格中，選擇 **Jobs (任務)**。 1. 新增或開始現有的任務。選擇 **Action (動作)**、**Run job (執行任務)**。 當您開始執行任務時，請導覽到頁面，其中包含有關執行中任務的資訊： + **Logs (日誌)** 標籤會顯示較舊的彙總應用程式日誌 。 + **日誌**索引標籤會在任務搭配 `glueContext` 初始化執行時顯示即時進度列。 + **Logs** 索引標籤也包含**驅動程式日誌**，可擷取即時 Apache Spark 驅動程式日誌，以及在任務執行時使用應用程式記錄器記錄的指令碼中的 AWS Glue 應用程式日誌。 1. 對於較舊的任務，您也可以在 **Job History (任務歷史記錄)** 檢視中透過選擇 **Logs (日誌)** 來檢視即時日誌。此動作會移至 CloudWatch 主控台，並顯示所有 Spark 驅動程式、執行器，以及該任務執行的進度列日誌串流。 **使用 CloudWatch 主控台儀表板檢視即時日誌** 1. 透過 [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 開啟 CloudWatch 主控台。 1. 在導覽窗格中，選擇 **Log (日誌)**。 1. 選擇 **/aws-glue/jobs/error/** 日誌群組。 1. 在 **Filter (篩選條件)** 方塊中，貼上任務執行 ID。 您可以檢視驅動程式日誌、執行器日誌，以及進度列 (如果使用 **Standard filter (標準篩選條件)**)。 # 使用 AWS Glue 可觀測性指標進行監控 **注意** AWS Glue 可觀測性指標可在 AWS Glue 4.0 及更新版本上使用。 使用 AWS Glue 可觀測性指標針對 Apache Spark 任務產生 AWS Glue 內部所發生之事件的深入解析，以改善問題的分類和分析。可觀測性指標能透過 Amazon CloudWatch 儀表板以視覺化呈現，並可用來協助執行錯誤的根本原因分析，以及診斷效能瓶頸。您可以減少大規模偵錯問題所花費的時間，使您能夠專注於更快、更有效地解決問題。 AWS Glue 可觀測性提供以下四個群組中分類的 Amazon CloudWatch 指標： + **可靠性 (即錯誤類別)**：可輕鬆識別特定時間範圍內您可能想要解決之常見失敗原因。 + **效能 (即偏態)**：識別效能瓶頸並套用調整技術。例如，當您因任務偏態而遇到效能降低時，您可能會想要啟用 Spark 調適性查詢執行，並微調偏斜聯結閾值。 + **輸送量 (即每個來源/接收器輸送量)**：監控資料讀取和寫入的趨勢。您也可以設定異常的 Amazon CloudWatch 警示。 + **資源使用率 (即工作者、記憶體和磁碟使用率)**：有效率地找出容量使用率低的任務。您可能會想要為這些任務啟用 AWS Glue 自動擴展。 ## 開始使用 AWS Glue 可觀測性指標 **注意** 設會在 AWS Glue Studio 主控台中啟用新的指標。 **要在 AWS Glue Studio 中設定可觀測性指標：** 1. 登入 AWS Glue 主控台，然後從主控台功能表選擇 **ETL 任務**。 1. 按一下**您的任務**區段中的任務名稱，即可選擇任務。 1. 選擇 **Job details** (任務詳細資訊) 索引標籤。 1. 捲動至底部，然後選擇**進階屬性**，接著選擇**任務可觀測性指標**。 ![\[螢幕擷取畫面顯示「任務詳細資料」索引標籤「進階」屬性。「任務可觀測性指標」選項會反白顯示。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/job-details-observability-metrics.png) **若要使用 啟用AWS Glue可觀測性指標 AWS CLI：** + 將輸入 JSON 檔案中的下列鍵值新增至 `--default-arguments` 對應： ``` --enable-observability-metrics, true ``` ## 使用 AWS Glue 可觀測性 由於可觀測性指標是透過 AWS Glue 提供 Amazon CloudWatch，因此您可以使用 Amazon CloudWatch 主控台 AWS CLI、 SDK 或 API 來查詢可觀測性指標資料點。請參閱[使用 Glue 可觀測性監控資源使用率以降低成本](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics/)，了解何時使用 AWS Glue 可觀測性指標的範例使用案例。 ### AWS Glue 在 Amazon CloudWatch 主控台中使用可觀測性 **若要在 Amazon CloudWatch 主控台中查詢和視覺化指標：** 1. 開啟 Amazon CloudWatch 主控台，然後選擇**所有指標**。 1. 在自訂命名空間下方，選取 **AWS Glue**。 1. 選擇**任務可觀測性指標、每個來源的可觀測性指標，或每個接收器的可觀測性指標**。 1. 搜尋特定的指標名稱、任務名稱、任務執行 ID，然後加以選取。 1. 在**圖形化指標**索引標籤下方，設定您偏好的統計資料、期間和其他選項。 ![\[螢幕擷取畫面顯示 Amazon CloudWatch 主控台和指標圖表。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/cloudwatch-console-metrics.png) **使用 查詢可觀測性指標 AWS CLI：** 1. 建立指標定義 JSON 檔案並使用自己的值取代 `your-Glue-job-name` 和 `your-Glue-job-run-id`。 ``` $ cat multiplequeries.json [ { "Id": "avgWorkerUtil_0", "MetricStat": { "Metric": { "Namespace": "Glue", "MetricName": "glue.driver.workerUtilization", "Dimensions": [ { "Name": "JobName", "Value": "" }, { "Name": "JobRunId", "Value": "" }, { "Name": "Type", "Value": "gauge" }, { "Name": "ObservabilityGroup", "Value": "resource_utilization" } ] }, "Period": 1800, "Stat": "Minimum", "Unit": "None" } }, { "Id": "avgWorkerUtil_1", "MetricStat": { "Metric": { "Namespace": "Glue", "MetricName": "glue.driver.workerUtilization", "Dimensions": [ { "Name": "JobName", "Value": "" }, { "Name": "JobRunId", "Value": "" }, { "Name": "Type", "Value": "gauge" }, { "Name": "ObservabilityGroup", "Value": "resource_utilization" } ] }, "Period": 1800, "Stat": "Minimum", "Unit": "None" } } ] ``` 1. 執行 `get-metric-data` 命令： ``` $ aws cloudwatch get-metric-data --metric-data-queries file: //multiplequeries.json \ --start-time '2023-10-28T18: 20' \ --end-time '2023-10-28T19: 10' \ --region us-east-1 { "MetricDataResults": [ { "Id": "avgWorkerUtil_0", "Label": "", "Timestamps": [ "2023-10-28T18:20:00+00:00" ], "Values": [ 0.06718750000000001 ], "StatusCode": "Complete" }, { "Id": "avgWorkerUtil_1", "Label": "", "Timestamps": [ "2023-10-28T18:50:00+00:00" ], "Values": [ 0.5959183673469387 ], "StatusCode": "Complete" } ], "Messages": [] } ``` ## 可觀測性指標 AWS Glue 可觀測性設定檔並 Amazon CloudWatch 每 30 秒將下列指標傳送至 ，其中一些指標會顯示在AWS Glue Studio任務執行監控頁面中。 | 指標 | Description | Category | | --- | --- | --- | | glue.driver.skewness.stage | 指標類別：job\$1performance Spark 階段執行偏態：此指標表示特定階段中最大任務持續時間與此階段中的中等任務持續時間相比較有多長。其會擷取執行偏態，此偏態可能是由輸入資料偏態或轉換 (例如，偏斜聯結) 引起。此指標的值落在 [0, infinity[ 的範圍內，其中 0 表示該階段所有任務中，任務執行時間的最大值與中位數的比率小於特定階段偏態因子。預設階段偏態因子為「5」，可透過 spark conf 覆寫此值：spark.metrics.conf.driver.source.glue.jobPerformance.skewnessFactor 階段偏態值為 1 表示比率是階段偏態因子的兩倍。 階段偏態的值會每 30 秒更新一次，可反映目前的偏態。階段結束時的值會反映最後階段偏態。 此階段層級指標用於計算任務層級指標 `glue.driver.skewness.job`。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (job\$1performance) 有效的統計資料：平均值、最大值、最小值、百分位數 單位：計數 | job\$1performance | | glue.driver.skewness.job | 指標類別：job\$1performance 任務偏態是所有階段的加權偏態的最大值。階段偏態 (glue.driver.skewness.stage) 使用階段持續時間加權。這是為了避免以下極端情況，即相對於其他階段，嚴重偏斜的階段實際執行時間很短 (因此其偏態對整體作業效能影響不大，不值得費力嘗試解決其偏態)。 此指標會在每個階段完成時更新，因此最後一個值會反映實際的整體作業偏態。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (job\$1performance) 有效的統計資料：平均值、最大值、最小值、百分位數 單位：計數 | job\$1performance | | glue.succeed.ALL | 指標類別：錯誤 成功的作業執行總數，可完成失敗類別的圖片 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計數)，以及 ObservabilityGroup (錯誤) 有效的統計資料：總和 單位：計數 | error | | glue.error.ALL | 指標類別：錯誤 作業執行錯誤總數，可完成失敗類別的圖片 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計數)，以及 ObservabilityGroup (錯誤) 有效的統計資料：總和 單位：計數 | error | | glue.error.[error category] | 指標類別：錯誤 這實際上是一組指標，只有在作業執行失敗時才會更新。錯誤分類有助於分類和偵錯。當作業執行失敗時，會將造成失敗的錯誤分類，並將對應的錯誤類別指標設為 1。這有助於針對所有作業錯誤分析執行隨著時間變化的失敗分析，以找出最常見的失敗類別並開始解決這些問題。AWS Glue 有 28 個錯誤類別，包括 OUT\$1OF\$1MEMORY (驅動程式和執行程式)、PERMISSION、SYNTAX 和 THROTTLING 錯誤類別。錯誤類別還包括 COMPILATION、LAUNCH 和 TIMEOUT 錯誤類別。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計數)，以及 ObservabilityGroup (錯誤) 有效的統計資料：總和 單位：計數 | error | | glue.driver.workerUtilization | 指標類別：resource\$1utilization 實際使用的已配置工作者百分比。如果不理想，自動擴展可以有所助益。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值、最大值、最小值、百分位數 單位：百分比 | resource\$1utilization | | glue.driver.memory.heap.[available \$1 used] | 指標類別：resource\$1utilization 在作業執行期間，驅動程式可用/已用的堆積記憶體。這有助於了解記憶體使用量趨勢，特別是隨著時間的推移，除了對記憶體相關的失敗進行偵錯，還有助於避免潛在的失敗。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：位元組 | resource\$1utilization | | glue.driver.memory.heap.used.percentage | 指標類別：resource\$1utilization 在作業執行期間，驅動程式已用的 (%) 堆積記憶體。這有助於了解記憶體使用量趨勢，特別是隨著時間的推移，除了對記憶體相關的失敗進行偵錯，還有助於避免潛在的失敗。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：百分比 | resource\$1utilization | | glue.driver.memory.non-heap.[available \$1 used] | 指標類別：resource\$1utilization 在作業執行期間，驅動程式可用/已用的非堆積記憶體。這有助於了解記憶體使用量趨勢，特別是隨著時間的推移，除了對記憶體相關的失敗進行偵錯，還有助於避免潛在的失敗。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：位元組 | resource\$1utilization | | glue.driver.memory.non-heap.used.percentage | 指標類別：resource\$1utilization 在作業執行期間，驅動程式已用的 (%) 非堆積記憶體。這有助於了解記憶體使用量趨勢，特別是隨著時間的推移，除了對記憶體相關的失敗進行偵錯，還有助於避免潛在的失敗。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：百分比 | resource\$1utilization | | glue.driver.memory.total.[available \$1 used] | 指標類別：resource\$1utilization 在作業執行期間，驅動程式可用/已用的記憶體總量。這有助於了解記憶體使用量趨勢，特別是隨著時間的推移，除了對記憶體相關的失敗進行偵錯，還有助於避免潛在的失敗。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：位元組 | resource\$1utilization | | glue.driver.memory.total.used.percentage | 指標類別：resource\$1utilization 在作業執行期間，驅動程式已用的 (%) 記憶體總量。這有助於了解記憶體使用量趨勢，特別是隨著時間的推移，除了對記憶體相關的失敗進行偵錯，還有助於避免潛在的失敗。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：百分比 | resource\$1utilization | | glue.ALL.memory.heap.[available \$1 used] | 指標類別：resource\$1utilization 執行程式可用/已用的堆積記憶體。ALL 表示所有執行程式。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：位元組 | resource\$1utilization | | glue.ALL.memory.heap.used.percentage | 指標類別：resource\$1utilization 執行程式已用的 (%) 堆積記憶體。ALL 表示所有執行程式。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：百分比 | resource\$1utilization | | glue.ALL.memory.non-heap.[available \$1 used] | 指標類別：resource\$1utilization 執行程式可用/已用的非堆積記憶體。ALL 表示所有執行程式。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：位元組 | resource\$1utilization | | glue.ALL.memory.non-heap.used.percentage | 指標類別：resource\$1utilization 執行程式已用的 (%) 非堆積記憶體。ALL 表示所有執行程式。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：百分比 | resource\$1utilization | | glue.ALL.memory.total.[available \$1 used] | 指標類別：resource\$1utilization 執行程式可用/已用的記憶體總量。ALL 表示所有執行程式。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：位元組 | resource\$1utilization | | glue.ALL.memory.total.used.percentage | 指標類別：resource\$1utilization 執行程式已用的 (%) 記憶體總量。ALL 表示所有執行程式。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：百分比 | resource\$1utilization | | glue.driver.disk.[available\$1GB \$1 used\$1GB] | 指標類別：resource\$1utilization 在作業執行期間，驅動程式可用/已用的磁碟空間。這有助於了解磁碟使用量趨勢，特別是隨著時間的推移，除了對磁碟空間不足相關的失敗進行偵錯，還有助於避免潛在的失敗。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：千兆位元組 (GB) | resource\$1utilization | | glue.driver.disk.used.percentage] | 指標類別：resource\$1utilization 在作業執行期間，驅動程式可用/已用的磁碟空間。這有助於了解磁碟使用量趨勢，特別是隨著時間的推移，除了對磁碟空間不足相關的失敗進行偵錯，還有助於避免潛在的失敗。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：百分比 | resource\$1utilization | | glue.ALL.disk.[available\$1GB \$1 used\$1GB] | 指標類別：resource\$1utilization 執行程式可用/已用的磁碟空間。ALL 表示所有執行程式。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：千兆位元組 (GB) | resource\$1utilization | | glue.ALL.disk.used.percentage | 指標類別：resource\$1utilization 執行程式可用/已用/已用(%) 的磁碟空間。ALL 表示所有執行程式。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)，以及 ObservabilityGroup (resource\$1utilization) 有效的統計資料：平均值 單位：百分比 | resource\$1utilization | | glue.driver.bytesRead | 指標類別：輸送量 此作業執行中每個輸入來源以及針對所有來源讀取的位元組數目。這有助於了解資料磁碟區及其隨時間的變化，進而幫助解決資料偏態等問題。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (儀表)、ObservabilityGroup (resource\$1utilization)，以及 Source (來源資料位置) 有效的統計資料：平均值 單位：位元組 | 輸送量 | | glue.driver.[recordsRead \$1 filesRead] | 指標類別：輸送量 此作業執行中每個輸入來源以及針對所有來源讀取的記錄/檔案數目。這有助於了解資料磁碟區及其隨時間的變化，進而幫助解決資料偏態等問題。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (儀表)、ObservabilityGroup (resource\$1utilization)，以及 Source (來源資料位置) 有效的統計資料：平均值 單位：計數 | 輸送量 | | glue.driver.partitionsRead | 指標類別：輸送量 此作業執行中每個 Amazon S3 輸入來源以及針對所有來源讀取的分割區數目。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (儀表)、ObservabilityGroup (resource\$1utilization)，以及 Source (來源資料位置) 有效的統計資料：平均值 單位：計數 | 輸送量 | | glue.driver.bytesWrittten | 指標類別：輸送量 此作業執行中每個輸出接收器以及針對所有接收器寫入的位元組數目。這有助於了解資料磁碟區及其隨時間的演進，進而幫助解決處理偏態等問題。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)、ObservabilityGroup (resource\$1utilization)，以及 Sink (接收器資料位置) 有效的統計資料：平均值 單位：位元組 | 輸送量 | | glue.driver.[recordsWritten \$1 filesWritten] | 指標類別：輸送量 此作業執行中每個輸出接收器以及針對所有接收器寫入的記錄/檔案數目。這有助於了解資料磁碟區及其隨時間的演進，進而幫助解決處理偏態等問題。 有效維度：JobName (AWS Glue 作業的名稱)、JobRunId (JobRun ID 或 ALL)、Type (計量)、ObservabilityGroup (resource\$1utilization)，以及 Sink (接收器資料位置) 有效的統計資料：平均值 單位：計數 | 輸送量 | ## 錯誤類別 | 錯誤類別 | Description | | --- | --- | | COMPILATION\$1ERROR | 編譯 Scala 程式碼期間出現錯誤。 | | CONNECTION\$1ERROR | 連線到服務/遠端主機/資料庫服務等項目時出現錯誤。 | | DISK\$1NO\$1SPACE\$1ERROR | 驅動程式/執行程式的磁碟中沒有剩餘空間時出現錯誤。 | | OUT\$1OF\$1MEMORY\$1ERROR | 驅動程式/執行程式的記憶體中沒有剩餘空間時出現錯誤。 | | IMPORT\$1ERROR | 匯入相依性時出現錯誤。 | | INVALID\$1ARGUMENT\$1ERROR | 輸入引數無效/非法時出現錯誤。 | | PERMISSION\$1ERROR | 缺少服務、資料等項目的許可時出現錯誤。 | | RESOURCE\$1NOT\$1FOUND\$1ERROR | 資料、位置等項目不存在時出現錯誤。 | | QUERY\$1ERROR | 因 Spark SQL 查詢執行而出現錯誤。 | | SYNTAX\$1ERROR | 指令碼中存在語法錯誤時出現錯誤。 | | THROTTLING\$1ERROR | 達到服務並行限制或超出服務配額限制時出現錯誤。 | | DATA\$1LAKE\$1FRAMEWORK\$1ERROR | 因 AWS Glue 原生支援的資料湖架構 (例如 Hudi、Iceberg 等) 而出現錯誤。 | | UNSUPPORTED\$1OPERATION\$1ERROR | 進行不支援的操作時出現錯誤。 | | RESOURCES\$1ALREADY\$1EXISTS\$1ERROR | 要建立或新增的資源已存在時出現錯誤。 | | GLUE\$1INTERNAL\$1SERVICE\$1ERROR | 發生 AWS Glue 內部服務問題時出現錯誤。 | | GLUE\$1OPERATION\$1TIMEOUT\$1ERROR | AWS Glue 操作逾時時出現錯誤。 | | GLUE\$1VALIDATION\$1ERROR | 無法驗證 AWS Glue 作業所需的值時出現錯誤。 | | GLUE\$1JOB\$1BOOKMARK\$1VERSION\$1MISMATCH\$1ERROR | 在相同的來源儲存貯體上執行同一個作業並同時寫入相同/不同的目的地 (並行數 > 1) 時出現錯誤 | | LAUNCH\$1ERROR | 在 AWS Glue 作業啟動階段出現錯誤。 | | DYNAMODB\$1ERROR | Amazon DynamoDB 服務發生一般錯誤。 | | GLUE\$1ERROR | 因 AWS Glue 服務而出現一般錯誤。 | | LAKEFORMATION\$1ERROR | AWS Lake Formation 服務出現一般錯誤。 | | REDSHIFT\$1ERROR | Amazon Redshift 服務出現一般錯誤。 | | S3\$1ERROR | 因 Amazon S3 服務而出現一般錯誤。 | | SYSTEM\$1EXIT\$1ERROR | 一般系統結束錯誤。 | | TIMEOUT\$1ERROR | 作業因操作逾時而失敗時出現一般錯誤。 | | UNCLASSIFIED\$1SPARK\$1ERROR | 因 Spark 而出現一般錯誤。 | | UNCLASSIFIED\$1ERROR | 預設錯誤類別。 | ## 限制 **注意** 必須將 `glueContext` 初始化才能發布指標。 在來源維度中，值可以是 Amazon S3 路徑或資料表名稱，具體取決於來源類型。此外，如果來源為 JDBC 且使用的是查詢選項，則會在來源維度中設定查詢字串。如果該值超過 500 個字元，則會修剪至 500 個字元以內。值的限制如下： + 非 ASCII 字元會被移除。 + 如果來源名稱不包含任何 ASCII 字元，則會將該名稱轉換為 <非 ASCII 輸入>。 ### 輸送量指標的限制和考量 + 支援 DataFrame 和以 DataFrame 為基礎的 DynamicFrame (例如 JDBC，從 Amazon S3 上的 parquet 讀取)，但不支援以 RDD 為基礎的 DynamicFrame (例如在 Amazon S3 讀取 csv、json)。從技術上來講，支援 Spark UI 上可見的所有讀取和寫入。 + 如果資料來源是目錄資料表且格式為 JSON、CSV、文字或 Iceberg，則會發出 `recordsRead` 指標。 + JDBC 和 Iceberg 資料表中不提供 `glue.driver.throughput.recordsWritten`、`glue.driver.throughput.bytesWritten` 和 `glue.driver.throughput.filesWritten` 指標。 + 指標可能會延遲出現。如果任務在大約一分鐘內完成， Amazon CloudWatch 則指標中可能沒有輸送量指標。 # 任務監控與偵錯 您可以收集 AWS Glue 任務的指標，並且在 AWS Glue 和 Amazon CloudWatch 主控台上，用視覺化的方式呈現這些指標，來找出和修正問題。分析您的 AWS Glue 任務需要執行下列步驟： 1. 啟用指標： 1. 在任務定義中啟用 **Job metrics (任務指標)** 選項。您可以在 AWS Glue 主控台中啟用分析功能，或是將分析功能做為任務的參數。如需詳細資訊，請參閱[定義 Spark 任務的任務屬性](add-job.md#create-job)或[在 Glue AWS 任務中使用任務參數](aws-glue-programming-etl-glue-arguments.md)。 1. 在任務定義中啟用 **AWS Glue 可觀測性指標**選項。您可以在 AWS Glue 主控台中啟用可觀測性指標，或是將其作為作業的參數。如需更多資訊，請參閱[使用 AWS Glue 可觀測性指標進行監控](monitor-observability.md)。 1. 確認任務指令碼會將 `GlueContext` 初始化。例如，下列的指令碼片段會將 `GlueContext` 初始化，並顯示分析程式碼在指令碼中的所在位置。這個一般格式會在後續的除錯案例中使用。 ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job import time ## @params: [JOB_NAME] args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) ... ... code-to-profile ... ... job.commit() ``` 1. 執行任務。 1. 以視覺化的方式呈現指標： 1. 在 AWS Glue 主控台中以視覺化的方式呈現指標，並找出驅動程式或執行程式的異常指標。 1. 在作業執行監控頁面、作業執行詳細資訊頁面或 Amazon CloudWatch 上查看可觀測性指標。如需詳細資訊，請參閱[使用 AWS Glue 可觀測性指標進行監控](monitor-observability.md)。 1. 利用辨識出的指標來縮小問題根源的範圍。 1. 或者，使用已辨識驅動程式或任務執行器的日誌串流，來確認問題的根源。 **AWS Glue 可觀測性指標的使用案例** + [進行 OOM 例外與任務異常的除錯](monitor-profile-debug-oom-abnormalities.md) + [針對高要求的階段和落後任務進行除錯](monitor-profile-debug-straggler.md) + [監控多個任務的進度](monitor-debug-multiple.md) + [DPU 容量規劃監控](monitor-debug-capacity.md) + [使用 AWS Glue 可觀測性監控資源使用率以降低成本](https://aws.amazon.com/blogs/big-data/enhance-monitoring-and-debugging-for-aws-glue-jobs-using-new-job-observability-metrics) # 進行 OOM 例外與任務異常的除錯 您可以針對 AWS Glue 中的記憶體不足 (OOM) 例外和任務異常進行除錯。下列的段落所說明的除錯案例，是針對 Apache Spark 驅動程式或 Spark 執行器的記憶體不足 (OOM) 例外進行除錯。 + [進行驅動程式 OOM 例外的除錯](#monitor-profile-debug-oom-driver) + [進行執行器 OOM 例外的除錯](#monitor-profile-debug-oom-executor) ## 進行驅動程式 OOM 例外的除錯 在這個案例中，Spark 任務會從 Amazon Simple Storage Service (Amazon S3) 讀取大量的小型檔案。接著將檔案轉換成 Apache Parquet 格式，然後寫入到 Amazon S3。Spark 驅動程式的記憶體即將用盡。輸入的 Amazon S3 資料在不同的 Amazon S3 分割區中，具有超過 100 萬個檔案。 分析程式碼如下： ``` data = spark.read.format("json").option("inferSchema", False).load("s3://input_path") data.write.format("parquet").save(output_path) ``` ### 在 AWS Glue 主控台上視覺化分析指標 下列的圖表顯示驅動程式和執行器的記憶體使用量百分比。此用量曲線是由一個資料點繪製而成，而此資料點是過去一分鐘內所呈報值的平均值。您可以看到在任務的記憶體使用狀況圖中，[驅動程式記憶體](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.jvm.heap.usage)很快地就超過 50% 的安全使用量門檻。另一方面，所有執行器的整體[平均記憶體使用量](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage)仍然低於 4%。這明顯地顯示出這項 Spark 任務中驅動程式執行的異常狀況。 ![\[驅動程式和執行器的記憶體使用量百分比。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-memoryprofile.png) 工作的執行很快地失敗，在 ** 主控台的 **History (歷程記錄)AWS Glue 索引標籤中，顯示了下列的錯誤訊息：Command Failed with Exit Code 1 (指令執行失敗，結束代碼 1)。這個錯誤字串代表任務因系統錯誤而失敗，在此案例中，是因為驅動程式的記憶體用盡。 ![\[AWS Glue 主控台顯示的錯誤訊息。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-errorstring.png) 在主控台的 **History (歷程記錄)** 索引標籤中，選擇 **Error logs (錯誤日誌)** 連結，來確認 CloudWatch Logs 所提供關於驅動程式 OOM 的資訊。在任務的錯誤日誌中搜尋「**Error**」，確認這的確是讓任務失敗的 OOM 例外： ``` # java.lang.OutOfMemoryError: Java heap space # -XX:OnOutOfMemoryError="kill -9 %p" # Executing /bin/sh -c "kill -9 12039"... ``` 在任務的 **History (歷程記錄)** 索引標籤中，選擇 **Logs (日誌)**。您可於任務開始時在 CloudWatch Logs 找到驅動程式執行的追蹤。Spark 驅動程式會試著列出所有目錄中的所有檔案、建立 `InMemoryFileIndex`，並針對每個檔案啟動一個任務。這會導致 Spark 驅動程式必須在記憶體中維持大量的狀態顯示，以追蹤所有的任務。該驅動程式會針對大量檔案的完整清單建立快取，以維持記憶體內的索引，進而造成驅動程式的 OOM。 ### 利用分組功能來修正處理多個檔案的問題 您可以利用 * 中的*分組AWS Glue功能，來修正處理多個檔案的問題。使用動態框架時，以及輸入資料集包含大量檔案 (超過 50,000 個) 時，分組功能就會自動啟用。分組功能可讓您將多個檔案合併為一個群組，讓任務處理整個群組而非單一檔案。因此，Spark 驅動程式儲存於記憶體中的狀態顯示會大幅減少，追蹤的任務也減少。關於手動啟用資料集的分組功能，詳細資訊請參閱 [讀取在大型群組中的輸入檔案](grouping-input-files.md)。 若要查看 AWS Glue 任務的記憶體使用狀況，請在啟用分組功能的狀況下，分析下列程式碼： ``` df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json") datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink") ``` 您可以在 AWS Glue 任務狀況分析中，監控記憶體的使用狀況和 ETL 資料的移動。 在 AWS Glue 任務的整個任務期間內，驅動程式都會以低於 50% 的記憶體使用量閥值來執行。執行器會串流來自 Amazon S3 的資料、進行處理，然後將資料輸出寫入到 Amazon S3。因此，執行器在任何時點所使用的記憶體皆少於 5%。 ![\[出現問題的記憶體使用狀況已經修正。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-memoryprofile-fixed.png) 下列的資料移動狀況圖，顯示了所有執行器隨著任務的進行，過去一分鐘內[讀取](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes)和[寫入](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes)的 Amazon S3 位元組總數。這兩種動作都會遵循相同的模式，讓資料分散透過所有執行器串流。這項任務會在不到三小時內處理完所有的一百萬個檔案。 ![\[出現問題的資料移動狀況已經修正。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-etlmovement.png) ## 進行執行器 OOM 例外的除錯 在此案例中，您可以了解如何針對 Apache Spark 執行器可能會發生的 OOM 例外，來進行除錯。下列的程式碼使用了 Spark MySQL 讀取器，來將包含約 3,400 萬行的大型資料表，讀取到 Spark DataFrame 中。接著再以 Parquet 格式，將資料輸出寫入至 Amazon S3。您可以提供連線屬性，並使用預設的 Spark 組態來讀取資料表。 ``` val connectionProperties = new Properties() connectionProperties.put("user", user) connectionProperties.put("password", password) connectionProperties.put("Driver", "com.mysql.jdbc.Driver") val sparkSession = glueContext.sparkSession val dfSpark = sparkSession.read.jdbc(url, tableName, connectionProperties) dfSpark.write.format("parquet").save(output_path) ``` ### 在 AWS Glue 主控台上視覺化已分析的指標 如果記憶體使用量圖表的斜率為正值且跨越 50%，則如果在發出下一個指標之前任務失敗，則記憶體耗盡很可能是造成失敗的原因。下列圖表顯示執行開始的一分鐘內，所有執行器的[平均記憶體使用量](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage)快速暴增超過 50%。使用量達到 92%，而執行此執行器的容器被 Apache Hadoop YARN 停止。 ![\[所有執行器的平均記憶體使用量。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile.png) 如下列圖表所示，到任務失敗之前，一直都有[單一執行器](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors)在執行。這是由於啟動了新的執行器來取代已停止的執行器。JDBC 資料來源的讀取，預設並非平行進行，因為這會需要從欄分割資料表，並開啟多個連線。因此，只有一個執行器會以序列方式讀取完整的資料表。 ![\[任務執行圖顯示任務失敗前一直有單一執行器在執行。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-2-execution.png) 如下列圖表所示，在任務失敗之前，Spark 嘗試啟動新的任務四次。您可以查看三個執行器的[記憶體使用狀況](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.used)。每個執行器很快地就用完自己所有的記憶體。當第四個執行器用完記憶體後，任務就失敗了。因此，並未立即呈報其指標。 ![\[執行器的記憶體使用狀況。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-2-exec-memprofile.png) 您可以從 AWS Glue 主控台上的錯誤字串，確認任務是因為 OOM 例外而失敗，如下列圖像所示。 ![\[AWS Glue 主控台顯示的錯誤訊息。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-2-errorstring.png) **任務輸出日誌**：為了進一步確認執行器 OOM 例外的情況，請檢視 CloudWatch Logs。搜尋 **Error** 時，您會發現四個執行器大約是在相同的期間內遭到停止，如指標儀表板上所示。因為超過了記憶體使用量的限制，這些執行器全都遭到 YARN 終止。 執行器 1 ``` 18/06/13 16:54:29 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 ERROR YarnClusterScheduler: Lost executor 1 on ip-10-1-2-175.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:54:29 WARN TaskSetManager: Lost task 0.0 in stage 0.0 (TID 0, ip-10-1-2-175.ec2.internal, executor 1): ExecutorLostFailure (executor 1 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` 執行器 2 ``` 18/06/13 16:55:35 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 ERROR YarnClusterScheduler: Lost executor 2 on ip-10-1-2-16.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:55:35 WARN TaskSetManager: Lost task 0.1 in stage 0.0 (TID 1, ip-10-1-2-16.ec2.internal, executor 2): ExecutorLostFailure (executor 2 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` 執行器 3 ``` 18/06/13 16:56:37 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 ERROR YarnClusterScheduler: Lost executor 3 on ip-10-1-2-189.ec2.internal: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:56:37 WARN TaskSetManager: Lost task 0.2 in stage 0.0 (TID 2, ip-10-1-2-189.ec2.internal, executor 3): ExecutorLostFailure (executor 3 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.8 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` 執行器 4 ``` 18/06/13 16:57:18 WARN YarnAllocator: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 WARN YarnSchedulerBackend$YarnSchedulerEndpoint: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 ERROR YarnClusterScheduler: Lost executor 4 on ip-10-1-2-96.ec2.internal: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. 18/06/13 16:57:18 WARN TaskSetManager: Lost task 0.3 in stage 0.0 (TID 3, ip-10-1-2-96.ec2.internal, executor 4): ExecutorLostFailure (executor 4 exited caused by one of the running tasks) Reason: Container killed by YARN for exceeding memory limits. 5.5 GB of 5.5 GB physical memory used. Consider boosting spark.yarn.executor.memoryOverhead. ``` ### 利用 AWS Glue 動態框架來修正擷取大小 由於預設的 Spark JDBC 擷取大小為 0，因此執行器在讀取 JDBC 資料表時用盡了記憶體。這代表 Spark 執行器上的 JDBC 驅動程式，試著一次從資料庫擷取 3,400 萬行的資料，並建立這些資料的快取 (即使 Spark 是一次一行的進行串流作業)。使用 Spark 時，您可以將擷取大小的參數，設定為非 0 的預設值，來避免這種狀況發生。 您也可以改用 AWS Glue 動態框架，來修正這個問題。在預設情況下，動態框架會使用 1,000 個資料列的擷取大小，通常這個設定值已經夠用。因此，執行器不會使用超過總記憶體 7% 的記憶體量。AWS Glue 任務只會使用單一執行器，在不到兩分鐘內完成。雖然我們建議使用 AWS Glue 動態框架，但是您也可以使用 Apache Spark `fetchsize` 屬性來設定擷取大小。請參閱 [Spark SQL、DataFrames 和資料集指南](https://spark.apache.org/docs/2.2.0/sql-programming-guide.html#jdbc-to-other-databases)。 ``` val (url, database, tableName) = { ("jdbc_url", "db_name", "table_name") } val source = glueContext.getSource(format, sourceJson) val df = source.getDynamicFrame glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet", transformation_ctx = "datasink") ``` **正常分析指標：**使用 [ 動態框架的](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.jvm.heap.usage)執行器記憶體AWS Glue絕對不會超過安全門檻，如下列圖像所示：此等記憶體會從資料庫串流資料行，而且任何時點只會針對 JDBC 驅動程式中的 1,000 行建立快取。不會發生記憶體不足的例外狀況。 ![\[AWS Glue 主控台顯示執行器記憶體低於安全門檻值。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-oom-2-memoryprofile-fixed.png) # 針對高要求的階段和落後任務進行除錯 您可以利用 AWS Glue 任務分析功能，在擷取、轉換和載入 (ETL) 任務中，找出高要求階段和落後任務。在 AWS Glue 任務的階段中，落後任務所花費的作業時間，遠多於其他的任務。因此，此等任務需要花較長的時間完成作業，也延遲了任務的總執行時間。 ## 將小型的輸入檔案合併為較大的輸出檔案 當不同任務之間的作業量分配不均，或是資料傾斜造成某個任務需要處理更多的資料時，就可能會出現落後的任務。 您可以分析下列程式碼 (在 Apache Spark 中的通用模式)，來將大量的小型檔案合併為較大的輸出檔案。在這個範例中，輸入資料集是 32 GB 的 JSON Gzip 壓縮檔案。輸出資料集約包含 190 GB 的未壓縮 JSON 檔案。 分析程式碼如下： ``` datasource0 = spark.read.format("json").load("s3://input_path") df = datasource0.coalesce(1) df.write.format("json").save(output_path) ``` ### 在 AWS Glue 主控台上視覺化已分析的指標 您可以分析任務，檢驗四組不同的指標： + ETL 資料移動 + 在執行器之間的資料隨機移動 + 任務執行 + 記憶體使用狀況 **ETL 資料移動**：在 **ETL Data Movement (ETL 資料移動)** 分析圖表中，所有執行器在前 6 分鐘內就完成的第一個階段中，相當快速地[讀取](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes)資料 (單位：位元組)。不過，任務執行的總時間約為一個小時，大部分為資料[寫入](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes)作業。 ![\[顯示 ETL 資料移動狀況的圖表。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-straggler-1.png) **執行器之間的資料隨機移動：**在第二階段結束之前，隨機移動資料期間[讀取](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleLocalBytesRead)和[寫入](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.shuffleBytesWritten)的位元組數量出現突增的峰值，如 **Job Execution (任務執行)** 和 **Data Shuffle (資料隨機移動)** 指標所示。在所有執行器隨機移動資料之後，就只從第 3 號執行器進行讀取和寫入。 ![\[執行器之間資料隨機移動的指標。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-straggler-2.png) **任務執行：**如下列圖表所示，其他所有的執行器皆處於閒置狀態，最後在 10:09 之前終止。在這個時間點，執行器的總數減少到只剩下一個。這清楚地顯示出，第 3 號執行器包含落後任務，此任務所花費的執行時間最長，而且佔了大部分的任務執行時間。 ![\[運作中執行器的執行指標。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-straggler-3.png) **記憶體使用狀況：**經過前兩階段後，只有[第 3 號執行器](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used)正在使用記憶體來運作處理資料。剩下的執行器只是處於閒置狀態，或是在前兩個階段完成之後，就很快地遭到終止。 ![\[經過前兩個階段後的記憶體使用狀況指標。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-straggler-4.png) ### 利用分組來解決落後執行器的問題 您可以利用 * 中的*分組AWS Glue功能，來避免出現落後的執行器。利用分組功能，將資料平均地分配給所有執行器，並使用叢集上所有可用的執行器，將檔案合併為更大型的檔案。如需詳細資訊，請參閱 [讀取在大型群組中的輸入檔案](grouping-input-files.md)。 若要查看 AWS Glue 任務中的 ETL 資料移動狀況，請在啟用分組功能的情況下，分析下列程式碼： ``` df = glueContext.create_dynamic_frame_from_options("s3", {'paths': ["s3://input_path"], "recurse":True, 'groupFiles': 'inPartition'}, format="json") datasink = glueContext.write_dynamic_frame.from_options(frame = df, connection_type = "s3", connection_options = {"path": output_path}, format = "json", transformation_ctx = "datasink4") ``` **ETL 資料移動：**在整個任務執行期間，資料寫入作業現在會與資料讀取作業並行串流。因此，任務會在 8 分鐘之內完成，速度比之前快上許多。 ![\[ETL 資料移動狀況顯示問題已經修正。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-straggler-5.png) **執行器之間的資料隨機移動：**在進行讀取時，使用分組功能將輸入檔案合併之後，就不用在資料讀取之後，進行成本昂貴的資料隨機移動作業。 ![\[資料隨機移動指標顯示問題已修正。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-straggler-6.png) **任務執行：**任務執行指標會顯示運作中執行器的總數，以及處理的資料維持地相當穩定。在任務中沒有任何落後作業。所有的執行器皆處於運作狀態，在任務尚未完成之前，不會遭到終止。由於不需在執行器之間進行中間的資料隨即移動作業，因此任務中只有一個階段。 ![\[任務執行小工具的指標，顯示任務中沒有落後的作業。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-straggler-7.png) **記憶體使用狀況**：此指標顯示所有執行器的[現用記憶體使用量](monitoring-awsglue-with-cloudwatch-metrics.md#glue.executorId.jvm.heap.used)—重新確認所有的執行器都在活動中。隨著資料同時串流傳入和輸出寫入，所有執行器使用的總記憶體大致平均，而且遠低於所有執行器的安全門檻值。 ![\[記憶體使用狀況指標，顯示所有執行器的現用記憶體使用量。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-straggler-8.png) # 監控多個任務的進度 您可以同時描述多個 AWS Glue 任務，並監控它們之間的資料流程。這是一個常見的任務流程模式，且需要監控個別任務進度、資料處理後端紀錄、資料重新處理和任務書籤。 **Topics** + [已分析的程式碼](#monitor-debug-multiple-profile) + [在 AWS Glue 主控台上視覺化已分析的指標](#monitor-debug-multiple-visualize) + [修正檔案處理](#monitor-debug-multiple-fix) ## 已分析的程式碼 在此任務流程中，您有兩個任務：輸入任務和輸出任務。輸入任務透過定期觸發排定每隔 30 分鐘執行。在每個輸入任務成功執行之後，即排定要執行的輸出任務。這些排定的任務皆由任務觸發器控制。 ![\[主控台螢幕擷取畫面會顯示任務觸發條件正在控制的輸入和輸出任務排程處理。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-multiple-1.png) **輸入任務**：此任務從 Amazon Simple Storage Service (Amazon S3) 位置讀取的資料，會使用 `ApplyMapping` 轉換該任務，並將其寫入至暫存 Amazon S3 位置。以下程式碼是已分析的輸入任務程式碼： ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": ["s3://input_path"], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": staging_path, "compression": "gzip"}, format = "json") ``` **輸出任務**：此任務從 Amazon S3 的暫存位置讀取輸入任務中的輸出，將其再次轉換並寫入至目的地： ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "json") ``` ## 在 AWS Glue 主控台上視覺化已分析的指標 在相同的輸出任務時間軸上，以下儀表板會將輸入任務的 Amazon S3 位元組寫入指標，加乘至 Amazon S3 位元組讀取指標。該時間軸顯示了輸入與輸出任務的不同任務執行。輸入任務 (紅色) 每 30 分鐘啟動一次。輸出任務 (褐色) 會於輸入任務完成時啟動，最大並行數量為 1。 ![\[圖形顯示了讀取和寫入的資料。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-multiple-4.png) 在此範例中並未啟用[任務書籤](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html)。在該指令碼程式碼中沒有使用轉換細節來啟用任務書籤。 **任務歷史記錄**：從下午 12 點開始，輸入和輸出任務會有多項執行，如 **History (歷史記錄)** 標籤中所示。 AWS Glue 主控台的輸入任務如下所示： ![\[主控台螢幕擷取畫面顯示了輸入任務的歷史紀錄標籤。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-multiple-2.png) 下列映像顯示了輸出任務： ![\[主控台螢幕擷取畫面顯示了輸出任務的歷史紀錄標籤。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-multiple-3.png) **第一個任務執行**：如下方的 Data Bytes Read and Written (資料位元組讀取和寫入圖形) 所示，在 12:00 和 12:30 之間的第一個輸入與輸出任務的任務執行，顯示了曲線下大致的相同區域。那些領域代表了輸入任務寫入的 Amazon S3 位元組，以及輸出任務讀取的 Amazon S3 位元組。此資料也由 Amazon S3 位元組寫入的比例所確認 (超過 30 分鐘的加總 - 輸入任務的任務觸發器頻率)。在下午 12 點開始的輸入任務執行比例資料點也是 1。 以下圖表顯示所有任務執行的資料流程比例： ![\[圖形顯示了資料流程比例：寫入的位元組和讀取的位元組。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-multiple-5.png) **第二個任務執行**：在第二個任務執行中，輸出任務讀取的位元數和輸入任務寫入的位元數之間有清楚的差異。(在輸出任務的兩個任務執行中比較曲線下的區域，或在輸入與輸出任務中的第二個執行中比較區域。) 讀取和寫入的位元組比例，顯示第二個範圍 (從 12:30 至 13:00) 的 30 分鐘內，輸出任務資料讀取約是輸入任務資料寫入的 2.5 倍。這是因為任務書籤並未啟用，故輸出任務重新處理了輸入任務的第一個任務執行的輸出。超過 1 的比率，說明有由輸出任務處理的額外資料後端紀錄。 **第三個任務執行**：輸入任務與寫入的位元組數相當的一致 (請參閱紅色曲線以下的區域)。不過，輸入任務第三個任務執行的執行時間超出預期 (請參閱紅色曲線的尾部)。因此，輸出任務的第三個任務執行會延遲開始。第三個任務執行僅在 13:00 到 13:30 之間剩餘的 30 分鐘內處理暫存位置中累積的一小部分資料。位元組流程的比例，顯示它僅會處理由輸入任務的第三個任務執行寫入資料的 0.83 (參見 13:00 時的比例)。 **輸入和輸出任務的重疊**：輸出任務的第四個任務執行依各排程在 13:30 開始，即輸出任務的第三個任務執行完成之前。這兩個任務執行間有部分重疊。不過，輸出任務的第三個任務執行約在 13:17 開始，它僅擷取 Amazon S3 暫存位置中列出的檔案。這包含了輸入任務的第一個任務執行的所有資料輸出。13:30 的實際比例為 2.75。從 13:30 至 14:00 間，輸出任務的第三個任務執行處理的寫入資料，是輸入任務的第四個任務執行的 2.75 倍。 如這些映像所示，輸出任務正在重新處理資料，這些資料位於輸入任務的所有優先任務暫存位置。因此，輸出任務的第四個任務執行時間最長，並與輸入任務的整個第五個任務執行重疊。 ## 修正檔案處理 您應該確保輸出任務僅會處理尚未由輸出任務的前一任務執行處理過的檔案。若要執行此操作，請啟用任務書籤並在輸出任務中設定轉換內容，如下所示： ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [staging_path], "useS3ListImplementation":True,"recurse":True}, format="json", transformation_ctx = "bookmark_ctx") ``` 任務書籤啟用後，輸出任務將不會自輸入任務的所有先前任務執行中重新處理暫存位置裡的資料。下列映像顯示了資料的讀取和寫入，棕色曲線下的面積與紅色曲線相當一致且相似。 ![\[圖形以紅色和棕色線條顯示了資料的讀取和寫入。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-multiple-6.png) 由於沒有額外的資料處理，位元組流程比例也會大致保持接近為 1。 ![\[圖形顯示了資料流程比例：寫入的位元組和讀取的位元組\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-multiple-7.png) 在下一個輸入任務執行開始將更多資料放入暫存位置之前，輸出任務的任務執行將開始並擷取暫存位置中的檔案。只要此操作持續執行，它僅會處理之前的輸入任務執行所擷取的檔案，且比例保持接近 1。 ![\[圖形顯示了資料流程比例：寫入的位元組和讀取的位元組\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-multiple-7.png) 假設輸入任務花費的時間超過預期，於是，輸出任務將從兩個輸入任務執行中擷取暫存位置中的檔案。然後，該輸出任務執行的比例將高於 1。不過，以下輸出任務的任務執行，不會處理任何輸出任務之前的任務執行已處裡的檔案。 # DPU 容量規劃監控 您可以在 中使用任務指標 AWS Glue 來估計可用於向外擴展AWS Glue任務的資料處理單位 (DPUs) 數量。 **注意** 此頁面僅適用於 AWS Glue 0.9 和 1.0 版。較新版本的 AWS Glue 包含節省成本的功能，這些功能會在容量規劃時帶來額外的考量。 **Topics** + [已分析的程式碼](#monitor-debug-capacity-profile) + [在 AWS Glue 主控台上視覺化已分析的指標](#monitor-debug-capacity-visualize) + [判斷最佳 DPU 容量](#monitor-debug-capacity-fix) ## 已分析的程式碼 以下指令碼會讀取包含 428 個 gzip JSON 檔案的 Amazon Simple Storage Service (Amazon S3) 分割區。該指令碼套用對應來變更欄位名稱，並以 Apache Parquet 格式將它們轉換並寫入 Amazon S3。您將根據預設佈建 10 個 DPU 並執行此任務。 ``` datasource0 = glueContext.create_dynamic_frame.from_options(connection_type="s3", connection_options = {"paths": [input_path], "useS3ListImplementation":True,"recurse":True}, format="json") applymapping1 = ApplyMapping.apply(frame = datasource0, mappings = [(map_spec]) datasink2 = glueContext.write_dynamic_frame.from_options(frame = applymapping1, connection_type = "s3", connection_options = {"path": output_path}, format = "parquet") ``` ## 在 AWS Glue 主控台上視覺化已分析的指標 **任務執行 1：**在此任務執行中，我們將展示如何尋找叢集中是否存在佈建不足的 DPU。在 AWS Glue 中的任務執行功能顯示所有主動執行的執行器[數量](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberAllExecutors)、完成階段的[數量](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.aggregate.numCompletedStages)，以及所需執行器的最大[數量](monitoring-awsglue-with-cloudwatch-metrics.md#glue.driver.ExecutorAllocationManager.executors.numberMaxNeededExecutors)。 所需執行器最大數量的計算，是透過新增執行中任務和待處理任務總數除以每個執行器的任務。該結果是滿足目前負載所需的執行器總數的測量。 相反的，主動執行的執行器數量，會衡量有多少執行器正在執行主動 Apache Spark 任務。隨著任務的進行，所需的最大執行器可以更改，並且通常會在等待中的任務佇列降低時向下移動到任務的末端。 下圖中的水平紅線顯示了分配執行器的最大數量，這取決於您為任務分配的 DPU 數。在本例中，您需要為該任務執行分配 10 個 DPU。一個 DPU 保留給管理使用。另外九個 DPU 則會分別執行兩個執行器，且會保留其中一個執行器給 Spark 驅動程式。Spark 驅動程式會在主要應用程式內執行。因此，分配的執行器最大數量是 2\$19 - 1 = 17 個執行器。 ![\[顯示主動執行器和最大所需執行器的任務指標。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-capacity-1.png) 如圖所示，所需執行器的最大數量在任務開始時從 107 開始，而中動執行器數量保持為 17。這與具有 10 個 DPU 的分配執行器最大數量相同。所需執行器最大數量和所分配執行器最大數量間的比率 (對於 Spark 驅動程式，兩者都新增 1 個) 會提供佈建不足因數：108/18 = 6 倍。您可以佈建 6 (佈建不足比率) \$19 (目前 DPU 容量 - 1) \$1 1 個 DPU = 55 個 DPU 來擴展該任務，即可以最高平行處理速度執行並加速完成。 AWS Glue 主控台會以靜態線 (表示分配執行器​原始數量上限) 顯示詳細的任務指標。該主控台會透過指標的任務定義來計算分配執行器的上限。相反地，如需詳細任務執行指標，主控台會透過任務執行組態來計算分配執行器的上限，特別是針對任務執行分配的 DPU 數。若要檢視個別任務執行的指標，請選取任務執行並選擇 **View run metrics (檢視執行指標)**。 ![\[顯示 ETL 資料移動的任務指標。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-capacity-2.png) 查看 Amazon S3 位元組[讀取](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.read_bytes)和[寫入](monitoring-awsglue-with-cloudwatch-metrics.md#glue.ALL.s3.filesystem.write_bytes)，請注意，該任務會在 Amazon S3 資料中花費所有的六分鐘串流，並將其平行寫出。分配的 DPU 上的所有核心都正在讀取和寫入 Amazon S3。所需執行器的最大數量為 107，也符合輸入 Amazon S3 路徑中的檔案數 – 428。每個執行器可以啟動四個 Spark 任務以處理四個輸入檔案 (JSON gzip)。 ## 判斷最佳 DPU 容量 根據先前任務執行的結果，您可以將分配的 DPU 總數增加到 55，並查看任務的執行情況。該任務可在三個分鐘內完成 – 是先前所需時間的一半。此案例中的任務擴展並非線性的，因為它是一種短期執行任務。具有長期執行任務或大量任務的任務 (大量的最大所需執行器) 受益於接近線性的 DPU 擴展效能加速。 ![\[圖形顯示分配的 DPU 總數增加\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-capacity-3.png) 如上圖所示，主動執行器的總數達到最大分配數 – 107 個執行器。同樣地，所需執行器的最大數量永遠不會超過分配的執行器最大數量。所需的最大執行器數量是根據主動執行和等待中任務計數計算的，因此可能小於活動執行器的數量。這是因為可能有執行器在短時間內部分或完全閒置，且尚未淘汰。 ![\[圖形顯示了達到最大分配總數的主動執行器。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-capacity-4.png) 此任務執行使用 6 倍以上的執行器從 Amazon S3 平行讀取和寫入。因此，此任務執行會為讀取和寫入使用更多的 Amazon S3 頻寬，並且更快完成。 ### 識別過度佈建的 DPU 接下來，您可以判斷使用 100 DPU (99 \$1 2 = 198 執行器) 擴展任務是否有助於進一步擴展。如下圖顯示，該任務仍然需要三分鐘來完成。同樣，任務不會超出 107 個執行器 (55 個 DPU 組態)，其餘 91 個執行器被過度佈建而完全不使用。這表示增加的 DPU 數量有時可能無法提高效能，這從所需的最大執行器數量中可以看出。 ![\[圖形顯示提高 DPU 數目有時可能無法提高任務效能。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/monitor-debug-capacity-5.png) ### 比較時間差異 下表中顯示的三個任務執行總結了 10 個 DPU、55 個 DPU 和 100 個 DPU 的任務執行時間。您可以使用監控第一個任務執行建立的評估來尋找 DPU 容量以改善任務執行時間。 | 任務 ID | DPU 數量 | 執行時間 | | --- | --- | --- | | jr\$1c894524c8ef5048a4d9... | 10 | 6 分鐘。 | | jr\$11a466cf2575e7ffe6856... | 55 | 3 分鐘。 | | jr\$134fa1ed4c6aa9ff0a814... | 100 | 3 分鐘。 | # Glue 中 Apache Spark 的生成式 AI AWS 疑難排解 Glue 中 Apache Spark AWS 任務的生成式 AI 疑難排解是一項新功能，可協助資料工程師和科學家輕鬆診斷和修正 Spark 應用程式的問題。此功能利用機器學習和生成式 AI 技術，可分析 Spark 任務中的問題，並提供詳細的根本原因分析以及可行的建議來解決這些問題。Apache Spark 的生成式 AI 疑難排解適用於在 Glue AWS 4.0 版及更高版本上執行的任務。 | | | --- | | 使用採用 AI 技術的故障診斷代理程式轉換您的 Apache Spark 故障診斷，現在支援所有主要部署模式，包括 AWS Glue、Amazon EMR-EC2、Amazon EMR-Serverless 和 Amazon SageMaker AI 筆記本。這個功能強大的代理程式透過將自然語言互動、即時工作負載分析和智慧程式碼建議結合到無縫體驗中，來消除複雜的偵錯程序。如需實作詳細資訊，請參閱[什麼是 Amazon EMR 的 Apache Spark 故障診斷代理](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshoot.html)程式。檢視[使用 Glue 疑難排解代理](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/spark-troubleshooting-using-troubleshooting-agent.html)程式疑難排解範例中的第二個示範。 AWS | ## 適用於 Apache Spark 的生成式 AI 疑難排解如何工作？ 對於失敗的 Spark 任務，生成式 AI 疑難排解會分析任務中繼資料，以及與任務錯誤簽章相關聯的精確指標和日誌，以產生根本原因分析，並建議特定解決方案和最佳實務，以協助解決任務失敗。 ## 針對您的任務設定適用於 Apache Spark 的生成式 AI 疑難排解 ### 設定 IAM 許可權限 授予許可給 Glue 中任務的 Spark 故障診斷所使用的 APIs AWS ，需要適當的 IAM 許可。您可以透過將下列自訂 AWS 政策連接至 IAM 身分 （例如使用者、角色或群組） 來取得許可。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "glue:StartCompletion", "glue:GetCompletion" ], "Resource": [ "arn:aws:glue:*:*:completion/*", "arn:aws:glue:*:*:job/*" ] } ] } ``` ------ **注意** IAM 政策中使用下列兩個 APIs，透過 Glue Studio AWS 主控台啟用此體驗： `StartCompletion`和 `GetCompletion`。 ### 指派權限 若要提供存取權，請新增權限至您的使用者、群組或角色： + 對於 IAM Identity Center 中的使用者和群組：建立許可集。請按照《IAM Identity Center 使用者指南》中[建立許可集](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html)的說明進行操作。 + 對於在 IAM 中透過身分提供者管理的使用者：建立聯合身分的角色。請按照《IAM 使用者指南》的[為第三方身分提供者 (聯合) 建立角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html)中的指示進行操作。 + 對於 IAM 使用者：建立您的使用者可擔任的角色。請按照《IAM 使用者指南》的[為 IAM 使用者建立角色](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html)中的指示進行操作。 ## 從失敗的任務執行中執行疑難排解分析 您可以透過 Glue AWS 主控台中的多個路徑存取故障診斷功能。以下是如何開始： ### 選項 1：從「任務清單」頁面中 1. 開啟 AWS 位於 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 的 Glue 主控台。 1. 在導覽窗格中，選擇 **ETL 任務**。 1. 在任務清單中找到失敗的任務。 1. 在任務詳細資訊區段中選取**執行**索引標籤。 1. 按一下您要分析的失敗任務執行。 1. 選擇**使用 AI 進行疑難排解**以開始分析。 1. 疑難排解分析完成後，可以在畫面底部的**疑難排解分析**索引標籤中檢視根本原因分析和建議。 ![\[GIF 會顯示失敗執行的端對端實作，並透過 AI 功能執行進行疑難排解。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/troubleshoot_spark_option_1_jobs_list.gif) ### 選項 2：使用「任務執行監控」頁面 1. 導覽至**任務執行監控**頁面。 1. 找到失敗的任務執行。 1. 選擇**動作**下拉式功能表。 1. 選擇**使用 AI 進行故障診斷**。 ![\[GIF 會顯示失敗執行的端對端實作，並透過 AI 功能執行進行疑難排解。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/troubleshoot_spark_option_2_job_monitoring.gif) ### 選項 3：從「任務執行詳細資訊」頁面中 1. 按一下**執行**索引標籤中失敗執行的**檢視詳細資訊**，或在**任務執行監控**頁面中選取任務執行，導覽至失敗任務執行的詳細資訊頁面。 1. 在任務執行詳細資訊頁面中，找到**疑難排解分析**索引標籤。 ## 支援的故障診斷類別 此服務著重於資料工程師和開發人員在其 Spark 應用程式中經常遇到的三個主要問題類別： + **資源設定和存取錯誤：**在 Glue AWS 中執行 Spark 應用程式時，資源設定和存取錯誤是最常診斷但具挑戰性的問題之一。當您的 Spark 應用程式嘗試與 AWS 資源互動，但遇到許可問題、資源遺失或組態問題時，通常會發生這些錯誤。 + **Spark 驅動程式和執行器記憶體問題：**Apache Spark 任務中的記憶體相關錯誤的診斷和解決可能很複雜。當資料處理要求超過驅動程式節點或執行器節點上可用的記憶體資源時，這些錯誤通常會顯現出來。 + **Spark 磁碟容量問題：**Glue Spark 任務中的儲存相關錯誤通常會在隨機播放操作、資料溢出或處理大規模資料轉換時出現。 AWS 這些錯誤可能特別棘手，因為其可能會在您的任務執行一段時間後才會顯現，因此可能會浪費寶貴的運算時間和資源。 + **查詢執行錯誤：**Spark SQL 和 DataFrame 操作中的查詢失敗可能難以進行故障診斷，因為錯誤訊息可能無法明確指向根本原因，並且可以使用小型資料集的查詢可能會突然大規模失敗。當這些錯誤在複雜的轉換管道中深入發生時，會變得更加具有挑戰性，其中實際問題可能來自較早階段的資料品質問題，而不是查詢邏輯本身。 **注意** 在生產環境中實作任何建議的變更之前，請徹底檢閱建議的變更。此服務會根據模式和最佳實務提供建議，但您的特定使用案例可能需要其他考量。 ## 支援的 區域 Apache Spark 的生成式 AI 疑難排解可在下列區域使用： + **非洲**：開普敦 (af-south-1) + **亞太區域**：香港 (ap-east-1)、東京 (ap-northeast-1)、首爾 (ap-northeast-2)、大阪 (ap-northeast-3)、孟買 (ap-south-1)、新加坡 (ap-southeast-1)、雪梨 (ap-southeast-2) 和雅加達 (ap-southeast-3) + **歐洲**：法蘭克福 (eu-central-1)、斯德哥爾摩 (eu-north-1)、米蘭 (eu-south-1)、愛爾蘭 (eu-west-1)、倫敦 (eu-west-2) 和巴黎 (eu-west-3) + **中東**：巴林 (me-south-1) 和阿拉伯聯合大公國 (me-central-1) + **北美洲**：加拿大 (ca-central-1) + **南美洲**：聖保羅 (sa-east-1) + **美國**：北維吉尼亞 (us-east-1)、俄亥俄 (us-east-2)、北加州 (us-west-1) 和奧勒岡 (us-west-2) # 搭配 Glue AWS 使用具體化視觀表 AWS Glue 5.1 版和更新版本支援在 Glue Data Catalog 中建立和管理 Apache Iceberg AWS 具體化視觀表。具體化檢視是受管資料表，以 Apache Iceberg 格式存放 SQL 查詢的預先計算結果，並隨著基礎來源資料表的變更遞增更新。您可以使用具體化視觀表來簡化資料轉換管道，並加速複雜分析工作負載的查詢效能。 當您使用 Glue 中的 Spark AWS 建立具體化檢視時，檢視定義和中繼資料會存放在 AWS Glue Data Catalog 中。預先計算的結果會以 Apache Iceberg 資料表的形式存放在 Amazon S3 Tables 儲存貯體中，或存放在您帳戶中的 Amazon S3 一般用途儲存貯體中。 AWS Glue Data Catalog 會自動監控來源資料表，並使用受管運算基礎設施重新整理具體化視觀表。 **Topics** + [具體化視觀表如何與 Glue AWS 搭配使用](#materialized-views-how-they-work) + [先決條件](#materialized-views-prerequisites) + [設定 Spark 以使用具體化視觀表](#materialized-views-configuring-spark) + [建立具體化視觀表](#materialized-views-creating) + [查詢具體化視觀表](#materialized-views-querying) + [重新整理具體化視觀表](#materialized-views-refreshing) + [管理具體化視觀表](#materialized-views-managing) + [具體化視觀表的許可](#materialized-views-permissions) + [監控具體化視觀表操作](#materialized-views-monitoring) + [範例：完成工作流程](#materialized-views-complete-workflow) + [考量和限制](#materialized-views-considerations-limitations) ## 具體化視觀表如何與 Glue AWS 搭配使用 具體化視觀表透過 Glue AWS 任務和 Glue Studio 筆記本中的 Apache Spark Iceberg AWS 支援與 AWS Glue 整合。當您將 Spark 工作階段設定為使用 AWS Glue Data Catalog 時，您可以使用標準 SQL 語法建立具體化檢視。Spark 最佳化工具可以在提供更好的效能時自動重寫查詢，以使用具體化視觀表，無需手動修改應用程式程式碼。 Glue Data Catalog AWS 會處理具體化視觀表維護的所有操作層面，包括： + 使用 Apache Iceberg 的中繼資料層偵測來源資料表中的變更 + 使用受管 Spark 運算排程和執行重新整理操作 + 根據資料變更決定是否執行完整或增量重新整理 + 將預先計算的結果儲存為 Apache Iceberg 格式以進行多引擎存取 您可以使用用於一般資料表的相同 Spark SQL 介面，從 AWS Glue 查詢具體化視觀表。預先計算的資料也可以從其他 服務存取，包括 Amazon Athena 和 Amazon Redshift。 ## 先決條件 若要搭配 Glue AWS 使用具體化視觀表，您需要： + 一個 帳戶 + AWS Glue 5.1 版或更新版本 + 在 Glue Data Catalog AWS 中註冊的 Apache Iceberg 格式來源資料表 + AWS Lake Formation 針對來源資料表和目標資料庫設定的許可 + 向 註冊的 S3 Tables 儲存貯體或 S3 一般用途儲存貯體， AWS Lake Formation 用於存放具體化視觀表資料 + 具有存取 Glue Data Catalog AWS 和 Amazon S3 許可的 IAM 角色 ## 設定 Spark 以使用具體化視觀表 若要在 Glue AWS 中建立和管理具體化視觀表，請使用所需的 Iceberg 延伸模組和目錄設定來設定 Spark 工作階段。組態方法取決於您使用的是 AWS Glue 任務或 Glue Studio AWS 筆記本。 ### 設定 AWS Glue 任務 建立或更新 AWS Glue 任務時，請將下列組態參數新增為任務參數： #### 對於 S3 Tables 儲存貯體 ``` job = glue.create_job( Name='materialized-view-job', Role='arn:aws:iam::111122223333:role/GlueServiceRole', Command={ 'Name': 'glueetl', 'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py', 'PythonVersion': '3' }, DefaultArguments={ '--enable-glue-datacatalog': 'true', '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ' '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.glue_catalog.type=glue ' '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse ' '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 ' '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ' '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.catalog.s3t_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.s3t_catalog.type=glue ' '--conf spark.sql.catalog.s3t_catalog.glue.id=111122223333:s3tablescatalog/my-table-bucket ', '--conf spark.sql.catalog.s3t_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.s3t_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.catalog.s3t_catalog.warehouse=s3://amzn-s3-demo-bucket/mv-warehouse ' '--conf spark.sql.catalog.s3t_catalog.glue.region=us-east-1 ' '--conf spark.sql.defaultCatalog=s3t_catalog ' '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true ' '--conf spark.sql.materializedViews.metadataCache.enabled=true' }, GlueVersion='5.1' ) ``` #### 對於 S3 一般用途儲存貯體 ``` job = glue.create_job( Name='materialized-view-job', Role='arn:aws:iam::111122223333:role/GlueServiceRole', Command={ 'Name': 'glueetl', 'ScriptLocation': 's3://amzn-s3-demo-bucket/scripts/mv-script.py', 'PythonVersion': '3' }, DefaultArguments={ '--enable-glue-datacatalog': 'true', '--conf': 'spark.sql.extensions=org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions ' '--conf spark.sql.catalog.glue_catalog=org.apache.iceberg.spark.SparkCatalog ' '--conf spark.sql.catalog.glue_catalog.type=glue ' '--conf spark.sql.catalog.glue_catalog.warehouse=s3://amzn-s3-demo-bucket/warehouse ' '--conf spark.sql.catalog.glue_catalog.glue.region=us-east-1 ' '--conf spark.sql.catalog.glue_catalog.glue.id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.account-id=111122223333 ', '--conf spark.sql.catalog.glue_catalog.glue.lakeformation-enabled=true ', '--conf spark.sql.defaultCatalog=glue_catalog ' '--conf spark.sql.optimizer.answerQueriesWithMVs.enabled=true ' '--conf spark.sql.materializedViews.metadataCache.enabled=true' }, GlueVersion='5.1' ) ``` ### 設定 AWS Glue Studio 筆記本 在 AWS Glue Studio 筆記本中，使用筆記本開頭的 %%configure 魔術命令來設定 Spark 工作階段： ``` %%configure { "conf": { "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions", "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.glue_catalog.type": "glue", "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse", "spark.sql.catalog.glue_catalog.glue.region": "us-east-1", "spark.sql.catalog.glue_catalog.glue.id": "111122223333", "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333", "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true", "spark.sql.defaultCatalog": "glue_catalog", "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true", "spark.sql.materializedViews.metadataCache.enabled": "true" } } ``` ### 啟用增量重新整理 若要啟用增量重新整理最佳化，請將下列組態屬性新增至您的任務參數或筆記本組態： ``` --conf spark.sql.optimizer.incrementalMVRefresh.enabled=true --conf spark.sql.optimizer.incrementalMVRefresh.deltaThresholdCheckEnabled=false ``` ### 組態參數 下列組態參數控制具體化視觀表行為： + `spark.sql.extensions` – 啟用具體化視觀表支援所需的 Iceberg Spark 工作階段延伸。 + `spark.sql.optimizer.answerQueriesWithMVs.enabled` – 啟用自動查詢重寫以使用具體化視觀表。設定為 true 以啟用此最佳化。 + `spark.sql.materializedViews.metadataCache.enabled` – 啟用具體化檢視中繼資料的快取，以進行查詢最佳化。設為 true 可改善查詢重寫效能。 + `spark.sql.optimizer.incrementalMVRefresh.enabled` – 啟用增量重新整理最佳化。設為 true 以在重新整理操作期間僅處理已變更的資料。 + `spark.sql.optimizer.answerQueriesWithMVs.decimalAggregateCheckEnabled` – 控制查詢重寫中小數彙總操作的驗證。設定為 false 以停用特定小數溢位檢查。 ## 建立具體化視觀表 您可以使用 Glue 任務或筆記本中的 CREATE MATERIALIZED VIEW SQL AWS 陳述式建立具體化視觀表。檢視定義會將轉換邏輯指定為參考一或多個來源資料表的 SQL 查詢。 ### 在 Glue AWS 任務中建立基本具體化視觀表 下列範例示範在 Glue AWS 任務指令碼中建立具體化檢視，在檢視定義中使用具有三個部分命名慣例的完整資料表名稱： ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Create materialized view spark.sql(""" CREATE MATERIALIZED VIEW customer_orders AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### 使用自動重新整理建立具體化視觀表 若要設定自動重新整理，請在建立檢視時指定重新整理排程，在檢視定義中使用具有三個部分命名慣例的完整資料表名稱： ``` spark.sql(""" CREATE MATERIALIZED VIEW customer_orders SCHEDULE REFRESH EVERY 1 HOUR AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### 使用跨目錄參考建立具體化視觀表 當您的來源資料表與具體化檢視位於不同的目錄中時，請在檢視名稱和檢視定義中使用具有三部分命名慣例的完整資料表名稱： ``` spark.sql(""" CREATE MATERIALIZED VIEW s3t_catalog.analytics.customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) ``` ### 在 Glue Studio AWS 筆記本中建立具體化視觀表 在 AWS Glue Studio 筆記本中，您可以使用 %%sql 魔術命令，在檢視定義中使用具有三個部分命名慣例的完整資料表名稱來建立具體化檢視： ``` %%sql CREATE MATERIALIZED VIEW customer_orders AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name ``` ## 查詢具體化視觀表 建立具體化檢視後，您可以使用 Glue 任務或筆記本中的標準 SQL SELECT AWS 陳述式，像任何其他資料表一樣進行查詢。 ### 在 Glue AWS 任務中查詢 ``` from awsglue.context import GlueContext from pyspark.context import SparkContext sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Query materialized view result = spark.sql("SELECT * FROM customer_orders") result.show() ``` ### 在 AWS Glue Studio 筆記本中查詢 ``` %%sql SELECT * FROM customer_orders ``` ### 自動查詢重寫 啟用自動查詢重寫時，Spark 最佳化工具會分析您的查詢，並在可以改善效能時自動使用具體化視觀表。例如，如果您執行下列查詢： ``` result = spark.sql(""" SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name """) ``` Spark 最佳化工具會自動重寫此查詢，以使用 customer\$1orders 具體化檢視，而不是處理基本訂單資料表，前提是具體化檢視是最新的。 ### 驗證自動查詢重寫 若要驗證查詢是否使用自動查詢重寫，請使用 EXPLAIN EXTENDED 命令： ``` spark.sql(""" EXPLAIN EXTENDED SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM orders GROUP BY customer_name """).show(truncate=False) ``` 在執行計畫中，尋找 BatchScan 操作中的具體化檢視名稱。如果計劃顯示 BatchScan glue\$1catalog.analytics.customer\$1orders，而不是 BatchScan glue\$1catalog.sales.orders，則查詢會自動重新寫入，以使用具體化視觀表。 請注意，自動查詢重寫需要時間，Spark 中繼資料快取才能在建立具體化檢視之後填入。此程序通常會在 30 秒內完成。 ## 重新整理具體化視觀表 您可以使用兩種方法重新整理具體化視觀表：完全重新整理或增量重新整理。完整重新整理會從所有基礎資料表資料重新計算整個具體化視觀表，而增量重新整理只會處理自上次重新整理以來變更的資料。 ### Glue AWS 任務中的手動完整重新整理 若要完整重新整理具體化視觀表： ``` spark.sql("REFRESH MATERIALIZED VIEW customer_orders FULL") # Verify updated results result = spark.sql("SELECT * FROM customer_orders") result.show() ``` ### Glue AWS 任務中的手動增量重新整理 若要執行增量重新整理，請確定已在 Spark 工作階段組態中啟用增量重新整理，然後執行： ``` spark.sql("REFRESH MATERIALIZED VIEW customer_orders") # Verify updated results result = spark.sql("SELECT * FROM customer_orders") result.show() ``` AWS Glue Data Catalog 會根據檢視定義和變更的資料量，自動判斷增量重新整理是否適用。如果無法進行增量重新整理，操作會回到完全重新整理。 ### 在 AWS Glue Studio 筆記本中重新整理 在筆記本中，使用 %%sql 魔術命令： ``` %%sql REFRESH MATERIALIZED VIEW customer_orders FULL ``` ### 驗證增量重新整理執行 若要確認已成功執行增量重新整理，請在 AWS Glue 任務中啟用偵錯記錄： ``` from awsglue.context import GlueContext from pyspark.context import SparkContext import logging sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session # Enable debug logging logger = logging.getLogger('org.apache.spark.sql') logger.setLevel(logging.DEBUG) # Execute refresh spark.sql("REFRESH MATERIALIZED VIEW customer_orders") ``` 在 Glue AWS 任務日誌中搜尋下列訊息： ``` DEBUG RefreshMaterializedViewExec: Executed Incremental Refresh ``` ## 管理具體化視觀表 AWS Glue 提供 SQL 命令，用於管理任務和筆記本中具體化視觀表的生命週期。 ### 描述具體化視觀表 若要檢視具體化檢視的中繼資料，包括其定義、重新整理狀態和上次重新整理時間戳記： ``` spark.sql("DESCRIBE EXTENDED customer_orders").show(truncate=False) ``` ### 變更具體化視觀表 若要修改現有具體化檢視的重新整理排程： ``` spark.sql(""" ALTER MATERIALIZED VIEW customer_orders ADD SCHEDULE REFRESH EVERY 2 HOURS """) ``` 若要移除自動重新整理： ``` spark.sql(""" ALTER MATERIALIZED VIEW customer_orders DROP SCHEDULE """) ``` ### 捨棄具體化視觀表 若要刪除具體化檢視： ``` spark.sql("DROP MATERIALIZED VIEW customer_orders") ``` 此命令會從 Glue Data Catalog AWS 中移除具體化檢視定義，並從 S3 儲存貯體中刪除基礎 Iceberg 資料表資料。 ### 列出具體化視觀表 若要列出資料庫中的所有具體化視觀表： ``` spark.sql("SHOW VIEWS FROM analytics").show() ``` ## 具體化視觀表的許可 若要建立和管理具體化視觀表，您必須設定 AWS Lake Formation 許可。建立具體化檢視的 IAM 角色 （定義者角色） 需要來源資料表和目標資料庫的特定許可。 ### 定義者角色的必要許可 定義者角色必須具有下列 Lake Formation 許可： + 在來源資料表上 – 沒有資料列、資料欄或儲存格篩選條件的 SELECT 或 ALL 許可 + 在目標資料庫上 – CREATE\$1TABLE 許可 + 在 AWS Glue Data Catalog 上 – GetTable 和 CreateTable API 許可 當您建立具體化檢視時，定義者角色的 ARN 會存放在檢視定義中。 AWS Glue Data Catalog 會在執行自動重新整理操作時擔任此角色。如果定義者角色無法存取來源資料表，重新整理操作將會失敗，直到許可還原為止。 ### Glue 任務的 IAM AWS 許可 Glue AWS 任務的 IAM 角色需要下列許可： ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "glue:GetCatalog", "glue:GetCatalogs", "glue:GetTable", "glue:GetTables", "glue:CreateTable", "glue:UpdateTable", "glue:DeleteTable", "glue:GetDatabase", "glue:GetDatabases", "cloudwatch:PutMetricData" ], "Resource": "*" }, { "Effect": "Allow", "Action": [ "s3:GetObject", "s3:PutObject", "s3:DeleteObject" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/*" ] }, { "Effect": "Allow", "Action": [ "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ] }, { "Effect": "Allow", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Resource": [ "arn:aws:logs:*:*:*:/aws-glue/*" ] }, { "Effect": "Allow", "Action": [ "lakeformation:GetDataAccess" ], "Resource": "*" } ] } ``` 您用於具體化檢視自動重新整理的角色必須具有角色的 iam：PassRole 許可。 ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/materialized-view-role-name" ] } ] } ``` 若要讓 Glue 為您自動重新整理具體化視觀表，該角色也必須具有下列信任政策，讓服務能夠擔任該角色。 ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::111122223333:role/materialized-view-role-name" ] } ] } ``` 如果具體化檢視存放在 S3 資料表儲存貯體中，您也需要將下列許可新增至角色。 ``` { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3tables:PutTableMaintenanceConfiguration" ], "Resource": "arn:aws:s3tables:*:123456789012:*" } ] } ``` ### 授予具體化視觀表的存取權 若要授予其他使用者查詢具體化視觀表的存取權，請使用 AWS Lake Formation 授予具體化視觀表的 SELECT 許可。使用者可以查詢具體化視觀表，而不需要直接存取基礎來源資料表。 如需設定 Lake Formation 許可的詳細資訊，請參閱《 AWS Lake Formation 開發人員指南》中的授予和撤銷 Data Catalog 資源的許可。 ## 監控具體化視觀表操作 AWS Glue Data Catalog 會將具體化檢視重新整理操作的指標和日誌發佈至 Amazon CloudWatch。您可以監控透過 CloudWatch 指標處理的重新整理狀態、持續時間和資料磁碟區。 ### 檢視任務日誌 若要檢視建立或重新整理具體化檢視之 AWS Glue 任務的日誌： 1. 開啟 AWS Glue 主控台。 1. 從導覽窗格中選擇任務。 1. 選取您的任務，然後選擇執行。 1. 選取特定的執行，然後選擇日誌以檢視 CloudWatch 日誌。 ### 設定警示 若要在重新整理操作失敗或超過預期持續時間時接收通知，請在具體化檢視指標上建立 CloudWatch 警示。您也可以設定 Amazon EventBridge 規則來觸發重新整理事件的自動回應。 ## 範例：完成工作流程 下列範例示範在 Glue AWS 中建立和使用具體化檢視的完整工作流程。 ### 範例 AWS Glue 任務指令碼 ``` import sys from awsglue.transforms import * from awsglue.utils import getResolvedOptions from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.job import Job args = getResolvedOptions(sys.argv, ['JOB_NAME']) sc = SparkContext() glueContext = GlueContext(sc) spark = glueContext.spark_session job = Job(glueContext) job.init(args['JOB_NAME'], args) # Create database and base table spark.sql("CREATE DATABASE IF NOT EXISTS sales") spark.sql("USE sales") spark.sql(""" CREATE TABLE IF NOT EXISTS orders ( id INT, customer_name STRING, amount DECIMAL(10,2), order_date DATE ) """) # Insert sample data spark.sql(""" INSERT INTO orders VALUES (1, 'John Doe', 150.00, DATE('2024-01-15')), (2, 'Jane Smith', 200.50, DATE('2024-01-16')), (3, 'Bob Johnson', 75.25, DATE('2024-01-17')) """) # Create materialized view spark.sql(""" CREATE MATERIALIZED VIEW customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name """) # Query the materialized view print("Initial materialized view data:") spark.sql("SELECT * FROM customer_summary").show() # Insert additional data spark.sql(""" INSERT INTO orders VALUES (4, 'Jane Smith', 350.00, DATE('2024-01-18')), (5, 'Bob Johnson', 100.25, DATE('2024-01-19')) """) # Refresh the materialized view spark.sql("REFRESH MATERIALIZED VIEW customer_summary FULL") # Query updated results print("Updated materialized view data:") spark.sql("SELECT * FROM customer_summary").show() job.commit() ``` ### 範例 AWS Glue Studio 筆記本 ``` %%configure { "conf": { "spark.sql.extensions": "org.apache.iceberg.spark.extensions.IcebergSparkSessionExtensions", "spark.sql.catalog.glue_catalog": "org.apache.iceberg.spark.SparkCatalog", "spark.sql.catalog.glue_catalog.type": "glue", "spark.sql.catalog.glue_catalog.warehouse": "s3://amzn-s3-demo-bucket/warehouse", "spark.sql.catalog.glue_catalog.glue.region": "us-east-1", "spark.sql.catalog.glue_catalog.glue.id": "111122223333", "spark.sql.catalog.glue_catalog.glue.account-id": "111122223333", "spark.sql.catalog.glue_catalog.glue.lakeformation-enabled": "true", "spark.sql.defaultCatalog": "glue_catalog", "spark.sql.optimizer.answerQueriesWithMVs.enabled": "true", "spark.sql.materializedViews.metadataCache.enabled": "true" } } ``` ``` %%sql CREATE DATABASE IF NOT EXISTS sales ``` ``` %%sql USE sales ``` ``` %%sql CREATE TABLE IF NOT EXISTS orders ( id INT, customer_name STRING, amount DECIMAL(10,2), order_date DATE ) ``` ``` %%sql INSERT INTO orders VALUES (1, 'John Doe', 150.00, DATE('2024-01-15')), (2, 'Jane Smith', 200.50, DATE('2024-01-16')), (3, 'Bob Johnson', 75.25, DATE('2024-01-17')) ``` ``` %%sql CREATE MATERIALIZED VIEW customer_summary AS SELECT customer_name, COUNT(*) as order_count, SUM(amount) as total_amount FROM glue_catalog.sales.orders GROUP BY customer_name ``` ``` %%sql SELECT * FROM customer_summary ``` ``` %%sql INSERT INTO orders VALUES (4, 'Jane Smith', 350.00, DATE('2024-01-18')), (5, 'Bob Johnson', 100.25, DATE('2024-01-19')) ``` ``` %%sql REFRESH MATERIALIZED VIEW customer_summary FULL ``` ``` %%sql SELECT * FROM customer_summary ``` ## 考量和限制 搭配 Glue AWS 使用具體化視觀表時，請考慮下列事項： + 具體化視觀表需要 AWS Glue 5.1 版或更新版本。 + 來源資料表必須是在 Glue Data Catalog 中註冊的 Apache Iceberg AWS 資料表。啟動時不支援 Apache Hive、Apache Hudi 和 Linux Foundation Delta Lake 資料表。 + 來源資料表必須位於與具體化視觀表相同的區域和帳戶中。 + 所有來源資料表都必須由 管理 AWS Lake Formation。不支援僅限 IAM 的許可和混合存取。 + 具體化視觀表無法參考 AWS Glue Data Catalog 檢視、多方視觀表或其他具體化視觀表作為來源資料表。 + 檢視定義者角色必須在未套用資料列、資料欄或儲存格篩選條件的所有來源資料表上具有完整讀取存取權 (SELECT 或 ALL 許可）。 + 具體化視觀表最終與來源資料表一致。在重新整理時段期間，查詢可能會傳回過時的資料。執行手動重新整理以立即保持一致性。 + 最短自動重新整理間隔為一小時。 + 增量重新整理支援 SQL 操作的限制子集。檢視定義必須是單一 SELECT-FROM-WHERE-GROUP BY-HAVING 區塊，而且不能包含設定操作、子查詢、SELECT 或彙總函數中的 DISTINCT 關鍵字、視窗函數或 INNER JOIN 以外的聯結。 + 增量重新整理不支援使用者定義的函數或特定內建函數。僅支援 Spark SQL 內建函數的子集。 + 查詢自動重寫只會考慮具體化視觀表，其定義屬於與增量重新整理限制類似的受限 SQL 子集。 + CREATE MATERIALIZED VIEW 查詢不支援包含英數字元和底線以外的特殊字元的識別符。這適用於所有識別符類型，包括catalog/namespace/table名稱、資料欄和結構欄位名稱、CTEs 和別名。 + 以 \$1\$1ivm 字首開頭的具體化檢視資料欄會保留供系統使用。Amazon 保留在未來版本中修改或移除這些資料欄的權利。 + 具體化視觀表定義不支援 SORT BY、LIMIT、OFFSET、CLUSTER BY 和 ORDER BY 子句。 + 不支援跨區域和跨帳戶來源資料表。 + 檢視查詢中參考的資料表必須使用三部分命名慣例 （例如 glue\$1catalog.my\$1db.my\$1table)，因為自動重新整理不會使用預設目錄和資料庫設定。 + 完整重新整理操作會覆寫整個資料表，並使先前的快照無法使用。 + 具體化視觀表定義不支援非確定性函數，例如 rand() 或 current\$1timestamp()。