本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。 # 監控 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 分鐘。 |