本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。 # 使用互動式工作階段建置 AWS Glue 任務 使用 AWS Glue 中的互動式工作階段，資料工程師可以比之前更快、更輕鬆地編寫 AWS Glue 任務。 **Topics** + [AWS Glue 互動式工作階段概觀](#interactive-sessions-overview) + [AWS Glue 互動式工作階段入門](interactive-sessions.md) + [為 Jupyter 和 AWS Glue Studio 筆記本設定 AWS Glue 互動式工作階段](interactive-sessions-magics.md) + [將指令碼或筆記本轉換為 AWS Glue 任務](interactive-sessions-convert.md) + [在 AWS Glue 互動式工作階段中使用串流操作](interactive-sessions-streaming.md) + [AWS Glue 互動式工作階段定價](interactive-sessions-session-pricing.md) + [在本機開發和測試 AWS Glue 任務指令碼](aws-glue-programming-etl-libraries.md) + [開發端點](development.md) ## AWS Glue 互動式工作階段概觀 使用 AWS Glue 互動式工作階段，您可以快速建置、測試和執行資料準備和分析應用程式。互動式工作階段提供用於建置和測試資料準備之擷取、轉換和載入 (ETL) 指令碼的程式化和視覺化介面。互動式工作階段執行 Apache Spark 分析應用程式，並提供對遠端 Spark 執行階段環境的隨需存取權。AWS Glue 透明地管理這些互動式工作階段的無伺服器 Spark。 互動式工作階段具有彈性，因此您可以從選擇的環境建置和測試應用程式。您可以透過 和 API 建立 AWS Command Line Interface 和使用互動式工作階段。您可以使用與 Jupyter 相容的筆記本，以視覺化方式編寫和測試您的筆記本指令碼。互動式工作階段提供了開放原始碼的 Jupyter 核心，其幾乎整合了 Jupyter 所出現的任何地方，包括與 PyCharm、IntelliJ 和 VS Code 等 IDE 整合。這可讓您在本機環境中編寫程式碼，並在互動式工作階段後端順暢地執行程式碼。 使用互動式工作階段 API，客戶可以透過程式設計方式執行使用 Apache Spark 分析的應用程式，而無需管理 Spark 基礎設施。您可以在單一互動式工作階段內執行一或多個 Spark 陳述式。 因此，互動式工作階段提供更快速、便宜、靈活的方式來建置和執行資料準備和分析應用程式。若要了解如何使用互動式工作階段，請參閱本節中的文件。[AWS Glue 支援的魔術命令](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-magics.html#interactive-sessions-magics2) ### 限制 + 互動式工作階段中不支援任務書籤。 + AWS Command Line Interface 不支援使用 建立筆記本任務。 + AWS Glue Studio 筆記本不支援 Scala。 # AWS Glue 互動式工作階段入門 這些章節說明如何執行 AWS Glue 本機互動式工作階段。 ## 在本機設定互動式工作階段的先決條件 下列是安裝互動式工作階段的先決條件： + 支援的 Python 版本為 3.6 至 3.10 以上版本。 + 請參閱以下章節來取得 MacOS/Linux 和 Windows 的相關指示。 + 檢閱[互動式工作階段定價](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-session-pricing.html)文件以了解成本結構。 ## 安裝 Jupyter 和 AWS Glue 互動式工作階段 Jupyter 核心 使用以下命令在本機安裝核心。 `install-glue-kernels` 命令會同時為 Pyspark 和 Spark 核心安裝 jupyter kernelspec，並在正確的目錄中安裝標誌。 ``` pip3 install --upgrade jupyter boto3 aws-glue-sessions ``` ``` install-glue-kernels ``` ## 執行 Jupyter 若要執行 Jupyter 筆記本，請完成以下步驟。 1. 執行下列命令以啟動 Jupyter 筆記本。 ``` jupyter notebook ``` 1. 選擇 **New** (新增)，然後選擇其中一個 AWS Glue 核心以開始針對 AWS Glue 編碼。 ## 設定工作階段憑證和區域 ### MacOS/Linux 指示 AWS Glue 互動式工作階段需要與 AWS Glue 任務和開發端點相同的 IAM 許可。使用下列兩種方式之一指定與互動式工作階段搭配使用的角色： 1. 使用 `%iam_role` 和 `%region` 魔術命令 1. 使用 `~/.aws/config` 中額外的行 **使用魔術命令設定工作階段角色** 在第一個儲存格中，在執行的第一個儲存格中鍵入 `%iam_role `。 **Configuring a session role with `~/.aws/config`** (使用 設定工作階段角色) AWS Glue 互動式工作階段的服務角色可以在筆記本本身中指定，或與 AWS CLI 組態一起存放。如果您有一個通常與 AWS Glue 任務一起使用的角色，那麼這就是該角色。如果您沒有用於 AWS Glue 任務的角色，請遵循本指南：《[設定用於 AWS Glue 的 IAM 許可](https://docs.aws.amazon.com/glue/latest/dg/configure-iam-for-glue.html)》來進行設定。 若要將此角色設定為互動式工作階段的預設角色： 1. 在文字編輯器中開啟 `~/.aws/config`。 1. 尋找您用於 AWS Glue 的設定檔。如果您不使用設定檔，請使用 `[Default]` 設定檔。 1. 在設定檔中為您打算使用的角色新增一行，如 `glue_role_arn=`。 1. [選用]：如果您的設定檔沒有設定預設區域，建議使用 `region=us-east-1` 新增一個區域，將 `us-east-1` 替換為您所需的區域。 1. 儲存組態。 如需詳細資訊，請參閱[具備 IAM 的互動式工作階段](glue-is-security.md)。 ### Windows 指示 AWS Glue 互動式工作階段需要與 AWS Glue 任務和開發端點相同的 IAM 許可。使用下列兩種方式之一指定與互動式工作階段搭配使用的角色： 1. 使用 `%iam_role` 和 `%region` 魔術命令 1. 使用 `~/.aws/config` 中額外的行 **使用魔術命令設定工作階段角色** 在第一個儲存格中，在執行的第一個儲存格中鍵入 `%iam_role `。 **使用 `~/.aws/config` 設定工作階段角色** AWS Glue 互動式工作階段的服務角色可以在筆記本本身中指定，或與 AWS CLI 組態一起存放。如果您有一個通常與 AWS Glue 任務一起使用的角色，那麼這就是該角色。如果您沒有用於 AWS Glue 任務的角色，請遵循本指南：[設定用於 AWS Glue 的 IAM 許可](https://docs.aws.amazon.com/glue/latest/dg/configure-iam-for-glue.html)，來進行設定。 若要將此角色設定為互動式工作階段的預設角色： 1. 在文字編輯器中開啟 `~/.aws/config`。 1. 尋找您用於 AWS Glue 的設定檔。如果您不使用設定檔，請使用 `[Default]` 設定檔。 1. 在設定檔中為您打算使用的角色新增一行，如 `glue_role_arn=`。 1. [選用]：如果您的設定檔沒有設定預設區域，建議使用 `region=us-east-1` 新增一個區域，將 `us-east-1` 替換為您所需的區域。 1. 儲存組態。 如需詳細資訊，請參閱[具備 IAM 的互動式工作階段](glue-is-security.md)。 ## 從互動式工作階段預覽版升級 在 0.27 版本發佈時，核心已升級並擁有新名稱。若要清理核心的預覽版本，請從終端機或 PowerShell 執行以下命令。 **注意** 如果您的核心是需要自訂服務模型的任何其他 AWS Glue 預覽版的一部分，移除核心會移除自訂服務模型。 ``` # Remove Old Glue Kernels jupyter kernelspec remove glue_python_kernel jupyter kernelspec remove glue_scala_kernel # Remove Custom Model cd ~/.aws/models rm -rf glue/ ``` # 將互動式工作階段與 SageMaker AI Studio 搭配使用 AWS Glue 互動式工作階段是一種隨需、無伺服器、Apache Spark 執行期環境，資料科學家和工程師可用來快速建置、測試和執行資料準備和分析應用程式。您可以啟動 Amazon SageMaker AI Studio Classic 筆記本來啟動 AWS Glue 互動式工作階段。 如需詳細資訊，請參閱[使用 AWS Glue 互動式工作階段來準備資料](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-glue.html)。 # 將互動式工作階段與 Microsoft Visual Studio Code 搭配使用 **先決條件** + 安裝 AWS Glue 互動式工作階段，並確認它能搭配 Jupyter 筆記本運作。 + 使用 Jupyter 下載並安裝與 Visual Studio Code。如需詳細資訊，請參閱 [VS Code 中的 Jupyter 筆記本](https://code.visualstudio.com/docs/datascience/jupyter-notebooks)。 **開始使用 VSCode 的互動式工作階段** 1. 在 VSCode 中停用 Jupyter 自動啟動。 在 Visual Studio Code 中，Jupyter 核心會自動啟動，這會阻止魔術命令生效，因為工作階段已經開始。若要在 Windows 上停用**自動啟動**，請前往**檔案** > **偏好設定** > **延伸模組** > **Jupyter** > 用滑鼠右鍵按一下 Jupyter，然後選擇**延伸模組設定**。 在 MacOS 上，前往**程式碼** > **設定** > **延伸模組** > **Jupyter** > 用滑鼠右鍵按一下 Jupyter，然後選擇**延伸模組設定**。 向下捲動，直到顯示 **Jupyter：停用 Jupyter 自動啟動**。勾選標示為「如果為 true，將停用 Jupyter 自動啟動。您必須改為執行儲存格來啟動 Jupyter。」的核取方塊。 ![\[螢幕擷取畫面顯示了 VS Code 中為 Jupyter 擴充功能啟用的核取方塊。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/IS_vscode_step1.png) 1. 前往 File (檔案) > New File (新建檔案) > Save (儲存)，以您選擇的名稱將此檔案儲存為 `.ipynb` 副檔名或在 **Select a language** (選取一種語言) 下選取 **Jupyter** 並儲存檔案。 ![\[螢幕擷取畫面會顯示使用新名稱儲存的檔案。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/IS_vscode_step2.gif) 1. 按兩下該檔案。會顯示出 Jupyter shell，並打開一個筆記本。 ![\[螢幕擷取畫面會顯示打開的筆記本。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/IS_vscode_step3.png) 1. 當您在 Windows 上首次建立檔案時，依預設不會選取核心。按一下 **Select Kernel** (選取核心)，即可顯示出可用的核心清單。選擇 **Glue PySpark**。 若您未在 MacOS 上看到 **Glue PySpark** 核心，請嘗試執行以下步驟： 1. 執行本機 Jupyter 工作階段以取得 URL。 例如，執行下列命令以啟動 Jupyter 筆記本。 ``` jupyter notebook ``` 當筆記本第一次執行時，您會看到類似 `http://localhost:8888/?token=3398XXXXXXXXXXXXXXXX` 的 URL。 複製 URL。 1. 在 VS Code 中，按一下目前的核心，然後**選取另一個核心…**，接著再選取**現有的 Jupyter 伺服器…**。貼上您從上述步驟複製的 URL。 若顯示錯誤訊息，請參閱 [VS Code Jupyter Wiki](https://github.com/microsoft/vscode-jupyter/wiki/Connecting-to-a-remote-Jupyter-server-from-vscode.dev)。 1. 若執行成功，則會將核心設定為 **Glue PySpark**。 ![\[螢幕擷取畫面會顯示反白的 Select Kernel (選取核心) 按鈕。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/IS_vscode_step4a.png) 選擇 **Glue PySpark** 或 **Glue Spark** 核心 (分別用於 Python 和 Scala)。 ![\[螢幕擷取畫面會顯示 AWS Glue PySpark 的選擇\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/IS_vscode_step4b.png) 如果您在下拉式清單中未看到 **AWS Glue PySpark** 和 **AWS Glue Spark** 核心，請確認您在上述步驟中已安裝 AWS Glue 核心，或 Visual Studio Code 中的 `python.defaultInterpreterPath` 設定正確。如需詳細資訊，請參閱 [python.defaultInterpreterPath 設定說明](https://github.com/microsoft/vscode-python/wiki/Setting-descriptions#pythondefaultinterpreterpath)。 1. 建立 AWS Glue 互動式工作階段。依照您在 Jupyter 筆記本中所做的相同方式繼續建立工作階段。在第一個儲存格頂部指定任何魔術命令，然後執行程式碼語句。 # 具備 IAM 的互動式工作階段 下列章節說明適用於 AWS Glue 互動式工作階段的安全考量。 **Topics** + [與互動式工作階段搭配使用的 IAM 主體](#glue-is-security-iam-principals) + [設定用戶端主體](#glue-is-client-principals) + [設定執行時間角色](#glue-is-runtime-role) + [使用 TagOnCreate 將工作階段設定為私有](#glue-is-tagoncreate) + [IAM 政策考量](#glue-is-security-iam-managed-policy) ## 與互動式工作階段搭配使用的 IAM 主體 您會使用兩個與 AWS Glue 互動式工作階段搭配使用的 IAM 主體。 + **Client principal** (用戶端主體)：用戶端主體 (使用者或角色) 會授權 AWS Glue 用戶端互動式工作階段的 API 操作，用戶端使用主體的身分識別型憑證進行設定。例如，這可能是您通常用來存取 AWS Glue 主控台的 IAM 角色。這也可能是提供給 IAM 中登入資料用於 的使用者的角色 AWS Command Line Interface，或互動式工作階段 Jupyter 核心所使用的AWS Glue用戶端。 + **執行時間角色**：執行時間角色是用戶端主體傳遞給互動式工作階段 API 操作的 IAM 角色。AWS Glue 會使用此角色在工作階段中執行陳述式。例如，此角色可能是用來執行 AWS Glue ETL 任務的角色。 如需詳細資訊，請參閱[設定執行時間角色](#glue-is-runtime-role)。 ## 設定用戶端主體 您必須將身分政策連接至用戶端主體，以允許其呼叫互動式工作階段 API。此角色必須擁有對您傳遞至如 `CreateSession` 等互動式工作階段 API 之執行角色的 `iam:PassRole` 存取權。例如，您可以將 **AWSGlueConsoleFullAccess** 受管政策連接到 IAM 角色，這會允許您帳戶中連接政策的使用者存取您帳戶中建立的所有工作階段 (例如執行時間陳述式或取消陳述式)。 如果您想要保護您的工作階段並使其僅對某些 IAM 角色私有，例如與建立工作階段的使用者關聯的 IAM 角色，那麼您可以使用 AWS Glue 互動式工作階段的以標籤為基礎的授權控制 (稱為 TagOnCreate)。如需詳細資訊，請參閱[使用 TagOnCreate 將工作階段設定為私有](#glue-is-tagoncreate)，瞭解以 owner 標籤為基礎的範圍縮減受管政策如何使用 TagOnCreate 將您的工作階段設定為私有。如需有關以身分為基礎的政策詳細資訊，請參閱 [AWS Glue 以身分為基礎的政策](https://docs.aws.amazon.com/glue/latest/dg/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies)。 ## 設定執行時間角色 您必須將 IAM 角色傳遞給 CreateSession API 操作，才能允許 AWS Glue 在互動式工作階段中承接和執行陳述式。角色應該擁有執行一般 AWS Glue 任務所需的相同 IAM 許可。例如，您可以使用允許 代表您AWS Glue呼叫 服務的 **AWSGlueServiceRole** 政策來建立 AWS 服務角色。如果您使用 AWS Glue 主控台，它會代為自動建立服務角色，或使用現有的服務角色。您也可以建立自己的 IAM 角色，並連接自己的 IAM 政策，以允許類似的許可。 如果您想要保護您的工作階段並使其僅對建立工作階段的使用者私有，那麼您可以使用 AWS Glue 互動式工作階段的以標籤為基礎的授權控制 (稱為 TagOnCreate)。如需詳細資訊，請參閱[使用 TagOnCreate 將工作階段設定為私有](#glue-is-tagoncreate)，瞭解以 owner 標籤為基礎的範圍縮減受管政策如何使用 TagOnCreate 將您的工作階段設定為私有。如需有關以身分為基礎的政策詳細資訊，請參閱 [Glue AWS 的身分型政策](security_iam_service-with-iam.md#security_iam_service-with-iam-id-based-policies)。如果您自己從 IAM 主控台建立執行角色，並且希望使用 TagOnCreate 特徵將您的服務設定為私有，請按照以下步驟操作。 1. 建立 IAM 角色並將角色類型設定為 `Glue`。 1. 連接此 AWS Glue 受管政策：*AwsGlueSessionUserRestrictedServiceRole* 1. 在角色名稱前加上政策名稱 *AwsGlueSessionUserRestrictedServiceRole*。例如，您可以建立名為 *AwsGlueSessionUserRestrictedServiceRole-myrole* 的角色並連接 AWS Glue 受管政策 *AwsGlueSessionUserRestrictedServiceRole*。 1. 連接類似下列項目的信任政策，以允許 AWS Glue 擔任此角色： ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "glue.amazonaws.com" ] }, "Action": [ "sts:AssumeRole" ] } ] } ``` ------ 對於互動式工作階段 Jupyter 核心，您可以在 AWS Command Line Interface 設定檔中指定`iam_role`金鑰。如需詳細資訊，請參閱[使用 \$1/.aws/config 設定工作階段](https://docs.aws.amazon.com/glue/latest/ug/interactive-sessions-magics.html#interactive-sessions-named-profiles)。如果您是使用 AWS Glue 筆記本與互動式工作階段進行互動，則您可以在您執行之第一個儲存格中的 `%iam_role` 魔術命令中傳遞執行角色。 ## 使用 TagOnCreate 將工作階段設定為私有 AWS Glue 互動式工作階段支援對互動式工作階段進行標記和以標籤為基礎的授權 (TBAC) 作為命名資源。除了使用 TagResource 和 UntagResource API 的 TBAC 之外，AWS Glue 互動式工作階段支援 TagOnCreate 特徵，以便僅在使用 CreateSession 操作建立工作階段期間使用給定標籤「標記」工作階段。這也意味著這些標籤將在 DeleteSession 中移除，也就是 UntagOnDelete。 TagOnCreate 提供了一種強大的安全機制，將工作階段設定為工作階段建立者私有。例如，您可以將具有 RequestTag "owner" 和值 \$1\$1aws:userId\$1 的 IAM 政策連接至用戶端主體 (例如使用者)，以便只有在具有呼叫者 userId 相符值的 "owner" 標籤在 CreateSession 請求中提供為 userId 標籤時才允許建立工作階段。此政策允許 AWS Glue 互動式工作階段建立工作階段資源，並僅在工作階段建立期間使用 userId 標籤標記工作階段。除此之外，您還可以透過將具有 ResourceTag "owner" 的 IAM 政策連接至您在 CreateSession 期間傳遞的執行角色，將對工作階段的存取 (如執行陳述句) 權限僅限於工作階段的建立者 (即具有值 \$1\$1aws:userId\$1 的擁有者標籤)。 為了使您更容易使用 TagOnCreate 特徵將工作階段設定為工作階段建立者私有，AWS Glue 提供專用的受管政策和服務角色。 如果您想要使用 IAM AssumeRole 主體 (即使用擔任 IAM 角色提供的憑證) 建立 AWS Glue 互動式工作階段，並且您想要將工作階段設定為建立者私有，然後分別使用類似於 **AWSGlueSessionUserRestrictedNotebookPolicy** 和 **AWSGlueSessionUserRestrictedNotebookServiceRole** 的政策。這些政策允許 AWS Glue 使用 \$1\$1aws:PrincipalTag\$1 來擷取 owner 標籤值。這需要您在擔任角色憑證中將值為 \$1\$1aws:userId\$1 的 userId 標籤作為 SessionTag 傳遞。請參閱 [ID 工作階段標籤](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_session-tags.html)。如果您使用的是帶有販售憑證的執行個體設定檔的 Amazon EC2 執行個體，並且您想要在 Amazon EC2 執行個體中建立工作階段或與工作階段互動，則需要在擔任角色憑證中將值為 \$1\$1aws:userId\$1 的 userId 標籤作為 SessionTag 傳遞。 例如，如果您正使用 IAM AssumeRole 主體憑證建立工作階段，並且希望使用 TagOnCreate 特徵將您的服務設定為私有服務，請按照以下步驟操作。 1. 從 IAM 主控台自行建立執行時間角色。請連接此 AWS Glue 受管政策 *AwsGlueSessionUserRestrictedNotebookServiceRole* 並在角色名稱前加上政策名稱 *AwsGlueSessionUserRestrictedNotebookServiceRole*。例如，您可以建立名為 *AwsGlueSessionUserRestrictedNotebookServiceRole-myrole* 的角色並連接 AWS Glue 受管政策 *AwsGlueSessionUserRestrictedNotebookServiceRole*。 1. 連接類似下方的信任政策，以允許 AWS Glue 來擔任上述角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "glue.amazonaws.com" ] }, "Action": [ "sts:AssumeRole" ] } ] } ``` ------ 1. 建立另一個使用字首 *AwsGlueSessionUserRestrictedNotebookPolicy* 命名的角色，並連接 AWS Glue 受管政策 *AwsGlueSessionUserRestrictedNotebookPolicy* 以使工作階段私有。除了受管政策之外，請連接以下內嵌政策，以允許 iam:PassRole 連接至您在步驟 1 中建立的角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::*:role/AwsGlueSessionUserRestrictedNotebookServiceRole*" ], "Condition": { "StringLike": { "iam:PassedToService": [ "glue.amazonaws.com" ] } } } ] } ``` ------ 1. 將類似下列的信任政策連接到上述 IAM AWS Glue，以擔任此角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "glue.amazonaws.com" ] }, "Action": [ "sts:AssumeRole", "sts:TagSession" ] } ] } ``` ------ **注意** (選用) 您可以使用單一角色 (例如筆記本角色) 並連接上述兩個受管政策 *AwsGlueSessionUserRestrictedNotebookServiceRole* 和 *AwsGlueSessionUserRestrictedNotebookPolicy*。也請連接額外的內嵌政策，以允許您角色的 `iam:passrole` 連接至 AWS Glue。最後連接上述信任政策，以允許 `sts:AssumeRole` 和 `sts:TagSession`。 ### AWSGlueSessionUserRestrictedNotebookPolicy AWSGlueSessionUserRestrictedNotebookPolicy 僅在標籤索引鍵「擁有者」和值符合委託人 （使用者或角色） AWS 的使用者 ID 時，才提供從筆記本建立AWS Glue互動式工作階段的存取權。如需詳細資訊，請參閱[您可以在何處使用政策變數](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#policy-vars-infotouse)。此政策會連接至 AWS Glue Studio 中建立 AWS Glue 互動式工作階段筆記本的主體 (使用者或角色)。此政策也允許足夠存取AWS Glue Studio筆記本，以與使用符合委託人 AWS 使用者 ID 的「擁有者」標籤值所建立的AWS Glue Studio互動式工作階段資源互動。工作階段建立之後，此政策會拒絕對變更或移除 AWS Glue 工作階段資源中 "owner" 標籤的許可。 ### AWSGlueSessionUserRestrictedNotebookServiceRole **AWSGlueSessionUserRestrictedNotebookServiceRole** 提供足夠的筆記本存取權，以便與使用與AWS Glue Studio筆記本建立者主體 （使用者或角色） AWS 的使用者 ID 相符的「擁有者」標籤值所建立的AWS Glue互動式工作階段資源互動。如需詳細資訊，請參閱[您可以在何處使用政策變數](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_variables.html#policy-vars-infotouse)。此服務角色政策會連接至作為魔術命令傳遞給筆記本或作為執行角色傳遞給 CreateSession API 的角色。只有在標籤索引鍵「擁有者」和值符合委託人 AWS 的使用者 ID 時，此政策也允許從筆記本建立AWS Glue互動式工作階段。工作階段建立之後，此政策會拒絕對變更或移除 AWS Glue 工作階段資源中 "owner" 標籤的許可。此政策還包括從 Amazon S3 儲存貯體寫入和讀取、寫入 CloudWatch 日誌、為 AWS Glue 使用的 Amazon EC2 資源建立和刪除標籤的許可。 ### 透過使用者政策將工作階段設定為私有 您可以將 **AWSGlueSessionUserRestrictedPolicy** 連接至您帳戶中每個使用者連接的 IAM 角色，以限制他們僅能使用值與其專屬 \$1\$1aws:userId\$1 相符的擁有者標籤建立工作階段。不會使用 **AWSGlueSessionUserRestrictedNotebookPolicy** 和 **AWSGlueSessionUserRestrictedNotebookServiceRole**。您需要分別使用與 **AWSGlueSessionUserRestrictedPolicy** 和 **AWSGlueSessionUserRestrictedServiceRole** 類似的政策。如需詳細資訊，請參閱[使用以身分為基礎的政策](https://docs.aws.amazon.com/glue/latest/dg/using-identity-based-policies.html)。此政策將對工作階段的存取權縮小到僅限建立者，亦即使用具有專屬 \$1\$1aws:userId\$1 之擁有者標籤建立工作階段的使用者 \$1\$1aws:userId\$1。如果您已按照[設定執行時間角色](#glue-is-runtime-role)中的步驟使用 IAM 主控台自行建立執行角色，則除了連接 **AwsGlueSessionUserRestrictedPolicy** 受管政策外，還要將以下內嵌政策連接至帳戶中的每個使用者，以允許 `iam:PassRole` 用於您先前建立的執行角色。 ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::*:role/AwsGlueSessionUserRestrictedServiceRole*" ], "Condition": { "StringLike": { "iam:PassedToService": [ "glue.amazonaws.com" ] } } } ] } ``` ------ #### AWSGlueSessionUserRestrictedPolicy **AWSGlueSessionUserRestrictedPolicy** 僅在提供符合其 AWS 使用者 ID 的標籤金鑰「擁有者」和值時，才提供使用 CreateSession API 建立AWS Glue互動式工作階段的存取權。此身分政策連接至叫用 CreateSession API 的使用者。此政策也允許 與使用符合其 AWS 使用者 ID 的「擁有者」標籤和值建立的AWS Glue互動式工作階段資源互動。工作階段建立之後，此政策會拒絕對變更或移除 AWS Glue 工作階段資源中 "owner" 標籤的許可。 #### AWSGlueSessionUserRestrictedServiceRole **AWSGlueSessionUserRestrictedServiceRole** 提供所有 AWS Glue 資源的完整存取權 (工作階段除外)，並允許使用者僅建立並使用與使用者相關聯的互動式工作階段。此政策也包含 在其他 AWS 服務中AWS Glue管理 Glue 資源所需的其他許可。此政策也允許將標籤新增至其他服務中的AWS Glue資源 AWS 。 ## IAM 政策考量 互動式工作階段是 AWS Glue 中的 IAM 資源。由於其是 IAM 資源，因此對工作階段的存取和互動受 IAM 政策管控。根據連接至用戶端主體或管理員設定之執行角色的 IAM 政策，用戶端主體 (使用者或角色) 可以建立新的工作階段，並與其本身的工作階段和其他工作階段進行互動。 如果管理員已連接 IAM 政策，例如 AWSGlueConsoleFullAccess 或 AWSGlueServiceRole，該政策允許存取該帳戶中的所有 AWS Glue 資源，則用戶端主體可以彼此協作。例如，如果政策允許，一位使用者可以與其他使用者建立的工作階段進行互動。 如果您想根據您的特定需求設定政策，請參閱[有關設定政策資源的 IAM 說明文件](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html)。例如，為了隔離屬於使用者的工作階段，您可以使用 AWS Glue 互動式工作階段支援的 TagOnCreate 功能。請參閱 [使用 TagOnCreate 將工作階段設定為私有](#glue-is-tagoncreate)。 互動式工作階段支援根據特定 VPC 條件限制建立工作階段。請參閱[控制使用條件索引鍵來控制設定的政策](security_iam_id-based-policy-examples.md#glue-identity-based-policy-condition-key-vpc)。 # 為 Jupyter 和 AWS Glue Studio 筆記本設定 AWS Glue 互動式工作階段 ## Jupyter 魔術命令簡介 Jupyter 魔術命令是可在儲存格的開頭或作為整個儲存格內文執行的命令。行魔術命令的開頭為 `%`，而儲存格魔術命令開頭為 `%%`。行魔術命令，如 `%region` 和 `%connections`，可在儲存格搭配多個魔術命令執行，或者像以下範列那樣搭配包含在儲存格內文中的程式碼。 ``` %region us-east-2 %connections my_rds_connection dy_f = glue_context.create_dynamic_frame.from_catalog(database='rds_tables', table_name='sales_table') ``` 儲存格魔術命令必須使用整個儲存格，並且可以使命令跨越多行。`%%sql` 的範例位於下方。 ``` %%sql select * from rds_tables.sales_table ``` ## 適用於 Jupyter 的 AWS Glue 互動式工作階段支援的魔術命令 以下是可以與適用於 Jupyter 筆記本的 AWS Glue 互動式工作階段搭配使用的魔術命令。 **Sessions magics** (工作階段魔術命令) | 名稱 | 類型 | 說明 | | --- | --- | --- | | %help | N/A | 傳回所有魔術命令的描述和輸入類型清單。 | | %profile | String | 在您的 AWS 組態中指定設定檔，以用作登入資料提供者。 | | %region | String | 指定 AWS 區域；在其中初始化工作階段。預設來自 `~/.aws/configure.` 範例：`%region us-west-1` | | %idle\$1timeout | Int | 在執行儲存格後工作階段逾時之前的閒置分鐘數。預設的 Spark ETL 工作階段閒置逾時值為預設的逾時值，即 2880 分鐘 (48 小時)。針對其他工作階段類型，請參閱該工作階段類型的相關文件。 範例：`%idle_timeout 3000` | | %session\$1id | N/A | 傳回執行中工作階段的工作階段 ID。 | | %session\$1id\$1prefix | String | 定義一個字串，該字串將放在所有工作階段 ID 之前，格式為 **[session\$1id\$1prefix]-[session\$1id]**。如果未提供工作階段 ID，則會產生隨機 UUID。當您在 AWS Glue Studio中執行 Jupyter 筆記本時，不支援此魔術命令。 範例：`%session_id_prefix 001` | | %status | | 傳回當前 AWS Glue 工作階段的狀態，包括其持續時間、組態和執行使用者/角色。 | | %stop\$1session | | 停止目前的工作階段。 | | %list\$1sessions | | 依名稱和 ID 列出所有目前執行中的工作階段。 | | %session\$1type | String | 將工作階段類型設為「串流」、「ETL」或「Ray」的其中之一。 範例：`%session_type Streaming` | | %glue\$1version | String | 此工作階段要使用的 AWS Glue 版本。 範例：`%glue_version 3.0` | **用於選取任務類型的魔術命令** | 名稱 | 類型 | Description | | --- | --- | --- | | %streaming | String | 將工作階段類型變更為 AWS Glue 串流。 | | %etl | String | 將工作階段類型變更為 AWS Glue ETL。 | | %glue\$1ray | String | 將工作階段類型變更為 AWS Glue for Ray。請參閱 [Ray AWS Glue 互動式工作階段支援的魔術](https://docs.aws.amazon.com/glue/latest/dg/is-using-ray-configuration)。 | **AWS Glue for Spark 組態魔術命令** `%%configure` 魔術命令是由工作階段的所有組態參數組成的 JSON 格式字典。可以在此處或透過個別魔術命令來指定每個參數。 | 名稱 | 類型 | 描述 | | --- | --- | --- | | %%configure | 字典 | 指定由工作階段的所有組態參數組成的 JSON 格式字典。可以在此處或透過個別魔術命令來指定每個參數。 如需參數清單以及如何使用 `%%configure` 的範例，請參閱[%%configure 儲存格魔術命令引數](#interactive-sessions-magics-configure-arguments)。 | | %iam\$1role | String | 指定用來執行工作階段的 IAM 角色 ARN。預設來自 \$1/.aws/configure。 範例：`%iam_role AWSGlueServiceRole` | | %number\$1of\$1workers | Int | 當任務執行時所分配的已定義 worker\$1type 的工作者數目。還必須設定 `worker_type`。預設的 `number_of_workers` 為 5。 範例：`%number_of_workers 2` | | %additional\$1python\$1modules | 清單 | 要包含在叢集中的以逗號分隔的其他 Python 模組清單 (可以來自 PyPI 或 S3)。 範例：`%additional_python_modules pandas, numpy`。 | | %%tags | String | 將標籤新增至工作階段。指定大括號 \$1\$1 內的標籤。每個標籤名稱配對均以括號 (" ") 括住，並以逗號 (,) 區隔。 
%%tags
{"billing":"Data-Platform", "team":"analytics"}
使用 `%status` 魔術命令來檢視與工作階段相關聯的標籤。 
%status
Session ID: 
 Status: READY
 Role: 
 CreatedOn: 2023-05-26 11:12:17.056000-07:00
 GlueVersion: 3.0
 Job Type: glueetl
 Tags: {'owner':'example-owner', 'team':'analytics', 'billing':'Data-Platform'}
 Worker Type: G.4X
 Number of Workers: 5
 Region: us-west-2
 Applying the following default arguments:
 --glue_kernel_version 0.38.0
 --enable-glue-datacatalog true
 Arguments Passed: ['--glue_kernel_version: 0.38.0', '--enable-glue-datacatalog: true']
| | %%assume\$1role | 字典 | 指定 JSON 格式的字典或 IAM 角色 ARN 字串，以建立可取得跨帳戶存取權的工作階段。 使用 ARN 的範例： 
%%assume_role
{
  'arn:aws:iam::XXXXXXXXXXXX:role/AWSGlueServiceRole'
}
使用憑證的範例： 
 %%assume_role
{{
    "aws_access_key_id" = "XXXXXXXXXXXX",
    "aws_secret_access_key" = "XXXXXXXXXXXX",
    "aws_session_token" = "XXXXXXXXXXXX"
}}
| ### %%configure 儲存格魔術命令引數 `%%configure` 魔術命令是由工作階段的所有組態參數組成的 JSON 格式字典。可以在此處或透過個別魔術命令來指定每個參數。如需 `%%configure` 儲存格魔術命令支援的引數範例，請參閱以下內容。將 `--` 字首用於為任務指定的執行引數。範例： ``` %%configure { "--user-jars-first": "true", "--enable-glue-datacatalog": "false" } ``` 如需任務參數的詳細資訊，請參閱[工作參數](aws-glue-programming-etl-glue-arguments.md)。 **工作階段組態** | 參數 | 類型 | 說明 | | --- | --- | --- | | max\$1retries | Int | 如果此任務失敗，可重試的次數上限。 
%%configure
{
  "max_retries": "0"
}
| | max\$1concurrent\$1runs | Int | 一項任務可同時執行的數量上限。範例： 
%%configure
{
  "max_concurrent_runs": "3"
}
| **工作階段參數** | 參數 | 類型 | 描述 | | --- | --- | --- | | --enable-spark-ui | 布林值 | 啟用 Spark UI 以監控和偵錯 AWS Glue ETL 任務。
%%configure
{
  "--enable-spark-ui": "true"
}
| | --spark-event-logs-path | String | 指定 Amazon S3 路徑。使用 Spark UI 監控功能時。範例： 
%%configure
{
  "--spark-event-logs-path": "s3://path/to/event/logs/"
}
| | --script\$1location | String | 指定執行任務的指令碼 S3 路徑。範例：
%%configure 
{
  "script_location": "s3://new-folder-here"
}
| | --SECURITY\$1CONFIGURATION | String | AWS Glue 安全組態的名稱 範例： 
%%configure
{
    "--security_configuration": {
"encryption_type": "kms",
"kms_key_id": "YOUR_KMS_KEY_ARN"
}
}
| | --job-language | String | 指令碼程式設計語言。接受 'scala' 或 'python' 的值。預設為 'python'。範例： 
%%configure 
{
  "--job-language": "scala"
}
| | --class | String | 可作為您的 Scala 指令碼進入點的 Scala 類別。預設為 Null。範例： 
%%configure 
{
  "--class": "className"
}
| | --user-jars-first | 布林值 | 在 classpath 中優先採用客戶的額外 JAR 檔案。預設為 Null。範例： 
%%configure 
{
  "--user-jars-first": "true"
}
| | --use-postgres-driver | 布林值 | 優先考慮類別路徑中的 Postgres JDBC 驅動程式，以避免與 Amazon Redshift JDBC 驅動程式衝突。預設為 Null。範例： 
%%configure 
{
  "--use-postgres-driver": "true"
}
| | --extra-files | List(string) | 組態檔案等其他檔案的 Amazon S3 路徑；在 AWS Glue 執行您的指令碼前，即會將其複製至指令碼的工作目錄。範例： 
%%configure 
{
  "--extra-files": "s3://path/to/additional/files/"
}
| | --job-bookmark-option | String | 控制任務書籤的行為。接受 'job-bookmark-enable'、'job-bookmark-disable' 或 'job-bookmark-pause' 的值。預設為 'job-bookmark-disable'。範例： 
%%configure
{
  "--job-bookmark-option": "job-bookmark-enable"
}
| | --TempDir | String | 指定儲存貯體的 Amazon S3 路徑做為任務的暫時目錄。預設為 Null。範例： 
%%configure 
{
  "--TempDir": "s3://path/to/temp/dir"
}
| | --enable-s3-parquet-optimized-committer | 布林值 | 啟用 EMRFS Amazon S3 最佳化遞交者，以將 Parquet 資料寫入 Amazon S3。預設為 'true'。範例： 
%%configure 
{
  "--enable-s3-parquet-optimized-committer": "false"
}
| | --enable-rename-algorithm-v2 | 布林值 | 將 EMRFS 重新命名演算法版本設定為第 2 版。預設為 'true'。範例： 
%%configure 
{
  "--enable-rename-algorithm-v2": "true"
}
| | --enable-glue-datacatalog | 布林值 | 可讓您使用 AWS Glue Data Catalog 作為 Apache Spark Hive 中繼存放區。範例： 
%%configure 
{
  "--enable-glue-datacatalog": "true"
}
| | --enable-metrics | 布林值 | 針對任務執行啟用任務分析的指標集合。預設為 'false'。範例： 
%%configure 
{
  "--enable-metrics": "true"
}
| | --enable-continuous-cloudwatch-log | 布林值 | 啟用即時、持續的 AWS Glue 任務記錄。預設為 'false'。範例： 
%%configure 
{
  "--enable-continuous-cloudwatch-log": "true"
}
| | --enable-continuous-log-filter | 布林值 | 當您建立或編輯已啟用持續記錄的任務時，指定標準篩選條件或無篩選條件。預設為 'true'。範例： 
%%configure 
{
  "--enable-continuous-log-filter": "true"
}
| | --continuous-log-stream-prefix | String | 為啟用持續記錄的任務指定自訂 Amazon CloudWatch 日誌串流字首。預設為 Null。範例： 
%%configure 
{
  "--continuous-log-stream-prefix": "prefix"
}
| | --continuous-log-conversionPattern | String | 為啟用連續記錄的任務指定自訂轉換日誌模式。預設為 Null。範例： 
%%configure 
{
  "--continuous-log-conversionPattern": "pattern"
}
| | --conf | String | 控制 Spark 組態參數。適用於進階使用案例。在每個參數之前使用 --conf。範例：
%%configure
{
    "--conf": "spark.hadoop.hive.metastore.glue.catalogid=123456789012 --conf hive.metastore.client.factory.class=com.amazonaws.glue.catalog.metastore.AWSGlueDataCatalogHiveClientFactory --conf hive.metastore.schema.verification=false"
}
| | timeout | Int | 確定 Spark 工作階段在終止陳述式之前，應等待陳述式完成的時間上限。
%%configure 
{
  "timeout": "30"
}
| | 自動擴展 | Boolean | 確定是否使用自動擴展。
%%configure 
{
  "––enable-auto-scaling": "true"
}
| ### Spark 任務 (ETL 與串流) 魔術命令 | 名稱 | 類型 | Description | | --- | --- | --- | | %worker\$1type | String | 也必須number\$1of\$1workers設定標準、G.1X、G.2X、G.4X、G.8X、G.12X、G.16X、R.1X、R.2X、R.4X 或 R.8X。預設 worker\$1type 是 G.1X。 | | %connections | List | 指定以逗號分隔的清單，其中列出要在工作階段中使用的連線。 範例： 
%connections my_rds_connection
                    dy_f = glue_context.create_dynamic_frame.from_catalog(database='rds_tables', table_name='sales_table')
| | %extra\$1py\$1files | 清單 | 列出來自 Amazon S3 的以逗號分隔的其他 Python 檔案清單。 | | %extra\$1jars | 清單 | 列出要包含在叢集中的以逗號分隔的其他 jar 清單。 | | %spark\$1conf | String | 為您的工作階段指定自訂 Spark 組態。例如 %spark\$1conf spark.serializer=org.apache.spark.serializer.KryoSerializer。 | ### 適用於 Ray 任務的魔術命令 | 名稱 | 類型 | 說明 | | --- | --- | --- | | %min\$1workers | Int | 分配給 Ray 任務的工作者數量下限。預設：1。 範例：`%min_workers 2` | | %object\$1memory\$1head | Int | 暖啟動後執行個體前端節點上可用記憶體的百分比。下限：0。上限：100。範例：`%object_memory_head 100` | | %object\$1memory\$1worker | Int | 暖啟動後執行個體工作節點上可用記憶體的百分比。下限：0。上限：100。範例：`%object_memory_worker 100` | ### Action magics (動作魔術命令) | 名稱 | 類型 | Description | | --- | --- | --- | | %%sql | String | 執行 SQL 程式碼。初始 `%%sql` 魔術命令之後的所有行都將作為 SQL 程式碼的一部分傳遞。 範例：`%%sql select * from rds_tables.sales_table` | | %matplot | Matplotlib 圖 | 使用 matplotlib 程式庫視覺化資料。 範例： 
import matplotlib.pyplot as plt

# Set X-axis and Y-axis values
x = [5, 2, 8, 4, 9]
y = [10, 4, 8, 5, 2]
  
# Create a bar chart 
plt.bar(x, y)
  
# Show the plot
%matplot plt
| | %plotly | Plotly 圖 | 使用 plotly 程式庫視覺化資料。 範例： 
import plotly.express as px
                  
#Create a graphical figure
fig = px.line(x=["a","b","c"], y=[1,3,2], title="sample figure")

#Show the figure
%plotly fig
| ## 命名工作階段 AWS Glue 互動式工作階段是 AWS 資源，需要名稱。每個工作階段的名稱應是唯一的，且可能受 IAM 管理員的限制。如需詳細資訊，請參閱[具備 IAM 的互動式工作階段](glue-is-security.md)。Jupyter 核心會為您自動產生唯一的工作階段名稱。但是，可以透過兩種方式手動命名工作階段： 1. 使用位於 AWS Command Line Interface 的組態檔案`~.aws/config`。請參閱[使用 AWS 設定組態 AWS Command Line Interface](https://docs.aws.amazon.com/config/latest/developerguide/gs-cli.html)。 1. 使用 `%session_id_prefix` 魔術命令。請參閱 [適用於 Jupyter 的 AWS Glue 互動式工作階段支援的魔術命令](#interactive-sessions-supported-magics)。 產生的工作階段名稱如下： + 當提供字首和 session\$1id 時：工作階段名稱將是 \$1prefix\$1-\$1UUID\$1。 + 如果未提供任何資料：工作階段名稱將是 \$1UUID\$1。 在 AWS CLI 或 主控台中列出工作階段時，字首工作階段名稱可讓您識別工作階段。 ## 指定互動式工作階段的 IAM 角色 您必須指定 AWS Identity and Access Management (IAM) 角色，以與您透過互動式工作階段執行的 AWS Glue ETL 程式碼搭配使用。 角色需要擁有執行 AWS Glue 任務所需的相同 IAM 許可。如需為 AWS Glue 任務和互動式工作階段建立角色的詳細資訊，請參閱《[為 AWS Glue 建立 IAM 角色](https://docs.aws.amazon.com/glue/latest/dg/create-an-iam-role.html)》。 IAM 角色可以使用兩種方式指定： + 使用位於 AWS Command Line Interface 的組態檔案 `~.aws/config`（建議）。如需詳細資訊，請參閱[使用 \$1/.aws/config 設定工作階段](https://docs.aws.amazon.com/glue/latest/ug/interactive-sessions-magics.html#interactive-sessions-named-profiles)。 **注意** 使用 `%profile` 魔術命令時，該設定檔的 `glue_iam_role` 組態會被接受。 + 使用 %iam\$1role 魔術命令。如需詳細資訊，請參閱[適用於 Jupyter 的 AWS Glue 互動式工作階段支援的魔術命令](#interactive-sessions-supported-magics)。 ## 使用命名設定檔設定工作階段 AWS Glue 互動式工作階段使用與 AWS Command Line Interface 或 boto3 相同的登入資料，而互動式工作階段遵守和使用具名設定檔，例如 AWS CLI `~/.aws/config`(Linux 和 MacOS) 或 `%USERPROFILE%\.aws\config`(Windows) 中找到的 。如需詳細資訊，請參閱[使用命名設定檔](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-using-profiles)。 互動式工作階段透過允許在設定檔中指定 AWS Glue 服務角色和工作階段 ID 字首，來利用命名設定檔。若要設定設定檔角色，請為 `iam_role` 金鑰和/或 `session_id_prefix ` 在命名設定檔中新增一行，如下所示。`session_id_prefix` 不需要引號。例如，若您想要新增 ` session_id_prefix`，請輸入 `session_id_prefix=myprefix` 的值。 ``` [default] region=us-east-1 aws_access_key_id=AKIAIOSFODNN7EXAMPLE aws_secret_access_key=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY glue_iam_role=arn:aws:iam:::role/ session_id_prefix= [user1] region=eu-west-1 aws_access_key_id=AKIAI44QH8DHBEXAMPLE aws_secret_access_key=je7MtGbClwBF/2Zp9Utk/h3yCo8nvbEXAMPLEKEY glue_iam_role=arn:aws:iam:::role/ session_id_prefix= ``` 如果您有產生憑證的自訂方法，您也可以在 `~/.aws/config` 檔案中將設定檔設定為使用 `credential_process` 參數。例如： ``` [profile developer] region=us-east-1 credential_process = "/Users/Dave/generate_my_credentials.sh" --username helen ``` 您可以透過此處的 `credential_process` 參數找到有關取得憑證的詳細資訊：[透過外部程序取得憑證](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sourcing-external.html)。 如果區域或 `iam_role` 未在您使用的設定檔中設定，則您必須在執行的第一個儲存格中使用 `%region` 和 `%iam_role` 魔術命令來指定它們。 # 將指令碼或筆記本轉換為 AWS Glue 任務 有兩種方式可將指令碼或筆記本轉換為 AWS Glue 任務： + 使用 **nbconvert** 將您的 Jupyter `.ipynb` 筆記本文件檔案轉換為 `.py` 檔案。如需詳細資訊，請參閱 [nbconvert：將筆記本轉換為其他格式](https://nbconvert.readthedocs.io/en/latest/)。 + 將檔案上傳到 AWS Glue Studio 筆記本。 + 在 AWS Glue Studio 主控台中，從導覽選單中選擇 **Jobs** (任務)。 + 在 **Create job** (建立任務) 區段中，選擇 **Jupyter Notebook** (Jupyter 筆記本)。 + 在 **Options** (選項) 區段中，選擇 **Upload and edit an existing notebook** (上傳並編輯現有的筆記本)。 + 選取 **Choose file** (選擇檔案) 以上傳 `.ipynb` 檔案。 # 在 AWS Glue 互動式工作階段中使用串流操作 ## 切換串流工作階段類型 使用 AWS Glue 互動式工作階段組態魔術命令 `%streaming`，定義您正在執行的任務並初始化串流互動式工作階段。 ## 為互動式開發抽樣輸入串流 為幫助增強 AWS Glue 互動式工作階段中的互動式體驗，我們開發出的一個工具是在 `GlueContext` 下新增了一種新方法，該方法用於獲取靜態 DynamicFrame 中的串流快照。`GlueContext` 讓您能夠檢查、互動並實作您的工作流程。 使用 `GlueContext` 類執行個體，您將能夠找到方法 `getSampleStreamingDynamicFrame`。此方法所需的引數為： + `dataFrame`：Spark Streaming DataFrame + `options`：請參閱下列可用的選項 可用選項包括： + **windowSize**：這也稱為微量批持續時間。此參數將判定觸發前一個批次後串流查詢將等待的時長。此參數值必須小於 `pollingTimeInMs`。 + **pollingTimeInMs**：方法將執行的總時長。它將至少觸發一個微批次，以從輸入串流中獲取樣本記錄。 + **recordPollingLimit**：此參數可幫助您限制將從串流輪詢的記錄總數。 + (選用) 您也可以使用 `writeStreamFunction` 將此自訂函數應用至每個記錄抽樣函數。請參閱下列 Scala 和 Python 中的範例。 **** ``` val sampleBatchFunction = (batchDF: DataFrame, batchId: Long) => {//Optional but you can replace your own forEachBatch function here} val jsonString: String = s"""{"pollingTimeInMs": "10000", "windowSize": "5 seconds"}""" val dynFrame = glueContext.getSampleStreamingDynamicFrame(YOUR_STREAMING_DF, JsonOptions(jsonString), sampleBatchFunction) dynFrame.show() ``` ``` def sample_batch_function(batch_df, batch_id): //Optional but you can replace your own forEachBatch function here options = { "pollingTimeInMs": "10000", "windowSize": "5 seconds", } glue_context.getSampleStreamingDynamicFrame(YOUR_STREAMING_DF, options, sample_batch_function) ``` **注意** 當抽樣 `DynFrame` 為空白時，它可能是由以下幾個原因造成的： 串流來源設定為「最新」，而且在抽樣週期期間沒有擷取任何新資料。 輪詢時間不足，無法處理它擷取的記錄。除非整個批次處理完畢，否則資料不會顯示。 ## 在互動式工作階段中執行串流應用程式 在 AWS Glue 互動式工作階段中，您可以執行 AWS Glue 串流應用程式，就像您在 AWS Glue 主控台中建立串流應用程式一樣。由於互動式工作階段是以工作階段為基礎，因此在執行時間遇到異常情形不會導致工作階段停止。反覆開發批次函數現在帶來了額外好處。例如： ``` def batch_function(data_frame, batch_id): log.info(data_frame.count()) invalid_method_call() glueContext.forEachBatch(frame=streaming_df, batch_function = batch_function, options = {**}) ``` 上面的範例中包含了對方法的無效使用，與將退出整個應用程式的常規 AWS Glue 任務不同的是，使用者的編碼內容和定義得到完全保留，且工作階段仍然可運作。無需引導新叢集並重新執行之前的所有轉換。這樣，您就可以專注於快速逐一查看批次函數實作，以獲得理想的結果。 需要注意的是，互動式工作階段會以封鎖的方式評估每個陳述句，以便讓工作階段一次只執行一個陳述句。由於串流查詢是連續的並且永不結束，因此具有作用中串流查詢的工作階段將無法處理任何後續陳述句，除非它們被中斷。您可以直接從 Jupyter 筆記本發出中斷命令，我們的核心會為您處理取消操作。 以下列正在等待執行的陳述句序列為範例： ``` Statement 1: val number = df.count() #Spark Action with deterministic result Result: 5 Statement 2: streamingQuery.start().awaitTermination() #Spark Streaming Query that will be executing continously Result: Constantly updated with each microbatch Statement 3: val number2 = df.count() #This will not be executed as previous statement will be running indefinitely ``` # AWS Glue 互動式工作階段定價 AWS 根據工作階段作用中的時間長度和使用的資料處理單位 (DPU) 數量，收取 AWS Glue 互動式工作階段的費用。用於執行工作負載的 DPUs 數目會按小時計費，以一秒為單位遞增計費。 AWS Glue 互動式工作階段會指派預設值為 5 DPUs，且至少需要 2 DPUs。每個互動式工作階段也有 1 分鐘的計費持續時間下限。若要查看 AWS Glue 費率和定價範例，或使用 AWS 定價計算器估算成本，請參閱[AWS Glue 定價](https://aws.amazon.com/glue/pricing/)。 ## 設定 AWS Glue 互動式工作階段 您可以在 AWS 互動式工作階段中使用 Jupyter 魔法來修改工作階段和組態參數。魔術命令是 Jupyter 儲存格開頭字首為 `%` 的簡短命令，它提供了快速簡便的方法幫助您控制環境。例如，如果要將分配至任務的工作者數目從預設值 5 變更為 10，您可以指定 `%number_of_workers 10`。如果您要將工作階段設定為在閒置時間 10 分鐘後停止，而不是預設的 2880，您可以指定 `%idle_timeout 10`。 如需可用的 AWS 魔術功能完整清單，請參閱[設定 Jupyter 和 AWS Glue Studio 筆記本的 AWS 互動式工作階段](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-magics.html)。 # 在本機開發和測試 AWS Glue 任務指令碼 當您開發和測試 AWS Glue for Spark 任務指令碼時，有多個可用選項： + AWS Glue Studio 主控台 + Visual editor (視覺化編輯器) + 指令碼編輯器 + AWS Glue Studio 筆記本 + 互動式工作階段 + Jupyter 筆記本 + Docker 映像檔 + 本機開發 + 遠端開發 您可根據自己的需求選擇上述任何選項。 如果您不偏好程式碼或更少的程式碼體驗，則 Glue Studio AWS 視覺化編輯器是不錯的選擇。 如果您偏好互動式筆記本體驗， AWS Glue Studio 筆記本是不錯的選擇。如需詳細資訊，請參閱[搭配使用筆記本與 AWS Glue Studio 和 AWS Glue](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html)。如果想要使用自己的本機環境，那麼互動式工作階段是個不錯的選擇。如需詳細資訊，請參閱[搭配 Glue AWS 使用互動式工作階段](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-chapter.html)。 如果您偏好採用本機/遠端開發，那麼 Docker 映像檔是個不錯的選擇。這可協助您在偏好的任何地方開發和測試 AWS Glue for Spark 任務指令碼，而不會產生 AWS Glue 成本。 如果您偏好不使用 Docker 進行本機開發，在本機安裝 AWS Glue ETL 程式庫目錄是不錯的選擇。 ## 使用 Glue Studio AWS 進行開發 Glue Studio 視覺化編輯器是一種圖形界面，可讓您輕鬆地在 AWS Glue 中建立、執行和監控擷取、轉換和載入 (ETL) AWS 任務。您可以視覺化地編寫資料轉換工作流程，並在 AWS Glue 的 Apache Spark 型無伺服器 ETL 引擎上順暢地執行它們。您可以在任務的每個步驟中檢查結構描述和資料結果。如需詳細資訊，請參閱 [AWS Glue Studio 使用者指南](https://docs.aws.amazon.com/glue/latest/ug/what-is-glue-studio.html)。 ## 使用互動式工作階段進行開發 使用互動式工作階段允許您自行選擇要建置和測試應用程式的環境。如需詳細資訊，請參閱[搭配 Glue AWS 使用互動式工作階段](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-chapter.html)。 # 使用 Docker 映像在本機開發和測試 AWS Glue 任務 對於生產就緒的資料平台，開發程序和 AWS Glue 任務的 CI/CD 管道是關鍵主題。您可以在 Docker 容器中彈性開發和測試 AWS Glue 任務。在 Docker Hub 上 AWS Glue 託管 Docker 映像，以使用其他公用程式設定您的開發環境。您可以使用 ETL 程式庫來使用您偏好的 AWS Glue IDE、筆記本或 REPL。本主題說明如何使用 Docker 映像在 Docker 容器中開發和測試 5.0 AWS Glue 版任務。 ## 可用的 Docker 映像檔 下列 Docker 映像可在 Amazon ECR AWS Glue 上使用： [https://gallery.ecr.aws/glue/aws-glue-libs](https://gallery.ecr.aws/glue/aws-glue-libs) + 對於 5.0 AWS Glue 版： `public.ecr.aws/glue/aws-glue-libs:5` + 對於 4.0 AWS Glue 版： `public.ecr.aws/glue/aws-glue-libs:glue_libs_4.0.0_image_01` + 對於 3.0 AWS Glue 版： `public.ecr.aws/glue/aws-glue-libs:glue_libs_3.0.0_image_01` + 對於 2.0 AWS Glue 版： `public.ecr.aws/glue/aws-glue-libs:glue_libs_2.0.0_image_01` **注意** AWS Glue Docker 映像與 x86\$164 和 arm64 相容。 在此範例中，我們使用 `public.ecr.aws/glue/aws-glue-libs:5` 並在本機電腦 (Mac、Windows 或 Linux) 上執行容器。此容器映像已針對 5.0 AWS Glue 版 Spark 任務進行測試。該映像檔包含下列項目： + Amazon Linux 2023 + AWS Glue ETL 程式庫 + Apache Spark 3.5.4 + 開放式資料表格式程式庫；Apache Iceberg 1.7.1、Apache Hudi 0.15.0 和 Delta Lake 3.3.0 + AWS Glue Data Catalog 用戶端 + Amazon Redshift Apache Spark 連接器 + Amazon DynamoDB Apache Hadoop 連接器 若要設定容器，請從 ECR 公共映像庫提取映像，然後執行容器。本主題示範如何使用下列方法執行您的容器，視您的需求而定： + `spark-submit` + REPL Shell `(pyspark)` + `pytest` + Visual Studio 程式碼 ## 先決條件 在開始之前，請務必安裝 Docker 並確保 Docker 常駐程式正在執行。如需安裝說明，請參閱 [Mac](https://docs.docker.com/docker-for-mac/install/) 或 [Linux](https://docs.docker.com/engine/install/) 專用的 Docker 文件。執行 Docker 的機器託管 AWS Glue 容器。亦請確保執行 Docker 的主機上至少有 7 GB 的磁碟空間可供映像檔使用。 如需在本機開發 AWS Glue 程式碼時限制的詳細資訊，請參閱[本機開發限制。 ](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-libraries.html#local-dev-restrictions) ### 設定 AWS 若要從容器啟用 AWS API 呼叫，請依照下列步驟設定 AWS 登入資料。在下列各節中，我們將使用此 AWS 具名設定檔。 1. [ 建立 AWS 具名設定檔 ](https://docs.aws.amazon.com//cli/latest/userguide/cli-configure-files.html)。 1. 開啟 Windows 上的 `cmd` 或 Mac/Linux 上的終端，並在終端執行下列命令： ``` PROFILE_NAME="" ``` 在下列各節中，我們會使用此 AWS 具名設定檔。 ### 如果在 Windows 上執行 Docker，請選擇 Docker 圖示 (按一下滑鼠右鍵)，並選擇**切換至 Linux 容器...**，然後再提取映像檔。 執行以下命令可從 ECR Public 中提取映像檔： ``` docker pull public.ecr.aws/glue/aws-glue-libs:5 ``` ## 執行容器 然後再使用此映像檔執行容器。您可根據自己的需求選擇下列任何選項。 ### spark-submit 您可以在容器上執行 `spark-submit`命令，以執行 AWS Glue 任務指令碼。 1. 撰寫指令碼並將其儲存為下面範例中的 `sample.py`，然後使用下列命令將其儲存在 `/local_path_to_workspace/src/` 型錄下： ``` $ WORKSPACE_LOCATION=/local_path_to_workspace $ SCRIPT_FILE_NAME=sample.py $ mkdir -p ${WORKSPACE_LOCATION}/src $ vim ${WORKSPACE_LOCATION}/src/${SCRIPT_FILE_NAME} ``` 1. 這些變數用於下面的 docker run 命令。下面 spark-submit 命令中使用的範例程式碼 (sample.py) 包含在本主題結尾的附錄中。 執行下列命令可在容器上執行 `spark-submit` 命令以提交新的 Spark 應用程式： ``` $ docker run -it --rm \ -v ~/.aws:/home /hadoop/.aws \ -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ \ -e AWS_PROFILE=$PROFILE_NAME \ --name glue5_spark_submit \ public.ecr.aws/glue/aws-glue-libs:5 \ spark-submit /home/hadoop/workspace/src/$SCRIPT_FILE_NAME ``` 1. (選用) 設定 `spark-submit` 以符合您的環境。例如，可以將相依項與 `--jars` 組態一起傳遞。如需詳細資訊，請參閱 Spark 文件中的[動態載入 Spark 屬性](https://spark.apache.org/docs/latest/configuration.html)。 ### REPL Shell (Pyspark) 您可以執行 REPL (`read-eval-print loops`) Shell 進行互動式開發。執行以下命令可在容器上執行 PySpark 命令以啟動 REPL Shell： ``` $ docker run -it --rm \ -v ~/.aws:/home/hadoop/.aws \ -e AWS_PROFILE=$PROFILE_NAME \ --name glue5_pyspark \ public.ecr.aws/glue/aws-glue-libs:5 \ pyspark ``` 您將會看到下列輸出： ``` Python 3.11.6 (main, Jan 9 2025, 00:00:00) [GCC 11.4.1 20230605 (Red Hat 11.4.1-2)] on linux Type "help", "copyright", "credits" or "license" for more information. Setting default log level to "WARN". To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel). Welcome to ____ __ / __/__ ___ _____/ /__ _\ \/ _ \/ _ `/ __/ '_/ /__ / .__/\_,_/_/ /_/\_\ version 3.5.4-amzn-0 /_/ Using Python version 3.11.6 (main, Jan 9 2025 00:00:00) Spark context Web UI available at None Spark context available as 'sc' (master = local[*], app id = local-1740643079929). SparkSession available as 'spark'. >>> ``` 使用此 REPL Shell，您能以互動方式編寫程式碼和進行測試。 ### Pytest 對於單元測試，您可以將 `pytest` 用於 AWS Glue Spark 任務指令碼。執行下列命令以完成前置作業。 ``` $ WORKSPACE_LOCATION=/local_path_to_workspace $ SCRIPT_FILE_NAME=sample.py $ UNIT_TEST_FILE_NAME=test_sample.py $ mkdir -p ${WORKSPACE_LOCATION}/tests $ vim ${WORKSPACE_LOCATION}/tests/${UNIT_TEST_FILE_NAME} ``` 執行下列命令，以使用 `docker run` 執行 `pytest`： ``` $ docker run -i --rm \ -v ~/.aws:/home/hadoop/.aws \ -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ \ --workdir /home/hadoop/workspace \ -e AWS_PROFILE=$PROFILE_NAME \ --name glue5_pytest \ public.ecr.aws/glue/aws-glue-libs:5 \ -c "python3 -m pytest --disable-warnings" ``` 在 `pytest` 完成執行單元測試後，您的輸出將如下所示： ``` ============================= test session starts ============================== platform linux -- Python 3.11.6, pytest-8.3.4, pluggy-1.5.0 rootdir: /home/hadoop/workspace plugins: integration-mark-0.2.0 collected 1 item tests/test_sample.py . [100%] ======================== 1 passed, 1 warning in 34.28s ========================= ``` ### 將容器設為使用 Visual Studio Code 若要使用 Visual Studio Code 設定容器，請完成下列步驟： 1. 安裝 Visual Studio Code。 1. 安裝 [Python](https://marketplace.visualstudio.com/items?itemName=ms-python.python)。 1. 安裝 [Visual Studio Code Remote - Containers](https://code.visualstudio.com/docs/remote/containers) 1. 在 Visual Studio Code 中開啟 workspace (工作區) 資料夾。 1. 按 `Ctrl+Shift+P` (Windows/Linux) 或 `Cmd+Shift+P` (Mac)。 1. 輸入 `Preferences: Open Workspace Settings (JSON)`。 1. 按 Enter。 1. 將下列 JSON 貼上並儲存。 ``` { "python.defaultInterpreterPath": "/usr/bin/python3.11", "python.analysis.extraPaths": [ "/usr/lib/spark/python/lib/py4j-0.10.9.7-src.zip:/usr/lib/spark/python/:/usr/lib/spark/python/lib/", ] } ``` 若要設定容器，請執行以下操作： 1. 執行 Docker 容器。 ``` $ docker run -it --rm \ -v ~/.aws:/home/hadoop/.aws \ -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ \ -e AWS_PROFILE=$PROFILE_NAME \ --name glue5_pyspark \ public.ecr.aws/glue/aws-glue-libs:5 \ pyspark ``` 1. 啟動 Visual Studio Code。 1. 選擇左側選單中的 **Remote Explorer** (遠端檔案總管)，然後選擇 `amazon/aws-glue-libs:glue_libs_4.0.0_image_01`。 1. 按一下滑鼠右鍵，然後選擇**在目前視窗中連接**。 ![\[按滑鼠右鍵時，會出現一個視窗，其中包含「在目前視窗中連接」選項。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/vs-code-other-containers.png) 1. 如果出現下列對話方塊，請選擇**了解**。 ![\[視窗警告，其中包含「連接至容器可能會執行任意程式碼」訊息。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/vs-code-warning-got-it.png) 1. 打開 `/home/handoop/workspace/`。 ![\[含有「工作區」選項的視窗下拉式清單會反白顯示。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/vs-code-open-workspace.png) 1. 建立 a AWS Glue PySpark 指令碼，然後選擇**執行**。 您會看到指令碼成功執行。 ![\[指令碼成功執行。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/vs-code-run-successful-script.png) ## AWS Glue 4.0 和 AWS Glue 5.0 Docker 映像檔之間的變更 AWS Glue 4.0 和 AWS Glue 5.0 Docker 映像檔之間的主要變更： + 在 AWS Glue 5.0 中，批次和串流任務都有單一容器映像。這與 Glue 4.0 不同，其中有一個映像用於批次，另一個用於串流。 + 在 AWS Glue 5.0 中，容器的預設使用者名稱為 `hadoop`。在 AWS Glue 4.0 中，預設使用者名稱為 `glue_user`。 + 在 AWS Glue 5.0 中，已從映像中移除數個額外的程式庫，包括 JupyterLab 和 Livy。您可以手動進行安裝。 + 在 AWS Glue 5.0 中，預設會預先載入所有 Iceberg、Hudi 和 Delta 程式庫，且`DATALAKE_FORMATS`不再需要環境變數。在 AWS Glue 4.0 之前，環境變數`DATALAKE_FORMATS`環境變數用於指定應載入哪些特定資料表格式。 上述清單特定於 Docker 映像檔案。若要進一步了解 AWS Glue 5.0 更新，請參閱適用於 [Apache Spark 的 Introducing AWS Glue 5.0 ](https://aws.amazon.com/blogs/big-data/introducing-aws-glue-5-0-for-apache-spark/) 和[AWS Glue 適用於 Spark 任務的遷移至 5.0 AWS Glue 版。](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-50.html) ## 考量事項 請注意，使用 AWS Glue 容器映像在本機開發任務指令碼時，不支援下列功能。 + [任務書籤](https://docs.aws.amazon.com/glue/latest/dg/monitor-continuations.html) + AWS Glue Parquet 寫入器 ([在 中使用 Parquet 格式 AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-parquet-home.html)) + [FillMissingValues 轉換](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-crawler-pyspark-transforms-fillmissingvalues.html) + [FindMatches 轉換](https://docs.aws.amazon.com/glue/latest/dg/machine-learning.html#find-matches-transform) + [向量化 SIMD CSV 讀取器](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-format-csv-home.html#aws-glue-programming-etl-format-simd-csv-reader) + 屬性 [customJdbcDriverS3Path](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-connect.html#aws-glue-programming-etl-connect-jdbc)，用於從 Amazon S3 路徑載入 JDBC 驅動器 + [AWS Glue 資料品質](https://docs.aws.amazon.com/glue/latest/dg/glue-data-quality.html) + [敏感資料偵測](https://docs.aws.amazon.com/glue/latest/dg/detect-PII.html) + AWS Lake Formation 以許可為基礎的登入資料販賣 ## 附錄：新增 JDBC 驅動器和 Java 程式庫 若要新增目前容器中無法使用的 JDBC 驅動器，您可以使用所需的 JAR 檔案在工作區下建立新的型錄，並在 docker run 命令中將型錄掛載至 `/opt/spark/jars/`。位於容器內 `/opt/spark/jars/` 下的 JAR 檔案會自動新增至 Spark Classpath，並在任務執行期間可供使用。 例如，使用下列 docker run 命令，將 JDBC 驅動器 jar 新增至 PySpark REPL Shell。 ``` docker run -it --rm \ -v ~/.aws:/home/hadoop/.aws \ -v $WORKSPACE_LOCATION:/home/hadoop/workspace/ \ -v $WORKSPACE_LOCATION/jars/:/opt/spark/jars/ \ --workdir /home/hadoop/workspace \ -e AWS_PROFILE=$PROFILE_NAME \ --name glue5_jdbc \ public.ecr.aws/glue/aws-glue-libs:5 \ pyspark ``` 如**考量**中反白顯示，`customJdbcDriverS3Path`連線選項無法用於從 AWS Glue 容器映像中的 Amazon S3 匯入自訂 JDBC 驅動程式。 # 開發端點 **注意** **自 2023 年 3 月 31 日起，已經移除開發端點的主控台體驗。**您仍可透過 [開發端點 API](aws-glue-api-dev-endpoint.md) 和 [ AWS Glue CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/index.html#cli-aws-glue) 建立、更新和監控開發端點。 基於下列原因，我們強烈建議您從開發端點移轉到互動式工作階段。如需如何從開發端點移轉到互動式工作階段的所需動作，請參閱[從開發端點移轉至互動式工作階段](https://docs.aws.amazon.com/glue/latest/dg/development-migration-checklist.html)。 | Description | 開發端點 | 互動式工作階段 | | --- | --- | --- | | Glue 版本支援 | 支援 AWS Glue 0.9 版和 1.0 版 | 支援 AWS Glue 2.0 版和更高版本 | | 開發端點在亞太區域 (雅加達) (ap-southeast-3)、中東 (阿拉伯聯合大公國) (me-central-1)、歐洲 (西班牙) (eu-south-2)、歐洲 (蘇黎世) (eu-central-2) 或今後推出服務的其他新區域中不可使用 | 互動式工作階段目前在中東 (阿拉伯聯合大公國) (me-central-1) 區域未提供使用，但稍後會提供。 | | Spark 叢集的存取方法 | 支援 SSH、REPL Shell、Jupyter 筆記本、IDE (如 PyCharm) | 支援 AWS Glue Studio 筆記本、Jupyter 筆記本、各種 IDE (例如 Visual Studio Code、PyCharm) 和 SageMaker AI 筆記本 | | 至第一次查詢的時間 | Spark 叢集需要 10-15 分鐘的設定時間 | 暫時性 Spark 叢集最長需要 1 分鐘的設定時間 | | 價格模型 | AWS 會根據佈建端點的時間和 DPUs。開發端點不會逾時。每個佈建的開發端點有 10 分鐘的最短計費持續時間。此外，當您使用 dev 端點設定 Jupyter 筆記本時， 會針對 Amazon EC2 執行個體和 SageMaker AI 筆記本 AWS 收取費用。 | AWS 會根據工作階段處於作用中狀態的時間和 DPUs 數量收取互動式工作階段的費用。 互動式工作階段具有可設定的閒置逾時。 AWS Glue Studio筆記本提供互動式工作階段的內建界面，並且免費提供。每個互動工作階段都有 1 分鐘的最短計費持續時間。AWS Glue Studio 筆記本提供互動式工作階段的內建介面，且不收取其他費用。 | | 主控台體驗 | 僅透過 CLI 和 API 提供 | 透過 AWS Glue 主控台、CLI 和 API 提供 | # 從開發端點移轉至互動式工作階段 使用下列檢查清單決定要從開發端點移轉至互動式工作階段的合適方法。 **您的指令碼是否仰賴 AWS Glue 0.9 或 1.0 的特定功能 (例如 HDFS、YARN)？** 如果答案為是，請參閱[將 AWS Glue 任務移轉至 AWS Glue 3.0 版](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html)，了解如何從 Glue 0.9 或 1.0 移轉至 Glue 3.0 及更高版本。 **您使用哪種方法存取自己的開發端點？** | 如果使用此方法 | 則執行此操作 | | --- | --- | | SageMaker AI 筆記本、Jupyter 筆記本或 JupyterLab | 在 Jupyter 上下載 .ipynb 檔案以移轉到 [AWS Glue Studio 筆記本](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-gs-notebook.html)，然後上傳 .ipynb 檔案以建立新的 AWS Glue Studio 筆記本任務。或者，您也可以使用 [ SageMaker AI Studio](https://aws.amazon.com/blogs/machine-learning/prepare-data-at-scale-in-amazon-sagemaker-studio-using-serverless-aws-glue-interactive-sessions/) 並選擇 AWS Glue 內核。 | | Zeppelin 筆記本 | 透過複製並貼上程式碼手動將筆記本轉換成 Jupyter 筆記本，或使用第三方轉換器 (如 ze2nb) 自動轉換。然後，在 AWS Glue Studio 筆記本或 SageMaker AI Studio 中使用筆記本。 | | IDE | 請參閱[使用 AWS Glue 互動式工作階段搭配 PyCharm 撰寫 AWS Glue 任務](https://aws.amazon.com/blogs/big-data/author-aws-glue-jobs-with-pycharm-using-aws-glue-interactive-sessions/)，或[將互動式工作階段與 Microsoft Visual Studio Code 搭配使用](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-vscode.html)。 | | REPL | 在本機安裝 [https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html)，然後請執行下列命令： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/development-migration-checklist.html) | | SSH | 互動式工作階段中沒有對應的選項。或者，您可以使用 Docker 映像檔。如需進一步了解，請參閱[使用 Docker 映像檔進行開發](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-libraries.html#develop-local-docker-image)。 | 以下章節將提供在 AWS Glue 1.0 版使用開發端點來開發任務的資訊。 **Topics** + [從開發端點移轉至互動式工作階段](development-migration-checklist.md) + [使用開發端點來開發指令碼](dev-endpoint.md) + [管理筆記本](notebooks-with-glue.md) # 使用開發端點來開發指令碼 **注意** 開發端點僅支援 2.0 AWS Glue 之前的 版本。對於您可以在其中撰寫和測試 ETL 指令碼的互動式環境，請在 [AWS Glue Studio 上使用筆記本](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html)。 AWS Glue 可以建立環境 (稱為*開發端點*)，以反覆開發和測試您的擷取、轉換和載入 (ETL) 指令碼。您可以使用 AWS Glue 主控台或 API 建立、編輯和刪除開發端點。 ## 管理您的開發環境 當您建立開發端點時，必須提供組態值來佈建開發環境。這些值會告訴 AWS Glue 如何設定網路，讓您安全地存取您的端點，同時讓端點可以存取您的資料存放區。 然後，建立連接到端點的筆記本，並使用您的筆記本編寫和測試您的 ETL 指令碼。當您對於開發程序的結果感到滿意時，可建立 ETL 任務以執行您的指令碼。透過此程序，您可以用互動的方式新增函數和偵錯您的指令碼。 遵循本節中的教學課程，了解如何透過筆記本使用您的開發端點。 **Topics** + [管理您的開發環境](#dev-endpoint-managing-dev-environment) + [開發端點工作流程](dev-endpoint-workflow.md) + [AWS Glue 開發端點如何搭配 SageMaker 筆記本使用](dev-endpoint-how-it-works.md) + [新增開發端點](add-dev-endpoint.md) + [存取您的開發端點](dev-endpoint-elastic-ip.md) + [教學課程：在 JupyterLab 中設定 Jupyter 筆記本以測試和偵錯 ETL 指令碼](dev-endpoint-tutorial-local-jupyter.md) + [教學課程：將 SageMaker AI 筆記本與開發端點搭配使用](dev-endpoint-tutorial-sage.md) + [教學課程：使用 REPL shell 搭配開發端點](dev-endpoint-tutorial-repl.md) + [教學課程：設定 PyCharm professional 與開發端點](dev-endpoint-tutorial-pycharm.md) + [進階組態：在多個使用者之間共用開發端點](dev-endpoint-sharing.md) # 開發端點工作流程 若要使用 AWS Glue 開發端點，您可以遵循此工作流程： 1. 使用 API 建立開發端點。此端點將在虛擬私有雲端 (VPC) 中啟動，並包含您定義的安全群組。 1. API 會輪詢開發端點，直到其佈建完成且可供使用。準備就緒時，請使用下列其中一個方法連接到開發端點，以建立和測試 AWS Glue 指令碼。 + 在您的帳戶中建立 SageMaker AI 筆記本。如需如何建立筆記本的詳細資訊，請參閱[使用 AWS Glue Studio 筆記本編寫程式碼](notebooks-chapter.md)。 + 開啟終端機視窗直接連接到開發端點。 + 如果您有專業版的 JetBrains [PyCharm Python IDE](https://www.jetbrains.com/pycharm/)，請將它連接到開發端點，並以互動方式將其用於開發作業。如果您將 `pydevd` 陳述式插入您的指令碼，PyCharm 就能支援遠端中斷點。 1. 當您完成偵錯和測試您的開發端點，您就可以將它刪除。 # AWS Glue 開發端點如何搭配 SageMaker 筆記本使用 存取開發端點的常見方法之一是在 SageMaker 筆記本上使用 [Jupyter](https://jupyter.org/)。Jupyter 筆記本是一個開源 Web 應用程式，廣泛用於視覺化、分析、機器學習等。AWS Glue SageMaker 筆記本為您提供了一個搭配 AWS Glue 開發端點的 Jupyter 筆記本體驗。在 AWS Glue SageMaker 筆記本中，Jupyter 筆記本環境預先設定了 [SparkMagic](https://github.com/jupyter-incubator/sparkmagic)，這是一個開源的 Jupyter 外掛程式，可將 Spark 任務提交到遠端 Spark 叢集。[Apache Livy](https://livy.apache.org) 是一種允許透過 REST API 與遠端 Spark 叢集進行互動的服務。在 AWS Glue SageMaker 筆記本中，SparkMagic 被設定為針對在 AWS Glue 開發端點執行的 Livy 伺服器呼叫 REST API。 下列文字流排說明每個元件的運作方式： *AWS Glue SageMaker 筆記本：(Jupyter → SparkMagic) → (網路) → AWS Glue 開發端點：(Apache Livy → Apache Spark)* 一旦您在 Jupyter 筆記本上執行在每個段落中編寫的 Spark 指令碼，Spark 程式碼就會透過 SparkMagic 提交到 Livy 伺服器，然後一個名為 "livy-session-N" 的 Spark 任務會在 Spark 叢集上執行。這個任務叫做 Livy 工作階段。Spark 任務將在筆記本工作階段處於活動狀態時執行。當您從筆記本關閉 Jupyter 核心或工作階段逾時時，Spark 任務將會終止。每個筆記本 (.ipynb) 檔案啟動一個 Spark 任務。 您可以使用單一 AWS Glue 開發端點來搭配多個 SageMaker 筆記本執行個體。您可以在每個 SageMaker 筆記本執行個體中建立多個筆記本檔案。當您開啟每個筆記本檔案並執行段落時，會透過 SparkMagic 在 Spark 叢集上每個筆記本檔案的 Livy 工作階段啟動。每個 Livy 工作階段對應於單個 Spark 任務。 ## AWS Glue 開發端點和 SageMaker 筆記本的預設行為 Spark 任務是根據 [Spark 設定](https://spark.apache.org/docs/2.4.3/configuration.html)執行。有多種方法可以設定 Spark 組態 (例如 Spark 叢集組態、SparkMagic 的組態等)。 依預設，Spark 根據 Spark 叢集組態配置叢集資源給 Livy 工作階段。在 AWS Glue 開發端點中，叢集組態取決於工作者類型。下面是一個資料表，它解釋了每個工作者類型的常見組態。 **** | | 標準 | G.1X | G.2X | | --- | --- | --- | --- | | spark.driver.memory | 5G | 10G | 20G | | spark.executor.memory | 5G | 10G | 20G | | spark.executor.cores | 4 | 8 | 16 | | spark.dynamicAllocation.enabled | TRUE | TRUE | TRUE | Spark 執行器的最大數量由 DPU (或 `NumberOfWorkers`) 和工作者類型自動計算。 **** | | 標準 | G.1X | G.2X | | --- | --- | --- | --- | | 最大 Spark 執行器數量 | (DPU - 1) \$1 2 - 1 | (NumberOfWorkers - 1) | (NumberOfWorkers - 1) | 例如，如果您的開發端點有 10 個工作者，並且工作者類型為 ` G.1X`，那麼您將有 9 個 Spark 執行器，並且整個叢集將有 90G 的執行器記憶體，因為每個執行器都有 10G 的記憶體。 無論指定的工作者類型為何，Spark 動態資源配置都會開啟。如果資料集足夠大，Spark 可以將所有執行器配置給單個 Livy 工作階段，因為預設未設定 `spark.dynamicAllocation.maxExecutors`。這代表同一個開發端點上的其他 Livy 工作階段將等待啟動新的執行器。如果資料集很小，Spark 將能夠同時將執行器配置給多個 Livy 工作階段。 **注意** 如需有關如何在不同的使用案例中配置資源，以及如何設定組態來修改行為的詳細資訊，請參閱 [進階組態：在多個使用者之間共用開發端點](dev-endpoint-sharing.md)。 # 新增開發端點 使用開發端點在 AWS Glue 中反覆開發和測試您的擷取、轉換和載入 (ETL) 指令碼。只能透過 AWS Command Line Interface使用開發端點。 1. 在命令列視窗中，輸入類似如下的命令。 ``` aws glue create-dev-endpoint --endpoint-name "endpoint1" --role-arn "arn:aws:iam::account-id:role/role-name" --number-of-nodes "3" --glue-version "1.0" --arguments '{"GLUE_PYTHON_VERSION": "3"}' --region "region-name" ``` 此命令指定 AWS Glue 1.0 版。由於此版本同時支援 Python 2 和 Python 3，您可以使用 `arguments` 參數來指示所需的 Python 版本。如果省略 `glue-version` 參數，將會假設 AWS Glue 0.9 版。如需 AWS Glue 版本的詳細資訊，請參閱 [Glue version job property](add-job.md#glue-version-table)。 如需其他命令列參數的相關資訊，請參閱 *AWS CLI 命令參考*中的 [create-dev-endpoint](https://docs.aws.amazon.com/cli/latest/reference/glue/create-dev-endpoint.html)。 1. (選用) 輸入下列命令來查看開發端點狀態。當狀態變更為 `READY`，開發端點已就緒可供使用。 ``` aws glue get-dev-endpoint --endpoint-name "endpoint1" ``` # 存取您的開發端點 當您在虛擬私有雲端 (VPC) 中建立開發端點時，AWS Glue 只會傳回一個私有 IP 地址。不會填入公有 IP 地址欄位。建立非 VPC 開發端點時，AWS Glue 只會傳回一個公有 IP 地址。 如果您的開發端點具有**公有地址**，請確認可使用開發端點的 SSH 私有金鑰與其連接，如下列範例所示。 ``` ssh -i dev-endpoint-private-key.pem glue@public-address ``` 假設您的開發端點具有**私有地址**，VPC 子網路可從公有網際網路路由，且其安全群組允許來自用戶端的傳入存取。在此情況下，請依照以下步驟將*彈性 IP 地址*連接到開發端點，以允許來自網際網路的存取。 **注意** 如果您想要使用彈性 IP 地址，使用的子網路需要透過與路由表相關聯的網際網路閘道。 **透過連接彈性 IP 地址來存取開發端點** 1. 在 https：//[https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/) 開啟 AWS Glue 主控台。 1. 在導覽窗格中，選擇 **Dev endpoints (開發端點)**，然後導覽至開發端點詳細資訊頁面。記錄在後續步驟中使用的**私有地址**。 1. 前往 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 開啟 Amazon EC2 主控台。 1. 在導覽窗格的 **Network & Security (網路與安全)** 中，選擇 **Network Interfaces (網路界面)**。 1. 在 AWS Glue 主控台開發端點詳細資訊頁面中搜尋與 **Private address (私有地址)** 相對應的 **Private DNS (IPv4) (私有 DNS (IPv4))**。 您可能需要修改在 Amazon EC2 主控台中會顯示哪些資料欄。請注意此地址的 **Network interface ID (網路界面 ID)** (ENI) (例如 `eni-12345678`)。 1. 在 Amazon EC2 主控台的 **Network & Security (網路與安全)** 中，選擇 **Elastic IPs (彈性 IP)**。 1. 選擇 **Allocate new address (配置新地址)**，然後選擇 **Allocate (配置)** 以配置新的彈性 IP 地址。 1. 在 **Elastic IP** (彈性 IP) 頁面，選擇新配置的**彈性 IP**。然後，選擇 **Actions** (動作)、**Associate address** (關聯地址)。 1. 在 **Associate address (關聯地址)** 頁面上，執行下列動作： + 對於**資源類型**，選擇 **Network interface** (網路介面)。 + 在 **Network interface (網路界面)** 方塊中，輸入私有地址的 **Network interface ID (網路界面 ID)** (ENI)。 + 選擇**關聯**。 1. 確認與開發端點相關聯的 SSH 私有金鑰可存取新關聯的彈性 IP 地址，如下列範例所示。 ``` ssh -i dev-endpoint-private-key.pem glue@elastic-ip ``` 如需使用堡壘主機取得開發端點私有地址的 SSH 存取權的詳細資訊，請參閱 AWS 安全部落格文章[安全連線至私有 Amazon VPC 中執行的 Linux 執行個體](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/)。 # 教學課程：在 JupyterLab 中設定 Jupyter 筆記本以測試和偵錯 ETL 指令碼 在本教學課程中，您將在本機電腦上執行的 JupyterLab 中 Jupyter 筆記本連接到開發端點。您可以執行這項操作，在進行部署之前，先以互動方式執行、偵錯和測試 AWS Glue 擷取、轉換和載入 (ETL) 指令碼。此教學課程使用 Secure Shell (SSH) 連接埠轉送以連接您的本機至 AWS Glue​ 開發端點。如需詳細資訊，請參閱 Wikipedia 中的 [Port forwarding](https://en.wikipedia.org/wiki/Port_forwarding)。 ## 步驟 1：安裝 JupyterLab 和 Sparkmagic 您使用 `conda` 或 `pip` 來安裝 JupyterLab。`conda` 是可在 Windows、macOS 和 Linux 上執行的開源套件管理系統以及環境管理系統。`pip` 是 Python 的套件安裝程式。 如果您在 macOS 上安裝，您必須先安裝 Xcode，才能安裝 Sparkmagic。 1. 安裝 JupyterLab、Sparkmagic 和相關的延伸項目。 ``` $ conda install -c conda-forge jupyterlab $ pip install sparkmagic $ jupyter nbextension enable --py --sys-prefix widgetsnbextension $ jupyter labextension install @jupyter-widgets/jupyterlab-manager ``` 1. 檢查 `Location` 的 `sparkmagic` 目錄。 ``` $ pip show sparkmagic | grep Location Location: /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages ``` 1. 將您的目錄變更為 `Location` 傳回的目錄，並安裝 Scala 和 PySpark 的核心。 ``` $ cd /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages $ jupyter-kernelspec install sparkmagic/kernels/sparkkernel $ jupyter-kernelspec install sparkmagic/kernels/pysparkkernel ``` 1. 下載範例 `config` 檔案。 ``` $ curl -o ~/.sparkmagic/config.json https://raw.githubusercontent.com/jupyter-incubator/sparkmagic/master/sparkmagic/example_config.json ``` 在此組態檔案中，您可以設定 Spark 相關的參數，如 `driverMemory` 和 `executorCores`。 ## 步驟 2：啟動 JupyterLab 當您啟動 JupyterLab 時，系統會自動開啟您的預設網頁瀏覽器，然後顯示 URL `http://localhost:8888/lab/workspaces/{workspace_name}`。 ``` $ jupyter lab ``` ## 步驟 3：啟動 SSH 連接埠轉送以連線到您的開發端點 然後，使用 SSH 本機連接埠轉送，將本機連接埠 (在這裡是 `8998`) 轉送至 AWS Glue (`169.254.76.1:8998`) 定義的遠端目的地。 1. 開啟單獨的終端機視窗，讓您存取 SSH。在 Microsoft Windows 上，您可以使用 [Git for Windows](https://git-scm.com/downloads) 所提供的 BASH shell，或安裝 [Cygwin](https://www.cygwin.com/)。 1. 執行以下 SSH 命令，修改如下： + 以 `.pem` 檔案 (內含與您用於建立開發端點的公有金鑰相關聯的私有金鑰) 的路徑取代 `private-key-file-path`。 + 如果您轉送不同於 `8998` 的連接埠，請以您實際在本機使用的連接埠號取代 `8998`。地址 `169.254.76.1:8998` 是遠端連接埠，且並非由您所變更。 + 以您的開發端點的公有 DNS 位址取代 `dev-endpoint-public-dns`。若要尋找此地址，請在 AWS Glue 主控台瀏覽到您的開發端點並選擇其名稱，然後將 **Endpoint details** (端點詳細資訊) 頁面中列出的 **Public address** (公有地址)。 ``` ssh -i private-key-file-path -NTL 8998:169.254.76.1:8998 glue@dev-endpoint-public-dns ``` 您可能會看到類似如下的警告訊息： ``` The authenticity of host 'ec2-xx-xxx-xxx-xx.us-west-2.compute.amazonaws.com (xx.xxx.xxx.xx)' can't be established. ECDSA key fingerprint is SHA256:4e97875Brt+1wKzRko+JflSnp21X7aTP3BcFnHYLEts. Are you sure you want to continue connecting (yes/no)? ``` 輸入 **yes**，然後在使用 JupyterLab 時維持終端機視窗在開啟狀態。 1. 檢查 SSH 連接埠轉送是否正確與開發端點一起運作。 ``` $ curl localhost:8998/sessions {"from":0,"total":0,"sessions":[]} ``` ## 步驟 4：在筆記本段落中執行簡單的指令碼片段 現在，您的 JupyterLab 中的筆記本應該可以與您的開發端點一起工作。將以下指令碼片段輸入筆記本並執行。 1. 檢查 Spark 是否成功執行。下面的命令會指示 Spark 計算 `1`，然後列印該值。 ``` spark.sql("select 1").show() ``` 1. 檢查 AWS Glue Data Catalog 整合是否正常運作。以下命令會列出 Data Catalog 中的資料表。 ``` spark.sql("show tables").show() ``` 1. 檢查使用 AWS Glue 程式庫的簡單指令碼片段是否有效。 以下指令碼使用 AWS Glue Data Catalog 中的 `persons_json` 資料表中繼資料以從範例資料中建立 `DynamicFrame`。接著它會列印出資料項目數和此資料的結構描述。 ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext # Create a Glue context glueContext = GlueContext(SparkContext.getOrCreate()) # Create a DynamicFrame using the 'persons_json' table persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json") # Print out information about *this* data print("Count: ", persons_DyF.count()) persons_DyF.printSchema() ``` 指令碼的輸出如下。 ``` Count: 1961 root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- note: string | | |-- name: string | | |-- lang: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string ``` ## 疑難排解 + 在 JupyterLab 安裝期間，如果您的電腦位於公司代理伺服器或防火牆後方，您可能會因為公司 IT 部門管理的自訂安全性設定檔而遇到 HTTP 和 SSL 錯誤。 以下是當 `conda` 無法連接到它自己的儲存庫時會發生的典型錯誤範例： ``` CondaHTTPError: HTTP 000 CONNECTION FAILED for url ``` 這可能是因為您的公司封鎖了與 Python 和 JavaScript 社群中廣泛使用的儲存庫的連線。如需詳細資訊，請參閱 JupyterLab 網站上的[安裝問題](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html#installation-problems)。 + 如果在嘗試連接到開發端點時遇到*連線遭拒*的錯誤，有可能您使用的開發端點已過期。請嘗試建立新的開發端點並重新連線。 # 教學課程：將 SageMaker AI 筆記本與開發端點搭配使用 在 AWS Glue 中，您可以建立開發端點，然後建立 SageMaker AI 筆記本以協助開發 ETL 和機器學習指令碼。SageMaker AI 筆記本執行個體是全受管的機器學習運算執行個體，可執行 Jupyter 筆記本應用程式。 1. 在 AWS Glue 主控台，選擇 **Dev endpoints (開發端點)** 以導覽至開發端點清單。 1. 在您要使用的開發端點名稱旁選取核取方塊，然後在 **Action (動作)** 選單中，選擇 **Create SageMaker notebook (建立 SageMaker 筆記本)**。 1. 填寫 **Create and configure a notebook (建立並設定筆記本)** 頁面，如下所示： 1. 輸入記事本名稱。 1. 在 **Attach to development endpoint (連接至開發端點)**，驗證開發端點。 1. 建立或選擇 AWS Identity and Access Management (IAM) 角色。 建議您建立角色。如果您使用現有角色，請確定它具有必要的權限。如需詳細資訊，請參閱[步驟 6：建立適用於 SageMaker AI 筆記本的 IAM 政策](create-sagemaker-notebook-policy.md)。 1. (選用) 選擇 VPC、子網路以及一或多個安全群組。 1. （選用） 選擇 AWS Key Management Service 加密金鑰。 1. (選用) 為筆記本執行個體新增標籤。 1. 選擇**建立筆記本**。在 **Notebooks (筆記本)** 頁面中，選擇右上角的重新整理圖示，然後繼續操作，直到 **Status (狀態)** 顯示 `Ready` 為止。 1. 選取新筆記本名稱旁的核取方塊，然後選擇 **Open notebook (開啟筆記本)**。 1. 建立新的筆記本：在 **jupyter** 頁面中，選擇 **New (新增)**，然後選擇 **Sparkmagic (PySpark)**。 您的螢幕畫面現在看起來應該與下列類似： ![\[jupyter 頁面有一個功能表列、工具列和一個寬文字欄位，您可以在其中輸入語句。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/sagemaker-notebook.png) 1. (選用) 在頁面頂端，選擇 **Untitled (為命名)**，然後為筆記本命名。 1. 若要啟動 Spark 應用程式，請在記事本中輸入下列指令，然後在工具列中選擇 **Run (執行)**。 ``` spark ``` 短暫的等待之後，您應可看到以下回應： ![\[系統回應顯示 Spark 應用程式狀態，並會輸出下列訊息：SparkSession 會以「spark」提供。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/spark-command-response.png) 1. 建立動態框架並針對其執行查詢：複製、貼上並執行下列程式碼，輸出 `persons_json` 資料表的計數和結構描述。 ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.transforms import * glueContext = GlueContext(SparkContext.getOrCreate()) persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json") print ("Count: ", persons_DyF.count()) persons_DyF.printSchema() ``` # 教學課程：使用 REPL shell 搭配開發端點 您可在 AWS Glue 中建立開發端點，並呼叫 REPL (Read-Evaluate-Print Loop) shell，以增量執行 PySpark 程式碼，讓您在部署之前先用互動方式偵錯 ETL 指令碼。 為了在開發端點上使用 REPL，您需要取得端點 SSH 的授權。 1. 在本機電腦上開啟可執行 SSH 命令的終端視窗，並貼入編輯的 SSH 命令。執行命令。 假設您已接受具備 Python 3 的 AWS Glue 1.0 版用於開發端點，輸出將如下所示： ``` Python 3.6.8 (default, Aug 2 2019, 17:42:44) [GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux Type "help", "copyright", "credits" or "license" for more information. SLF4J: Class path contains multiple SLF4J bindings. SLF4J: Found binding in [jar:file:/usr/share/aws/glue/etl/jars/glue-assembly.jar!/org/slf4j/impl/StaticLoggerBinder.class] SLF4J: Found binding in [jar:file:/usr/lib/spark/jars/slf4j-log4j12-1.7.16.jar!/org/slf4j/impl/StaticLoggerBinder.class] SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation. SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory] Setting default log level to "WARN". To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel). 2019-09-23 22:12:23,071 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Neither spark.yarn.jars nor spark.yarn.archive is set, falling back to uploading libraries under SPARK_HOME. 2019-09-23 22:12:26,562 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same name resource file:/usr/lib/spark/python/lib/pyspark.zip added multiple times to distributed cache 2019-09-23 22:12:26,580 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/etl/python/PyGlue.zip added multiple times to distributed cache. 2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/lib/spark/python/lib/py4j-src.zip added multiple times to distributed cache. 2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/libs/pyspark.zip added multiple times to distributed cache. Welcome to ____ __ / __/__ ___ _____/ /__ _\ \/ _ \/ _ `/ __/ '_/ /__ / .__/\_,_/_/ /_/\_\ version 2.4.3 /_/ Using Python version 3.6.8 (default, Aug 2 2019 17:42:44) SparkSession available as 'spark'. >>> ``` 1. 輸入陳述式 `print(spark.version)`，測試 REPL shell 能否正常運作。只要顯示 Spark 版本，即表示 REPL 可以使用。 1. 現在您可以嘗試在 shell 中逐行執行下列簡易指令碼： ``` import sys from pyspark.context import SparkContext from awsglue.context import GlueContext from awsglue.transforms import * glueContext = GlueContext(SparkContext.getOrCreate()) persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json") print ("Count: ", persons_DyF.count()) persons_DyF.printSchema() ``` # 教學課程：設定 PyCharm professional 與開發端點 本教學課程說明如何將您本機電腦上所執行的 [PyCharm Professional](https://www.jetbrains.com/pycharm/) Python IDE，連線到開發端點，以在部署 AWS Glue ETL (擷取、轉換及載入) 指令碼之前，先針對這些指令碼進行互動式的執行、除錯與測試作業。教學課程中的說明和螢幕截圖是根據 PyCharm Professional 2019.3 版。 若要以互動方式連線到開發端點，必須安裝 PyCharm Professional (專業版)。如果使用免費版，將無法執行這項動作。 **注意** 教學課程會使用 Amazon S3 做為資料來源。如果要改為使用 JDBC 資料來源，您必須在虛擬私有雲端 (VPC) 中執行您的開發端點。若要在 VPC 中使用 SSH 連線至開發端點，您必須建立一個 SSH 通道。本教學課程不包括建立 SSH 通道的說明。如需有關使用 SSH 連線到 VPC 中開發端點的資訊，請參閱 AWS 安全部落格中的[安全連線至在私有 Amazon VPC 中執行的 Linux 執行個體](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/)。 **Topics** + [將 PyCharm professional 連線至開發端點](#dev-endpoint-tutorial-pycharm-connect) + [將指令碼部署到您的開發端點](#dev-endpoint-tutorial-pycharm-deploy) + [設定遠端解譯器](#dev-endpoint-tutorial-pycharm-interpreter) + [在開發端點上執行您的指令碼](#dev-endpoint-tutorial-pycharm-debug-run) ## 將 PyCharm professional 連線至開發端點 1. 在 PyCharm 中建立新的純 Python 專案，將其命名為 `legislators`。 1. 使用下列內容，在專案中建立名為 `get_person_schema.py` 的檔案： ``` from pyspark.context import SparkContext from awsglue.context import GlueContext def main(): # Create a Glue context glueContext = GlueContext(SparkContext.getOrCreate()) # Create a DynamicFrame using the 'persons_json' table persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json") # Print out information about this data print("Count: ", persons_DyF.count()) persons_DyF.printSchema() if __name__ == "__main__": main() ``` 1. 執行以下任意一項： + 針對 AWS Glue 0.9 版，從 `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl/python/PyGlue.zip` 將 AWS Glue Python 程式庫檔案 `PyGlue.zip` 下載至您本機電腦上方便的位置。 + 針對 AWS Glue 1.0 版和更新版本，從 `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl-1.0/python/PyGlue.zip` 將 AWS Glue Python 程式庫檔案 `PyGlue.zip` 下載至您本機電腦上方便的位置。 1. 在 PyCharm 中，新增 `PyGlue.zip` 做為您專案的內容根： + 在 PyCharm 中，依序選擇 **File** (檔案)、**Settings** (設定)，來開啟 **Settings** (設定) 對話方塊。(您也可以按 `Ctrl+Alt+S`。) + 展開 `legislators` 專案，然後選擇 **Project Structure** (專案架構)。然後在右側的窗格中，選擇 **\$1 Add Content Root** (\$1 新增內容根)。 + 瀏覽至您儲存 `PyGlue.zip` 的位置，並選取此檔案，然後選擇 ** Apply** (套用)。 **Settings** (設定) 畫面的外觀應類似於下圖所示： ![\[已新增 PyGlue.zip 做為內容根的 PyCharm 設定畫面。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/PyCharm_AddContentRoot.png) 在選擇 **Apply** (套用) 之後，讓 **Settings** (設定) 對話方塊保持開啟。 1. 設定部署選項，以使用 SFTP 來將本機指令碼上傳到您的開發端點 (此功能只在 PyCharm Professional 中提供)： + 在 **Settings** (設定) 對話方塊中，展開 **Build, Execution, Deployment** (建置、執行、部署) 區塊。選擇 **Deployment** (部署) 子區塊。 + 選擇位於中間窗格頂端的 **\$1** 圖示，來新增伺服器。將其 **Type (類型)** 設為 `SFTP` 並命名。 + 將 **SFTP 主機**設為開發端點的**公用位址**，如詳細資料頁面所列。(在 AWS Glue 主控台中選擇開發端點的名稱，以顯示詳細資料頁面)。如為在 VPC 中執行的開發端點，請將 **SFTP 主機** 設定為 SSH 通道的主機位址和開發端點的本機連接埠。 + 將 **User name** (使用者名稱) 設定為 `glue`。 + 將 **Auth type** (驗証類型) 設定為 **Key pair (OpenSSH or Putty)** (金鑰對 (OpenSSH 或 Putty))。瀏覽至您開發端點私有金鑰檔案的所在位置，以設定 **Private key file** (私有金鑰檔案)。請注意，PyCharm 僅支援 DSA、RSA 和 ECDSA OpenSSH 金鑰類型，且不接受 Putty 私有格式的金鑰。您可以使用如下所示的語法，以最新版本的 `ssh-keygen` 來產生 PyCharm 可接受的金鑰對類型： ``` ssh-keygen -t rsa -f -C "" ``` + 選擇 **Test connection (測試連線)**，並允許連線以進行測試。如果連線成功，請選擇 **Apply** (套用)。 **Settings** (設定) 畫面的外觀現在應類似於下圖所示： ![\[定義了 SFTP 伺服器的 PyCharm 設定畫面。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/PyCharm_SFTP.png) 同樣地，在選擇 **Apply** (套用) 之後，讓 **Settings** (設定) 對話方塊保持開啟。 1. 將本機目錄映射至部署用的遠端目錄： + 在 **Deployment** (部署) 頁面的右側窗格中，從位於頂端的索引標籤，選擇中間的 **Mappings** (映射) 索引標籤。 + 在 **Deployment Path** (部署路徑) 欄位中，輸入 `/home/glue/scripts/` 中的路徑，來做為部署您專案的路徑。例如：`/home/glue/scripts/legislators`。 + 選擇**套用**。 **Settings** (設定) 畫面的外觀現在應類似於下圖所示： ![\[進行部署映射後的 PyCharm 設定畫面。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/PyCharm_Mapping.png) 選擇 **OK (確定)** 以關閉 **Settings (設定)** 對話方塊。 ## 將指令碼部署到您的開發端點 1. 選擇 **Tools (工具)**、**Deployment (部署)**，然後在您要設定開發端點使用的名稱，如下圖所示： ![\[用來部署指令碼的選單項目。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/PyCharm_Deploy.png) 在部署指令碼之後，畫面的底部應類似於下圖所示： ![\[部署成功後的 PyCharm 畫面 (底部)。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/PyCharm_Deployed.png) 1. 在功能表中，選擇 **Tools (工具)**、**Deployment (部署)**、**Automatic Upload (always) (自動上傳 (永遠))**。確認 **Automatic Upload (always) (自動上傳 (永遠))** 旁出現核取記號。 啟用此選項時，PyCharm 會自動將變更的檔案上傳到開發端點。 ## 設定遠端解譯器 設定 PyCharm 在開發端點上使用 Python 解釋器。 1. 在 **File (檔案)** 功能表中，選擇 **Open (開啟)**。 1. 展開專案 **Legislators (國會議員)**，然後選擇 **Project Interpreter (專案解譯器)**。 1. 選擇 **Project Interpreter (專案解譯器)** 清單旁的齒輪圖示，然後選擇 **Add (新增)**。 1. 在 **Add Python Interpreter (新增 Python 解譯器)** 對話方塊中，於左窗格中選擇 **SSH Interpreter (SSH 解譯器)**。 1. 選擇 **Existing server configuration (現有伺服器組態)**，然後在 **Deployment configuration (部署組態)** 清單中選擇您的組態。 顯示的畫面應類似於下圖所示： ![\[在左窗格中選擇了 SSH 解譯器，且在右窗格中選擇了現有伺服器組態的單選按鈕。部署組態欄位包含組態名稱，以及「Remote SDK is saved in IDE settings, so it needs the deployment server to be saved there too. Which do you prefer?」 (遠端 SDK 已於 IDE 設定中儲存，因此部署伺服器也必須儲存在該處。您要選擇哪一種？) 的訊息。以下是「Create copy of this deployment server in IDE settings」(在 IDE 設定中建立此部署伺服器的副本) 及「Move this server to IDE settings」(移動此伺服器至 IDE 設定) 訊息下方的選擇。\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/images/PyCharm_Interpreter1.png) 1. 選擇 **Move this server to IDE settings (移動此伺服器至 IDE 設定)**，然後選擇 **Next (下一步)**。 1. 在 **Interpreter (解譯器)** 欄位中，如果您使用 Python 2 則變更路徑為 ` /usr/bin/gluepython`；如果您使用 Python 3 則變更路徑為 `/usr/bin/gluepython3`。然後選擇 **Finish (完成)**。 ## 在開發端點上執行您的指令碼 執行指令碼： + 在左窗格中，右鍵按一下檔案名稱，然後選擇 **Run '**' (執行 <檔案名稱>)**。 在顯示過一系列的訊息後，最終輸出應顯示計數和模式。 ``` Count: 1961 root |-- family_name: string |-- name: string |-- links: array | |-- element: struct | | |-- note: string | | |-- url: string |-- gender: string |-- image: string |-- identifiers: array | |-- element: struct | | |-- scheme: string | | |-- identifier: string |-- other_names: array | |-- element: struct | | |-- lang: string | | |-- note: string | | |-- name: string |-- sort_name: string |-- images: array | |-- element: struct | | |-- url: string |-- given_name: string |-- birth_date: string |-- id: string |-- contact_details: array | |-- element: struct | | |-- type: string | | |-- value: string |-- death_date: string Process finished with exit code 0 ``` 設定已完成，您現在可以從遠端在您的開發端點上進行指令碼的除錯。 # 進階組態：在多個使用者之間共用開發端點 本節說明如何在典型使用案例中利用 SageMaker 筆記本搭配開發端點，在多個使用者之間共用開發端點。 ## 單一租用戶組態 在單一租用戶使用案例中，為了簡化開發人員體驗並避免爭用資源，建議您讓每位開發人員針對他們正在處理的專案使用自己的開發端點大小。這也可以簡化工作者類型和 DPU 計數相關的決策，由開發人員根據他們正在處理的專案自行決定。 除非您同時執行多個筆記本檔案，否則不需要處理資源配置。如果您同時執行多個筆記本檔案中的程式碼，多個 Livy 工作階段將同時啟動。若要隔離 Spark 叢集設定，以便同時執行多個 Livy 工作階段，您可以遵循多租用戶使用案例中介紹的步驟。 例如，如果您的開發端點有 10 個工作者，並且工作者類型為 ` G.1X`，那麼您將有 9 個 Spark 執行器，並且整個叢集將有 90G 的執行器記憶體，因為每個執行器都有 10G 的記憶體。 無論指定的工作者類型為何，Spark 動態資源配置都會開啟。如果資料集足夠大，Spark 可以將所有執行器配置給單個 Livy 工作階段，因為預設未設定 `spark.dynamicAllocation.maxExecutors`。這代表同一個開發端點上的其他 Livy 工作階段將等待啟動新的執行器。如果資料集很小，Spark 將能夠同時將執行器配置給多個 Livy 工作階段。 **注意** 如需有關如何在不同的使用案例中配置資源，以及如何設定組態來修改行為的詳細資訊，請參閱 [進階組態：在多個使用者之間共用開發端點](#dev-endpoint-sharing)。 ### 多租用戶組態 **注意** 請注意，開發端點旨在模擬 AWS Glue ETL 環境做為單一租用戶環境。雖然可以使用多租戶，但這是進階使用案例，仍建議大多數使用者為每個開發端點維護單一租用戶模式。 在多租用戶使用案例中，您可能需要處理資源的配置。關鍵因素是同時使用 Jupyter 筆記本的同時使用者數目。如果您的團隊在「跟隨太陽」工作流程中工作，並且每個時區只有一個 Jupyter 使用者，那麼同時使用者的數量只有一個，因此您不需要關心資源配置。但是，如果您的筆記本在多個使用者之間共用，並且每個使用者在臨機操作基礎上提交程式碼，那麼您將需要考慮以下幾點。 若要在多個使用者之間將 Spark 叢集資源分區，您可以使用 SparkMagic 組態。設定 SparkMagic 有兩個不同方式。 #### (A) 使用 %%configure -f 指令 如果您想從筆記本修改每個 Livy 工作階段的組態，則可以在筆記本段落執行 `%%configure -f` 指令。 例如，如果您想在 5 個執行器上執行 Spark 應用程式，則可以在筆記本段落執行下列命令。 ``` %%configure -f {"numExecutors":5} ``` 然後，您將看到只有 5 個執行器在 Spark UI 上執行該任務。 我們建議限制動態資源配置的執行器的最大數量。 ``` %%configure -f {"conf":{"spark.dynamicAllocation.maxExecutors":"5"}} ``` #### (B) 修改 SparkMagic 組態檔 SparkMagic 是根據 [Livy API](https://livy.incubator.apache.org/docs/latest/rest-api.html) 而運作。SparkMagic 使用組態建立 Livy 工作階段，如 `driverMemory`、` driverCores`、`executorMemory`、`executorCores`、` numExecutors`、`conf` 等。這些都是決定從整個 Spark 叢集消耗多少資源的關鍵因素。SparkMagic 允許您提供組態檔來指定傳送到 Livy 的這些參數。您可以在 [GitHub 儲存庫](https://github.com/jupyter-incubator/sparkmagic/blob/master/sparkmagic/example_config.json)看到範例應用程式組態檔。 如果您想從筆記本中修改所有 Livy 工作階段的組態，則可以修改 `/home/ec2-user/.sparkmagic/config.json` 以新增 `session_config`。 若要修改 SageMaker 筆記本執行個體上的組態檔案，您可以依照下列步驟執行。 1. 開啟 SageMaker 筆記本。 1. 開啟終端機核心。 1. 執行下列命令： ``` sh-4.2$ cd .sparkmagic sh-4.2$ ls config.json logs sh-4.2$ sudo vim config.json ``` 例如，您可以將這些行新增至 ` /home/ec2-user/.sparkmagic/config.json`，然後從筆記本重新啟動 Jupyter 核心。 ``` "session_configs": { "conf": { "spark.dynamicAllocation.maxExecutors":"5" } }, ``` ### 準則和最佳實務 為了避免這種資源衝突，您可以使用一些基本的方法，如： + 透過提高 `NumberOfWorkers` (水平擴展) 以及升級 `workerType` (垂直擴展)，擁有更大的 Spark 叢集 + 每個使用者配置較少的資源 (每個 Livy 工作階段的資源較少) 您的方法將取決於您的使用案例。如果您有較大的開發端點，並且沒有大量的資料，則資源衝突的可能性將大幅減少，因為 Spark 可以根據動態配置策略來配置資源。 如上所述，Spark 執行器的數量可以根據 DPU (或 `NumberOfWorkers`) 和工作者類型自動計算。每個 Spark 應用程式會啟動一個驅動程式和多個執行器。若要計算，您將需要 ` NumberOfWorkers` = `NumberOfExecutors + 1`。下面的矩陣根據同時使用者的數量，說明您在開發端點中需要多少容量。 **** | 同時筆記本使用者數量 | 要為每個使用者配置的 Spark 執行器的數量 | 開發端點的 NumberOfWorkers 總數 | | --- | --- | --- | | 3 | 5 | 18 | | 10 | 5 | 60 | | 50 | 5 | 300 | 如果您想要為每個使用者配置較少的資源，` spark.dynamicAllocation.maxExecutors` (或 `numExecutors`) 將是設定為 Livy 工作階段參數的最簡單參數。如果您在 `/home/ec2-user/.sparkmagic/config.json` 設定以下組態，則 SparkMagic 會為每個 Livy 工作階段指派最多 5 個執行器。這將有助於隔離每個 Livy 工作階段的資源。 ``` "session_configs": { "conf": { "spark.dynamicAllocation.maxExecutors":"5" } }, ``` 假設有 18 個工作者的開發端點 (G.1X)，並且同時有 3 個同時筆記本使用者。如果您的工作階段組態有 ` spark.dynamicAllocation.maxExecutors=5`，那麼每個使用者可以使用 1 個驅動程式和 5 個執行器。即使您同時執行多個筆記本段落，也不會發生任何資源衝突。 #### 取捨 使用此工作階段組態 `"spark.dynamicAllocation.maxExecutors":"5"`，您將能夠避免資源衝突錯誤，並且在存在同時使用者存取時不需要等待資源配置。但是，即使有許多免費資源 (例如，沒有其他同時使用者)，Spark 也不能為您的 Livy 工作階段指派超過 5 個執行器。 #### 其他備註 當您停止使用筆記本時，停止 Jupyter 核心是一個很好的做法。這將釋放資源，其他筆記本使用者可以立即使用這些資源，而無需等待核心過期 (自動關機)。 ### 常見問題 即使遵循指導方針，您可能會遇到某些問題。 #### 找不到工作階段 當您嘗試執行筆記本段落，即使您的 Livy 工作階段已經終止，您會看到下面的訊息。若要啟用 Livy 工作階段，您需要透過選擇 **Kernel (核心)** > **Restart (重新啟動)**，然後再次執行筆記本段落。 ``` An error was encountered: Invalid status code '404' from http://localhost:8998/sessions/13 with error payload: "Session '13' not found." ``` #### YARN 資源不足 當您在 Spark 叢集沒有足夠的資源來啟動新的 Livy 工作階段時嘗試執行筆記本段落，您會看到下面的訊息。您通常可以透過遵循指導方針來避免此問題，但是，您仍可能會遇到此問題。要解決這個問題，您可以檢查是否有任何不需要的作用中 Livy 工作階段。如果有不需要的 Livy 工作階段，您將需要終止這些工作階段才能釋放叢集資源。如需詳細資訊，請參閱下節。 ``` Warning: The Spark session does not have enough YARN resources to start. The code failed because of a fatal error: Session 16 did not start up in 60 seconds.. Some things to try: a) Make sure Spark has enough available resources for Jupyter to create a Spark context. b) Contact your Jupyter administrator to make sure the Spark magics library is configured correctly. c) Restart the kernel. ``` ### 監控與除錯 本節說明監控資源和工作階段的技巧。 #### 監控和除錯叢集資源配置 您可以觀看 Spark UI 來監控每個 Livy 工作階段配置了多少資源，以及任務上的有效 Spark 組態是什麼。若要啟用 Spark UI，請參閱[為開發端點啟用 Apache Spark Web UI](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-dev-endpoints.html)。 (選用) 如果您需要 Spark UI 的即時視圖，則可以針對 Spark 叢集上執行的 Spark 歷史記錄伺服器設定 SSH 通道。 ``` ssh -i -N -L 8157::18080 glue@ ``` 然後您可以在瀏覽器中開啟 http://localhost:8157 以檢視 Spark UI。 #### 釋放不需要的 Livy 工作階段 檢閱這些程序，以從筆記本或 Spark 叢集關閉任何不需要的 Livy 工作階段。 **(a). 從筆記本終止 Livy 工作階段** 您可以關閉 Jupyter 筆記本上的核心以終止不需要的 Livy 工作階段。 **(b). 從 Spark 叢集終止 Livy 工作階段** 如果不需要的 Livy 工作階段仍在執行，則可以關閉 Spark 叢集上的 Livy 工作階段。 作為執行此程序的先決條件，您需要為開發端點設定 SSH 公有金鑰。 若要登入到 Spark 叢集，您可以執行下列命令： ``` $ ssh -i glue@ ``` 您可以執行下列命令來查看作用中 Livy 工作階段： ``` $ yarn application -list 20/09/25 06:22:21 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/172.38.106.206:8032 Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):2 Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL application_1601003432160_0005 livy-session-4 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-4-130.ec2.internal:41867 application_1601003432160_0004 livy-session-3 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-179-185.ec2.internal:33727 ``` 然後，您可以使用以下命令關閉 Livy 工作階段： ``` $ yarn application -kill application_1601003432160_0005 20/09/25 06:23:38 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/255.1.106.206:8032 Killing application application_1601003432160_0005 20/09/25 06:23:39 INFO impl.YarnClientImpl: Killed application application_1601003432160_0005 ``` # 管理筆記本 **注意** 開發端點僅支援 2.0 AWS Glue 之前的 版本。對於您可以在其中撰寫和測試 ETL 指令碼的互動式環境，請在 [AWS Glue Studio 上使用筆記本](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html)。 筆記本可讓您在開發端點上進行互動開發並測試 ETL (擷取、轉換和載入) 指令碼。AWS Glue 提供 SageMaker AI Jupyter 筆記本的介面。您可以使用 AWS Glue 來建立和管理 SageMaker AI 筆記本。您也可以從 AWS Glue 主控台開啟 SageMaker AI 筆記本。 此外，您可以在支援 SageMaker AI 的 AWS Glue 開發端點上搭配使用 Apache Spark 與 SageMaker AI (而非 AWS Glue ETL 任務)。SageMaker Spark 是一種適用於 SageMaker AI 的開源 Apache Spark 程式庫。如需詳細資訊，請參閱 [Using Apache Spark with Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html) (搭配 Apache Spark 使用 Amazon SageMaker)。 | 區域 | Code | | --- | --- | | 使用AWS Glue開發端點管理 SageMaker AI 筆記本可在下列 AWS 區域使用： [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/glue/latest/dg/notebooks-with-glue.html) | | 美國東部 (俄亥俄) | `us-east-2` | | 美國東部 (維吉尼亞北部) | `us-east-1` | | 美國西部 (加利佛尼亞北部) | `us-west-1` | | 美國西部 (奧勒岡) | `us-west-2` | | 亞太地區 (東京) | `ap-northeast-1` | | 亞太地區 (首爾) | `ap-northeast-2` | | 亞太地區 (孟買) | `ap-south-1` | | 亞太地區 (新加坡) | `ap-southeast-1` | | 亞太地區 (雪梨) | `ap-southeast-2` | | 加拿大 (中部) | `ca-central-1` | | 歐洲 (法蘭克福) | `eu-central-1` | | 歐洲 (愛爾蘭) | `eu-west-1` | | 歐洲 (倫敦) | `eu-west-2` | **Topics**