本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 使用 Step Functions 開發工作流程
建議您開始在 Step Functions 主控台和 Workflow Studio 視覺化編輯器中建置工作流程。您可以從空白畫布開始，或選擇常見案例的入門範本。
建置您的工作流程需要下列任務：
+ 定義您的工作流程
+ 執行和偵錯您的工作流程
+ 部署您的工作流程
您可以使用 Amazon States Language 定義狀態機器。您可以手動建立 Amazon States Language 定義，但 Workflow Studio 會在教學課程中顯示。使用 Workflow Studio，您可以定義機器定義、視覺化和編輯步驟、執行和偵錯工作流程，以及從 Step Functions 主控台檢視所有結果。
**在 Visual Studio 程式碼中使用 Workflow Studio**
透過 AWS 工具組，您可以從 VS 程式碼內使用 Workflow Studio，在狀態機器中視覺化、建置甚至測試個別狀態。您可以提供狀態輸入並設定變數、開始測試，然後即可查看資料的轉換方式。您可以調整工作流程並重新測試。完成後，您可以套用變更來更新狀態機器。如需詳細資訊，請參閱《》中的[使用 Workflow Studio](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html) AWS Toolkit for Visual Studio Code。
您也可以從 AWS Command Line Interface () 使用許多 Step Functions 功能AWS CLI。例如，您可以建立狀態機器並列出現有的狀態機器。您可以在 中使用 Step Functions 命令 AWS CLI 來啟動和管理執行、輪詢活動、記錄任務活動訊號等。如需 Step Functions 命令的完整清單、可用引數的說明，以及顯示其使用方式的範例，請參閱 *AWS CLI 命令參考*。[AWS CLI 命令參考](https://docs.aws.amazon.com/cli/latest/reference/)
AWS CLI 命令會密切遵循 Amazon States Language，因此您可以使用 AWS CLI 來了解 Step Functions API 動作。您也可以使用現有的 API 知識來原型程式碼，或從命令列執行 Step Functions 動作。
**驗證狀態機器定義**
您可以使用 API **驗證**狀態機器，並在建立工作流程之前尋找潛在問題。
若要進一步了解驗證工作流程，請參閱 Step Functions API 參考中的 [ValidateStateMachineDefinition](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ValidateStateMachineDefinition.html)。
若要開始使用最少的設定，您可以遵循[建立 Lambda 狀態機器](tutorial-creating-lambda-state-machine.md)教學課程，其中說明如何使用呼叫 Lambda 函數的單一步驟來定義工作流程，然後執行工作流程，並檢視結果。
## 定義您的工作流程
開發工作流程的第一步是以 Amazon States Language 定義步驟。根據您的偏好設定和工具，您可以使用 JSON、YAML 或字串化 Amazon States Language (ASL) 定義來定義 Step Functions 狀態機器。
下表顯示依工具支援 ASL 型定義格式。
| AWS 工具 | 支援的格式 (s) |
| --- | --- |
| Step Functions 主控台 | JSON |
| HTTPS 服務 API | 分層 ASL |
| AWS CLI | 分層 ASL |
| Step Functions Local | 分層 ASL |
| AWS Toolkit for Visual Studio Code | JSON、YAML |
| AWS SAM | JSON、YAML |
| CloudFormation | JSON、YAML、分層 ASL |
範本狀態機器定義中的 YAML 單行註解不會轉送至建立的資源定義。如果您需要保留註解，您應該在狀態機器定義中使用 `Comment` 屬性。如需相關資訊，請參閱[狀態機器結構](statemachine-structure.md)。
使用 CloudFormation 和 AWS SAM，您可以將狀態機器定義上傳至 Amazon S3 (JSON 或 YAML 格式），並在範本中提供定義的 Amazon S3 位置。如需詳細資訊，請參閱 [AWS::StepFunctions::StateMachine S3Location](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-properties-stepfunctions-statemachine-s3location.html) 頁面。
下列範例 CloudFormation 範本示範如何使用不同的輸入格式提供相同的狀態機器定義。
------
#### [ JSON with Definition ]
```
{
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "AWS Step Functions sample template.",
"Resources": {
"MyStateMachine": {
"Type": "AWS::StepFunctions::StateMachine",
"Properties": {
"RoleArn": {
"Fn::GetAtt": [ "StateMachineRole", "Arn" ]
},
"TracingConfiguration": {
"Enabled": true
},
"Definition": {
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Pass",
"End": true
}
}
}
}
},
"StateMachineRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"sts:AssumeRole"
],
"Effect": "Allow",
"Principal": {
"Service": [
"states.amazonaws.com"
]
}
}
]
},
"ManagedPolicyArns": [],
"Policies": [
{
"PolicyName": "StateMachineRolePolicy",
"PolicyDocument": {
"Statement": [
{
"Action": [
"lambda:InvokeFunction"
],
"Resource": "*",
"Effect": "Allow"
}
]
}
}
]
}
}
},
"Outputs": {
"StateMachineArn": {
"Value": {
"Ref": "MyStateMachine"
}
}
}
}
```
------
#### [ JSON with DefinitionString ]
```
{
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "AWS Step Functions sample template.",
"Resources": {
"MyStateMachine": {
"Type": "AWS::StepFunctions::StateMachine",
"Properties": {
"RoleArn": {
"Fn::GetAtt": [ "StateMachineRole", "Arn" ]
},
"TracingConfiguration": {
"Enabled": true
},
"DefinitionString": "{\n \"StartAt\": \"HelloWorld\",\n \"States\": {\n \"HelloWorld\": {\n \"Type\": \"Pass\",\n \"End\": true\n }\n }\n}"
}
},
"StateMachineRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"sts:AssumeRole"
],
"Effect": "Allow",
"Principal": {
"Service": [
"states.amazonaws.com"
]
}
}
]
},
"ManagedPolicyArns": [],
"Policies": [
{
"PolicyName": "StateMachineRolePolicy",
"PolicyDocument": {
"Statement": [
{
"Action": [
"lambda:InvokeFunction"
],
"Resource": "*",
"Effect": "Allow"
}
]
}
}
]
}
}
},
"Outputs": {
"StateMachineArn": {
"Value": {
"Ref": "MyStateMachine"
}
}
}
}
```
------
#### [ YAML with Definition ]
```
AWSTemplateFormatVersion: 2010-09-09
Description: AWS Step Functions sample template.
Resources:
MyStateMachine:
Type: 'AWS::StepFunctions::StateMachine'
Properties:
RoleArn: !GetAtt
- StateMachineRole
- Arn
TracingConfiguration:
Enabled: true
Definition:
# This is a YAML comment. This will not be preserved in the state machine resource's definition.
Comment: This is an ASL comment. This will be preserved in the state machine resource's definition.
StartAt: HelloWorld
States:
HelloWorld:
Type: Pass
End: true
StateMachineRole:
Type: 'AWS::IAM::Role'
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
- Action:
- 'sts:AssumeRole'
Effect: Allow
Principal:
Service:
- states.amazonaws.com
ManagedPolicyArns: []
Policies:
- PolicyName: StateMachineRolePolicy
PolicyDocument:
Statement:
- Action:
- 'lambda:InvokeFunction'
Resource: "*"
Effect: Allow
Outputs:
StateMachineArn:
Value:
Ref: MyStateMachine
```
------
#### [ YAML with DefinitionString ]
```
AWSTemplateFormatVersion: 2010-09-09
Description: AWS Step Functions sample template.
Resources:
MyStateMachine:
Type: 'AWS::StepFunctions::StateMachine'
Properties:
RoleArn: !GetAtt
- StateMachineRole
- Arn
TracingConfiguration:
Enabled: true
DefinitionString: |
{
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Pass",
"End": true
}
}
}
StateMachineRole:
Type: 'AWS::IAM::Role'
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
- Action:
- 'sts:AssumeRole'
Effect: Allow
Principal:
Service:
- states.amazonaws.com
ManagedPolicyArns: []
Policies:
- PolicyName: StateMachineRolePolicy
PolicyDocument:
Statement:
- Action:
- 'lambda:InvokeFunction'
Resource: "*"
Effect: Allow
Outputs:
StateMachineArn:
Value:
Ref: MyStateMachinele
```
------
**使用 AWS SDKs 開發工作流程**
Step Functions 受適用於 Java、.NET、Ruby、PHP、Python (Boto 3)、JavaScript、Go 和 C\$1\$1 AWS SDKs 支援。這些SDKs提供以多種程式設計語言使用 Step Functions HTTPS API 動作的便利方式。您可以使用這些軟體開發套件程式庫所公開的 API 動作來開發狀態機器、活動或狀態機器啟動者。您也可以使用這些程式庫來存取可見性操作，以開發自己的 Step Functions 監控和報告工具。請參閱目前適用於 Amazon Web Services AWS SDKs 和工具參考文件。 [https://aws.amazon.com/tools/](https://aws.amazon.com/tools/)
**透過 HTTPS 請求開發工作流程**
Step Functions 提供可透過 HTTPS 請求存取的服務操作。您可以使用這些操作，從您自己的程式庫直接與 Step Functions 通訊。您可以使用服務 API 動作來開發狀態機器、工作者或狀態機器啟動者。您也可以透過 API 動作來存取可見度操作，以開發專屬的監控和報告工具。如需詳細資訊，請參閱 [AWS Step Functions API 參考](https://docs.aws.amazon.com/step-functions/latest/apireference/)。
**使用 AWS Step Functions 資料科學 SDK 開發工作流程**
資料科學家可以使用 SageMaker AI 和 Step Functions 建立工作流程來處理和發佈機器學習模型。您也可以在 Python 中建立多步驟機器學習工作流程，以大規模協調 AWS 基礎設施。 AWS Step Functions 資料科學 SDK 提供 Python API，可建立和叫用 Step Functions 工作流程。您可以直接在 Python 以及 Jupyter 筆記本中管理和執行這些工作流程。如需詳細資訊，請參閱：[AWS Github 上的 Step Functions 資料科學專案](https://github.com/aws/aws-step-functions-data-science-sdk-python)、[資料科學 SDK 文件](https://aws-step-functions-data-science-sdk.readthedocs.io/)，以及 GitHub [上的 Jupyter 筆記本](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-nbexamples.html)和 SageMaker AI 範例。 [SageMaker GitHub](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/step-functions-data-science-sdk)
## 執行和偵錯您的工作流程
您可以透過多種方式啟動工作流程，包括從主控台、從 Amazon EventBridge 和 EventBridge Scheduler 從另一個 Step Functions 狀態機器進行 API 呼叫 （例如，從 Lambda 函數）。執行中的工作流程可以連接到第三方服務、使用 AWS SDKs並在執行時操作資料。有多種工具可以執行和偵錯執行步驟，以及流經狀態機器的資料。下列各節提供執行和偵錯工作流程的其他資源。
若要進一步了解啟動狀態機器執行的方法，請參閱 [在 Step Functions 中啟動狀態機器執行](statemachine-starting.md)。
**選擇要執行工作流程的端點**
為了減少延遲並將資料存放在符合您需求的位置，Step Functions 會在不同的 AWS 區域中提供端點。Step Functions 中的每個端點都是完全獨立的。狀態機器或活動只存在於其建立所在的區域內。您在某個區域中建立的任何狀態機器和活動都不會與在另一個區域中建立的資料或屬性共用任何資料或屬性。例如，您可以在`STATES-Flows-1`兩個不同的區域中註冊名為 的狀態機器。一個區域中`STATES-Flows-1`的狀態機器不會與另一個區域中`STATES-Flow-1`的狀態機器共用資料或屬性。如需 Step Functions 端點的清單，請參閱 中的[AWS Step Functions 區域和端點](https://docs.aws.amazon.com/general/latest/gr/step-functions.html)*AWS 一般參考*。
**使用 VS 程式碼進行開發**
透過 AWS 工具組，您可以從 VS 程式碼內使用 Workflow Studio，在狀態機器中視覺化、建置甚至測試個別狀態。您也可以使用 SAM 和 CloudFormation 定義替換。您可以提供狀態輸入並設定變數、開始測試，然後即可查看資料的轉換方式。在狀態定義索引標籤中，您可以調整工作流程並重新測試。完成後，您可以套用變更來更新狀態機器。如需詳細資訊，請參閱《》中的[使用步驟函數](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/bulding-stepfunctions.html)和[使用工作流程 Studio](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html) AWS Toolkit for Visual Studio Code。
## 部署您的工作流程
定義和偵錯工作流程之後，您可能想要使用基礎設施做為程式碼架構進行部署。您可以選擇使用各種 IaC 選項來部署狀態機器，包括： AWS Serverless Application Model CloudFormation、 AWS CDK和 Terraform。
**AWS Serverless Application Model**
您可以使用 AWS Serverless Application Model 搭配 Step Functions 來建置工作流程和部署所需的基礎設施，包括 Lambda 函數、APIs和事件，以建立無伺服器應用程式。您也可以使用 AWS SAM CLI 搭配 AWS Toolkit for Visual Studio Code 做為整合體驗的一部分。
如需詳細資訊，請參閱[使用 AWS SAM 建置 Step Functions 工作流程](concepts-sam-sfn.md)。
**CloudFormation**
您可以直接在 CloudFormation 範本中使用狀態機器定義。
如需詳細資訊，請參閱[使用 在 Step Functions 中 CloudFormation 建立工作流程](tutorial-lambda-state-machine-cloudformation.md)。
**AWS CDK**
您可以使用 建置標準和快速狀態機器 AWS CDK。
若要建置標準工作流程，請參閱 [使用 CDK 建立標準工作流程](tutorial-lambda-state-machine-cdk.md)。
若要建置 Express 工作流程，請參閱 [使用 CDK 建立 Express 工作流程](tutorial-step-functions-rest-api-integration-cdk.md)。
**Terraform**
HashiCorp 的 [Terraform](https://www.terraform.io/intro/) 是使用基礎設施即程式碼 (IaC) 建置應用程式的架構。使用 Terraform，您可以建立狀態機器並使用功能，例如預覽基礎設施部署和建立可重複使用的範本。Terraform 範本會將程式碼分解為較小的區塊，協助您維護和重複使用程式碼。
如需詳細資訊，請參閱[使用 Terraform 在 Step Functions 中部署狀態機器](terraform-sfn.md)。
# 在 Step Functions Workflow Studio 中開發工作流程
在 AWS Step Functions 主控台中編輯工作流程時，您會使用名為 Workflow Studio 的視覺化工具。使用 Workflow Studio，您可以在畫布上drag-and-drop狀態以建置工作流程。您可以新增、編輯和設定狀態、設定輸入和輸出篩選條件、轉換結果，以及設定錯誤處理。
當您修改工作流程中的狀態時，Workflow Studio 會驗證和自動產生狀態機器定義。您可以使用內建程式碼編輯器檢閱產生的程式碼、編輯組態，甚至修改文字定義。完成後，您可以儲存工作流程、執行工作流程，然後檢查結果。
您可以在建立或編輯工作流程時，從 Step Functions 主控台存取 Workflow Studio。
您也可以從視覺化設計工具 **內**使用 Workflow StudioAWS Infrastructure Composer，透過 AWS Serverless Application Model 和 建立基礎設施做為程式碼AWS CloudFormation。若要探索此方法的優點，請參閱 [在 中使用 Workflow Studio Infrastructure Composer](use-wfs-in-app-composer.md)。
Workflow Studio 有三種模式：**設計**、**程式碼**和**組態**。在*設計模式中*，您可以在畫布上drag-and-drop狀態。*程式碼模式*提供內建程式碼編輯器，可在 主控台中編輯工作流程定義。在 *Config 模式中*，您可以管理工作流程組態。
**在 Visual Studio 程式碼中使用 Workflow Studio**
透過 AWS 工具組，您可以從 VS Code 內使用 Workflow Studio，在狀態機器中視覺化、建置甚至測試個別狀態。您可以提供狀態輸入並設定變數、開始測試，然後即可查看資料的轉換方式。您可以調整工作流程並重新測試。完成後，您可以套用變更來更新狀態機器。如需詳細資訊，請參閱《》中的[使用 Workflow Studio](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html) AWS Toolkit for Visual Studio Code。
## 設計模式
設計模式提供圖形界面，可讓您在建置工作流程原型時將工作流程視覺化。下圖顯示 Workflow Studio **設計**模式中的狀態瀏覽器、工作流程畫布、檢測器和內容說明面板。
![\[設計模式的螢幕擷取畫面，顯示狀態瀏覽器、工作流程畫布、檢測器和說明面板。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/wfs_main_01.png)
1. 模式按鈕會在三種模式之間切換。如果您的 ASL 工作流程定義無效，則無法切換模式。
1. [狀態瀏覽器](#workflow-studio-components-states) 包含下列三個標籤：
+ **動作**索引標籤提供 AWS APIs 的清單，您可以在畫布中拖放到工作流程圖表中。每個動作都代表一個[任務工作流程狀態](state-task.md)狀態。
+ **流程**索引標籤提供流程狀態清單，您可以在畫布中拖放至工作流程圖表。
+ **模式**索引標籤提供數個ready-to-use、可重複使用的建置區塊，可用於各種使用案例。例如，您可以使用這些模式反覆處理 Amazon S3 儲存貯體中的資料。
1. [Canvas 和工作流程圖表](#workflow-studio-components-grapheditor) 可讓您將狀態拖放至工作流程圖表、變更狀態順序，以及選取要設定或檢視的狀態。
1. 您可以在[Inspector 面板](#workflow-studio-components-formdefinition)面板中檢視和編輯您已在畫布上選取之任何狀態的屬性。開啟**定義**切換以檢視工作流程的 Amazon States 語言代碼，並反白顯示目前選取的狀態。
1. 當您需要協助時，**資訊**連結會開啟包含內容資訊的面板。這些面板也包含 Step Functions 文件中相關主題的連結。
1. 設計工具列 – 包含一組按鈕來執行常見動作，例如復原、刪除和放大。
1. 公用程式按鈕 – 用來執行任務的一組按鈕，例如儲存工作流程，或在 JSON 或 YAML 檔案中匯出其 ASL 定義。
### 狀態瀏覽器
從狀態瀏覽器中，您可以選取要拖放至工作流程畫布的狀態。**動作**索引標籤提供連線至第三方 HTTP 端點和 AWS APIs的任務狀態清單。**流程**索引標籤提供狀態清單，您可以使用這些清單來指示和控制工作流程。流程狀態包括：選擇、平行、映射、通過、等待、成功和失敗。**模式**索引標籤提供ready-to-use、可重複使用的預先定義建置區塊。您可以使用面板頂端的搜尋方塊搜尋所有狀態類型。
![\[顯示動作、流程、模式和搜尋的螢幕擷取畫面說明集合。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/wfe-states-browser-01.png)
### Canvas 和工作流程圖表
選擇要新增至工作流程的狀態之後，您可以將其拖曳至畫布，並將其放入工作流程圖表中。您也可以拖放狀態，在工作流程中移動它們。如果您的工作流程很大，您可以放大或縮小，以在畫布中檢視工作流程圖形的不同部分。
### Inspector 面板
您可以從右側的**檢查器**面板設定新增至工作流程的任何狀態。選擇您要設定的狀態，您會在**檢查器**面板中看到其組態選項。若要查看工作流程程式碼的自動產生 [ASL 定義](concepts-amazon-states-language.md)，請開啟**定義**切換。與您所選狀態相關聯的 ASL 定義將反白顯示。
![\[顯示組態面板之 Workflow Studio 檢查程式的說明性螢幕擷取畫面\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/wfe-forms-definitions-01.png)
![\[顯示程式碼定義之 Workflow Studio 檢測器面板的說明性螢幕擷取畫面\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/wfe-forms-definitions-02.png)
## 程式碼模式
在 Workflow Studio 的**程式碼**模式中，您可以使用整合式程式碼編輯器，在 Step Functions 主控台中檢視、寫入和編輯工作流程的 [使用 Amazon States Language 定義 Step Functions 工作流程](concepts-amazon-states-language.md)(ASL) 定義。下列螢幕擷取畫面顯示**程式碼**模式中的元件。
![\[在程式碼模式中編輯工作流程定義的說明性螢幕擷取畫面。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/wfs-code-mode.png)
1. 模式按鈕會在三種模式之間切換。如果您的 ASL 工作流程定義無效，則無法切換模式。
1. [程式碼編輯器](#wfs-interface-code-editor) 您可以在 Workflow Studio 中撰寫和編輯工作流程的 [ASL 定義](concepts-amazon-states-language.md)。程式碼編輯器也提供功能，例如語法反白和自動完成。
1. [圖形視覺化](#wfs-interface-code-graph-viz) – 顯示工作流程的即時圖形視覺化。
1. 公用程式按鈕 – 用來執行任務的一組按鈕，例如儲存工作流程，或在 JSON 或 YAML 檔案中匯出其 ASL 定義。
1. 程式碼工具列 – 包含一組按鈕來執行常見動作，例如復原動作或格式化程式碼。
1. 圖形工具列 – 包含一組按鈕來執行常見動作，例如放大和縮小工作流程圖形。
### 程式碼編輯器
程式碼編輯器提供類似 IDE 的體驗，可讓您在 Workflow Studio 中使用 JSON 撰寫和編輯工作流程定義。程式碼編輯器包含數個功能，例如語法反白、自動完成建議、[ASL 定義](concepts-amazon-states-language.md)驗證和內容敏感的說明顯示。當您更新工作流程定義時， 會[圖形視覺化](#wfs-interface-code-graph-viz)轉譯工作流程的即時圖形。您也可以在 中查看更新的工作流程圖表[設計模式](#wfs-interface-design-mode)。
如果您在 [設計模式](#wfs-interface-design-mode)或圖形視覺化窗格中選取狀態，則該狀態的 ASL 定義會顯示在程式碼編輯器中反白顯示。如果您在**設計**模式或圖形視覺化窗格中重新排序、刪除或新增狀態，工作流程的 ASL 定義會自動更新。
程式碼編輯器可以建議自動完成欄位和狀態。
+ 若要查看您可以在特定狀態內包含的欄位清單，請按 **Ctrl\$1Space**。
+ 若要為工作流程中的新狀態產生程式碼片段，請在目前狀態的定義**Ctrl\$1Space**之後按 。
+ 若要顯示所有可用命令和**鍵盤快速鍵**的清單，請按 **F1**。
### 圖形視覺化
圖形視覺化面板會以圖形格式顯示您的工作流程。當您在 Workflow Studio [程式碼編輯器](#wfs-interface-code-editor)的 中撰寫工作流程定義時，圖形視覺化窗格會轉譯工作流程的即時圖形。
當您在圖形視覺化窗格中重新排序、刪除或複製狀態時，程式碼編輯器中的工作流程定義會自動更新。同樣地，當您在程式碼編輯器中更新工作流程定義、重新排序、刪除或新增狀態時，視覺化效果會自動更新。
如果工作流程的 ASL 定義中的 JSON 無效，圖形視覺化面板會暫停轉譯，並在窗格底部顯示狀態訊息。
## 組態模式
在 Workflow Studio 的 **Config** 模式中，您可以管理狀態機器的一般組態。在此模式中，您可以指定設定，如下所示：
+ **詳細資訊**：設定工作流程**名稱**和**類型**。請注意，在您建立狀態機器之後，兩者**都無法**變更。
+ **許可 **：您可以建立新的角色 （建議）、選擇現有角色，或輸入特定角色的 ARN。如果您選擇建立新角色的選項，Step Functions 會使用最低權限為您的狀態機器建立執行角色。產生的 IAM 角色對您 AWS 區域 建立狀態機器的 有效。在建立之前，您可以檢閱 Step Functions 為狀態機器自動產生的許可。
+ **記錄**：您可以啟用和設定狀態機器的日誌層級。Step Functions 會根據您的選擇記錄執行歷史記錄事件。您可以選擇使用客戶受管金鑰來加密您的日誌。如需日誌層級的詳細資訊，請參閱 [Step Functions 執行事件的日誌層級](cw-logs.md#cloudwatch-log-level)。
**在其他組態**中，您可以設定下列一或多個**選用**組態選項：
+ **啟用 X-Ray 追蹤**：即使上游服務未傳遞追蹤 ID，您也可以將追蹤傳送至 X-Ray 以進行狀態機器執行。如需詳細資訊，請參閱[在 中追蹤 Step Functions 請求資料 AWS X-Ray](concepts-xray-tracing.md)。
+ **建立時發佈版本**：*版本*是您可以執行的狀態機器的編號、不可變快照。選擇此選項可在建立狀態機器時發佈狀態機器的版本。Step Functions 會將第 1 版發佈為狀態機器的第一個修訂版。如需有關版本的詳細資訊，請參閱[Step Functions 工作流程中的狀態機器版本](concepts-state-machine-version.md)。
+ **使用客戶受管金鑰加密 **：您可以直接提供用來加密資料的金鑰。如需相關資訊，請參閱[靜態資料加密](encryption-at-rest.md)。
+ **標籤**：選擇此方塊可新增標籤，協助您追蹤和管理與 資源相關的成本，並在 IAM 政策中提供更好的安全性。如需標籤的詳細資訊，請參閱[在 Step Functions 中標記狀態機器和活動](sfn-best-practices.md#concepts-tagging)。
# 在 Step Functions 中使用 Workflow Studio 建立工作流程
了解如何使用 Step Functions Workflow Studio 建立、編輯和執行工作流程。工作流程準備就緒後，您可以儲存、執行和匯出它。
**Topics**
+ [建立狀態機器](#workflow-studio-components-create)
+ [設計工作流程](#workflow-studio-build)
+ [執行您的工作流程](#workflow-studio-components-create-run)
+ [編輯您的工作流程](#workflow-studio-components-create-edit)
+ [匯出您的工作流程](#workflow-studio-components-create-export)
+ [使用預留位置建立工作流程原型](#workflow-studio-components-create-prototype)
## 建立狀態機器
在工作流程 Studio 中，您可以選擇入門範本或空白範本來建立工作流程。
入門範本是ready-to-run的範例專案，可自動建立工作流程原型和定義，並將專案所需的所有相關 AWS 資源部署至您的 AWS 帳戶。您可以使用這些入門範本依原狀部署和執行，或使用工作流程原型來建置這些範本。如需入門範本的詳細資訊，請參閱 [使用 Step Functions 的入門範本部署狀態機器](starter-templates.md)。
使用空白範本時，您可以使用[設計](workflow-studio.md#wfs-interface-design-mode)或[程式碼](workflow-studio.md#wfs-interface-code-mode)模式來建立自訂工作流程。
### 使用入門範本建立狀態機器
1. 開啟 [Step Functions 主控台](https://console.aws.amazon.com/states/home?region=us-east-1#/)，然後選擇**建立狀態機器**。
1. 在**選擇範本**對話方塊中，執行下列其中一項操作來選擇範例專案：
+ **Task Timer** 在依關鍵字搜尋方塊中輸入 ，然後從搜尋結果中選擇**任務計時器**。
+ 瀏覽右側窗格中**全部**列出的範例專案，然後選擇**任務計時器**。
1. 選擇 **Next** (下一步) 繼續。
1. 選擇如何使用範本：
1. 選擇**使用範本**以繼續您的選擇。
1. **執行示範** – 建立唯讀狀態機器。檢閱後，您可以建立工作流程和所有相關資源。
1. **在其中建置** – 提供可編輯的工作流程定義，您可以使用自己的資源來檢閱、自訂和部署。(**不會**自動建立相關資源，例如函數或佇列。)
### 使用空白範本建立工作流程
當您想要從乾淨的畫布開始時，請從空白範本建立工作流程。
1. 開啟 [Step Functions 主控台](https://console.aws.amazon.com/states/home?region=us-east-1#/)。
1. 選擇 **Create state machine (建立狀態機器)**。
1. 選擇**從空白建立**。
1. 為您的狀態機器命名，然後選擇**繼續**在 Workflow Studio 中編輯您的狀態機器。
您現在可以開始在 中設計工作流程，[設計模式](workflow-studio.md#wfs-interface-design-mode)或在 中撰寫工作流程定義[程式碼模式](workflow-studio.md#wfs-interface-code-mode)。
1. 選擇**組態**以在 中管理工作流程的組態[組態模式](workflow-studio.md#wfs-interface-config-mode)。例如，為您的工作流程提供名稱，然後選擇其類型。
## 設計工作流程
當您知道要新增的狀態名稱時，請使用 頂端的搜尋方塊[狀態瀏覽器](workflow-studio.md#workflow-studio-components-states)來尋找狀態。否則，請在瀏覽器中尋找您需要的狀態，並將其新增至畫布。
您可以將工作流程中的狀態拖曳到工作流程中的不同位置，以重新排序。當您將狀態拖曳到畫布上時，會出現一行，顯示狀態將插入工作流程的位置，如下列螢幕擷取畫面所示：
![\[顯示指示狀態目的地之藍線的圖例螢幕擷取畫面。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/wfe-design-02.png)
將狀態捨棄至畫布後，其程式碼會自動產生並在工作流程定義中新增。若要查看定義，請開啟 [Inspector 面板](workflow-studio.md#workflow-studio-components-formdefinition)上的**定義**切換。您可以選擇使用內建程式碼編輯器[程式碼模式](workflow-studio.md#wfs-interface-code-mode)編輯定義。
在畫布上捨棄狀態後，您可以在右側的[Inspector 面板](workflow-studio.md#workflow-studio-components-formdefinition)面板中設定狀態。此面板包含您在畫布上放置的每個狀態或 API 動作的**組態**、**輸入**、**輸出**和**錯誤處理**索引標籤。您可以在組態索引標籤中**設定**工作流程中包含的狀態。
例如，Lambda 調用 API 動作的**組態**索引標籤提供下列選項：
+ **狀態名稱**：您可以使用自訂名稱識別狀態，或接受預設產生的名稱。
+ **API** 會顯示狀態使用的 API 動作。
+ **整合類型**：您可以選擇用於在其他 服務上呼叫 API 動作的服務整合類型。
+ **函數名稱**提供下列選項：
+ **輸入函數名稱**：您可以輸入函數名稱或其 ARN。
+ **在執行時間從狀態輸入取得函數名稱**：您可以使用此選項，根據您指定的路徑，從狀態輸入動態取得函數名稱。
+ **選取函數名稱**：您可以直接從帳戶和區域中可用的函數中選取。
+ **承載** ：您可以選擇使用狀態輸入、JSON 物件或無承載做為承載傳遞至 Lambda 函數。如果您選擇 JSON，您可以同時包含靜態值和從狀態輸入中選取的值。
+ （選用） 有些狀態可以選擇**等待任務完成**或**等待回呼**。可用時，您可以選擇下列其中一種[服務整合模式](connect-to-resource.md)：
+ **未選取選項**：Step Functions 將使用[請求回應](connect-to-resource.md#connect-default)整合模式。Step Functions 會等待 HTTP 回應，然後進入下一個狀態。Step Functions 不會等待任務完成。當沒有可用的選項時，狀態將使用此模式。
+ **等待任務完成**：Step Functions 將使用[執行任務 (.sync)](connect-to-resource.md#connect-sync)整合模式。
+ **等待回呼**：Step Functions 將使用[使用任務字符等待回呼](connect-to-resource.md#connect-wait-token)整合模式。
+ （選用） 若要存取工作流程中不同 AWS 帳戶 中設定的資源，Step Functions 會提供[跨帳戶存取](concepts-access-cross-acct-resources.md)。**跨帳戶存取的 IAM 角色**提供以下選項：
+ **提供 IAM 角色 ARN**：指定包含適當資源存取許可的 IAM 角色。這些資源可在目標帳戶中使用，這是您進行跨帳戶呼叫 AWS 帳戶 的 。
+ **從狀態輸入在執行時間取得 IAM 角色 ARN**：在包含 IAM 角色的狀態 JSON 輸入中，指定現有鍵值對的參考路徑。
+ **下一個狀態**可讓您選取要轉換為下一個狀態的狀態。
+ （選用） **註解**欄位不會影響工作流程，但您可以使用它來註釋工作流程。
有些狀態會有額外的一般組態選項。例如，Amazon ECS `RunTask` 狀態組態包含填入預留位置值`API Parameters`的欄位。對於這些狀態，您可以將預留位置值取代為符合您需求的組態。
**刪除狀態**
您可以按下退格鍵，按一下滑鼠右鍵並選擇**刪除狀態**，或在[設計工具列](workflow-studio.md#wfs-interface-design-mode)上選擇**刪除**。
## 執行您的工作流程
當您的工作流程準備就緒時，您可以執行它，並從 [Step Functions 主控台](https://console.aws.amazon.com/states/home)檢視其執行。
**在 Workflow Studio 中執行工作流程**
1. 在**設計**、**程式碼**或**組態**模式中，選擇**執行。**
**開始執行**對話方塊會在新索引標籤中開啟。
1. 在**啟動執行**對話方塊中，執行下列動作：
1. （選用） 輸入自訂執行名稱以覆寫產生的預設值。
**非 ASCII 名稱和記錄**
Step Functions 接受包含非 ASCII 字元的狀態機器、執行、活動和標籤名稱。由於這類字元會阻止 Amazon CloudWatch 記錄資料，因此我們建議您僅使用 ASCII 字元，以便您可以追蹤 Step Functions 指標。
1. （選用） 在**輸入**方塊中，輸入 JSON 格式的輸入值來執行工作流程。
1. 選擇 **Start execution (開始執行)**。
1. Step Functions 主控台會引導您前往標題為執行 ID 的頁面，稱為*執行詳細資訊*頁面。您可以在工作流程進行和完成後檢閱執行結果。
若要檢閱執行結果，請在**圖形檢視**中選擇個別狀態，然後選擇[步驟詳細資訊](concepts-view-execution-details.md#exec-details-intf-step-details)窗格上的個別標籤，分別檢視每個狀態的詳細資訊，包括輸入、輸出和定義。如需您可以在執行詳細資訊頁面上檢視之*執行資訊的詳細資訊*，請參閱 [執行詳細資訊概觀](concepts-view-execution-details.md#exec-details-interface-overview)。
## 編輯您的工作流程
您可以在 Workflow Studio [設計模式](workflow-studio.md#wfs-interface-design-mode) 的 中以視覺化方式編輯現有的工作流程。
在 [Step Functions 主控台](https://console.aws.amazon.com/states/home)中，從**狀態機器**頁面選擇您要編輯的工作流程。工作流程會在 Workflow Studio **的設計**模式中開啟。
您也可以在 中編輯工作流程定義[程式碼模式](workflow-studio.md#wfs-interface-code-mode)。選擇**程式碼**按鈕以檢視或編輯工作流程 Studio 中的工作流程定義。
**注意**
如果您在工作流程中看到錯誤，則必須在**設計**模式中修正這些錯誤。如果您的工作流程中存在任何錯誤，則無法切換到**程式碼**或**組態**模式。
當您儲存工作流程的變更時，您也可以選擇發佈新**版本**。使用 版本，您可以選擇執行工作流程的原始或替代版本。若要進一步了解如何使用 版本管理工作流程，請參閱 [Step Functions 工作流程中的狀態機器版本](concepts-state-machine-version.md)
## 匯出您的工作流程
您可以匯出工作流程的 [Amazon States Language](concepts-amazon-states-language.md)(ASL) 定義和工作流程圖表：
1. 在 [Step Functions 主控台](https://console.aws.amazon.com/states/home)中選擇您的工作流程。
1. 在*狀態機器詳細資訊*頁面上，選擇**編輯**。
1. 選擇**動作**下拉式選單按鈕，然後執行下列其中一項或兩項操作：
+ 若要將工作流程圖表匯出至 SVG 或 PNG 檔案，請在**匯出圖表**下選取您想要的格式。
+ 若要將工作流程定義匯出為 JSON 或 YAML 檔案，請在**匯出定義**下，選取您想要的格式。
## 使用預留位置建立工作流程原型
您可以在 中使用 Workflow Studio 或 [Workflow Studio Infrastructure Composer](use-wfs-in-app-composer.md) 來建立新工作流程的原型，其中包含名為尚不存在之資源的*預留位置資源*。
若要建立工作流程原型：
1. 登入 [Step Functions 主控台](https://console.aws.amazon.com/states/home?region=us-east-1#/)。
1. 選擇 **Create state machine (建立狀態機器)**。
1. 選擇**從空白建立**。
1. 為您的狀態機器命名，然後選擇**繼續**在 Workflow Studio 中編輯您的狀態機器。
1. Workflow Studio [的設計模式](workflow-studio.md#wfs-interface-design-mode)隨即開啟。在 Workflow Studio 中設計您的工作流程。若要包含預留位置資源：
1. 選擇您要包含預留位置資源的狀態，然後在**組態**中：
+ 對於 Lambda 調用狀態，選擇**函數名稱**，然後選擇**輸入函數名稱**。您也可以輸入函數的自訂名稱。
+ 針對 Amazon SQS 傳送訊息狀態，選擇**佇列 URL**，然後選擇**輸入佇列 URL**。輸入預留位置佇列 URL。
+ 對於 Amazon SNS 發佈狀態，從**主題**中選擇主題 ARN。
+ 對於**動作**下列出的所有其他狀態，您可以使用預設組態。
**注意**
如果您在工作流程中看到錯誤，則必須在**設計**模式中修正這些錯誤。如果您的工作流程中存在任何錯誤，則無法切換到**程式碼**或**組態**模式。
1. （選用） 若要檢視工作流程的自動產生 ASL 定義，請選擇**定義**。
1. （選用） 若要更新 Workflow Studio 中的工作流程定義，請選擇**程式碼**按鈕。
**注意**
如果您在工作流程定義中看到錯誤，則必須在**程式碼**模式中修正錯誤。如果您的工作流程定義中存在任何錯誤，則無法切換到**設計**或**組態**模式。
1. （選用） 若要編輯狀態機器名稱，請選擇 **MyStateMachine** 預設狀態機器名稱旁的編輯圖示，然後在**狀態機器名稱**方塊中指定名稱。
您也可以切換到 [組態模式](workflow-studio.md#wfs-interface-config-mode)來編輯預設狀態機器名稱。
1. 指定您的工作流程設定，例如狀態機器類型及其執行角色。
1. 選擇**建立**。
您現在已使用可用於原型的預留位置資源建立新的工作流程。您可以[匯出](#workflow-studio-components-create-export)工作流程定義和工作流程圖表。
+ 若要將您的工作流程定義匯出為 JSON 或 YAML 檔案，請在**設計**或**程式碼**模式中，選擇**動作**下拉式選單按鈕。然後，在**匯出定義**下，選取您要匯出的格式。您可以使用此匯出的定義做為透過 進行本機開發的起點[AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/building-stepfunctions.html)。
+ 若要將工作流程圖表匯出至 SVG 或 PNG 檔案，請在**設計**或**程式碼**模式中，選擇**動作**下拉式選單按鈕。然後，在**匯出定義**下，選取您想要的格式。
# 在 Step Functions 中使用 Workflow Studio 設定狀態輸入和輸出
**管理狀態和轉換資料**
了解如何[使用變數在狀態與使用 JSONata 轉換資料之間傳遞資料](workflow-variables.md)。 [ JSONata](transforming-data.md)
每個狀態都會根據收到的輸入做出決策或執行動作。在大多數情況下，它會將輸出傳遞至其他狀態。在 Workflow Studio 中，您可以設定狀態在[Inspector 面板](workflow-studio.md#workflow-studio-components-formdefinition)面板的輸入和輸出索引標籤中篩選和操作其**輸入**和**輸出**資料的方式。設定輸入和輸出時，請使用**資訊**連結來存取內容說明。
![\[顯示狀態輸入、輸出和資訊說明面板的說明螢幕擷取畫面\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/wfs_input_output_01.png)
如需 Step Functions 如何處理輸入和輸出的詳細資訊，請參閱 [在 Step Functions 中處理輸入和輸出](concepts-input-output-filtering.md)。
## 將輸入設定為 狀態
每個狀態都會以 JSON 的形式接收先前狀態的輸入。如果您想要篩選輸入，您可以使用[Inspector 面板](workflow-studio.md#workflow-studio-components-formdefinition)面板中**輸入**索引標籤下的`InputPath`篩選條件。`InputPath` 是以 開頭的字串`$`，可識別特定的 JSON 節點。這些稱為[參考路徑](amazon-states-language-paths.md)，它們遵循 JsonPath 語法。
若要篩選輸入：
+ 選擇**使用 InputPath 篩選輸入**。
+ 輸入`InputPath`篩選條件的有效 [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)。例如 **\$1.data**。
您的`InputPath`篩選條件將新增至您的工作流程。
**Example 範例 1：在 Workflow Studio 中使用 InputPath 篩選條件**
假設您狀態的輸入包含下列 JSON 資料。
```
{
"comment": "Example for InputPath",
"dataset1": {
"val1": 1,
"val2": 2,
"val3": 3
},
"dataset2": {
"val1": "a",
"val2": "b",
"val3": "c"
}
}
```
若要套用`InputPath`篩選條件，請選擇**使用 InputPath 篩選輸入**，然後輸入適當的參考路徑。如果您輸入 **\$1.dataset2.val1**，則會將下列 JSON 做為輸入傳遞至 狀態。
```
{"a"}
```
參考路徑也可以有一系列的值。如果您參考的資料是 ，`{ "a": [1, 2, 3, 4] }`而您套用參考路徑`$.a[0:2]` 做為`InputPath`篩選條件，則結果如下。
```
[ 1, 2 ]
```
[平行工作流程狀態](state-parallel.md)[映射工作流程狀態](state-map.md)、 和 [傳遞工作流程狀態](state-pass.md)流程狀態在其輸入索引標籤`Parameters`下有一個名為 的額外**輸入**篩選選項。此篩選條件在 InputPath 篩選條件之後生效，可用於建構由一或多個鍵值對組成的自訂 JSON 物件。每個對的值可以是靜態值、可以從輸入中選取，也可以從[從 Step Functions 中的內容物件存取執行資料](input-output-contextobject.md)具有路徑的 中選取。
**注意**
若要指定參數使用參考路徑指向輸入中的 JSON 節點，參數名稱必須以 結尾`.$`。
**Example 範例 2：建立平行狀態的自訂 JSON 輸入**
假設下列 JSON 資料是平行狀態的輸入。
```
{
"comment": "Example for Parameters",
"product": {
"details": {
"color": "blue",
"size": "small",
"material": "cotton"
},
"availability": "in stock",
"sku": "2317",
"cost": "$23"
}
}
```
若要選取此輸入的一部分並傳遞具有靜態值的其他鍵值對，您可以在**平行**狀態的**輸入**索引標籤下的**參數**欄位中指定下列項目。
```
{
"comment": "Selecting what I care about.",
"MyDetails": {
"size.$": "$.product.details.size",
"exists.$": "$.product.availability",
"StaticValue": "foo"
}
}
```
以下 JSON 資料將成為結果。
```
{
"comment": "Selecting what I care about.",
"MyDetails": {
"size": "small",
"exists": "in stock",
"StaticValue": "foo"
}
}
```
## 設定狀態的輸出
每個狀態都會產生可在傳遞至下一個狀態之前進行篩選的 JSON 輸出。有數個可用的篩選條件，每個篩選條件都會以不同的方式影響輸出。每個狀態可用的輸出篩選條件會列在 **Inspector **面板的**輸出**索引標籤下。對於[任務工作流程狀態](state-task.md)狀態，您選取的任何輸出篩選條件都會依此順序處理：
1. `ResultSelector`：使用此篩選條件來操作狀態的結果。您可以使用部分結果建構新的 JSON 物件。
1. `在 Step Functions 中使用 ResultPath 指定狀態輸出`：使用此篩選條件來選取要傳遞至輸出的狀態輸入和任務結果的組合。
1. `使用 OutputPath 篩選狀態輸出`：使用此篩選條件篩選 JSON 輸出，以從結果中選擇哪些資訊將傳遞至下一個狀態。
### 使用 ResultSelector
`ResultSelector` 是下列狀態的選用輸出篩選條件：
+ [任務工作流程狀態](state-task.md) 狀態，這些狀態都列在 **的動作**索引標籤中[狀態瀏覽器](workflow-studio.md#workflow-studio-components-states)。
+ [映射工作流程狀態](state-map.md) 狀態，在狀態瀏覽器的流程****索引標籤中。
+ [平行工作流程狀態](state-parallel.md) 狀態，在狀態瀏覽器的流程****索引標籤中。
`ResultSelector` 可用來建構由一或多個鍵值對組成的自訂 JSON 物件。每個對的值可以是靜態值，或從具有路徑的狀態結果中選取。
**注意**
若要指定參數使用路徑來參考結果中的 JSON 節點，參數名稱必須以 結尾`.$`。
**Example 使用 ResultSelector 篩選條件的範例**
在此範例中，您會使用 從 Amazon EMR CreateCluster API 呼叫`ResultSelector`操作 Amazon EMR `CreateCluster` 狀態的回應。以下是 Amazon EMR `CreateCluster` API 呼叫的結果。
```
{
"resourceType": "elasticmapreduce",
"resource": "createCluster.sync",
"output": {
"SdkHttpMetadata": {
"HttpHeaders": {
"Content-Length": "1112",
"Content-Type": "application/x-amz-JSON-1.1",
"Date": "Mon, 25 Nov 2019 19:41:29 GMT",
"x-amzn-RequestId": "1234-5678-9012"
},
"HttpStatusCode": 200
},
"SdkResponseMetadata": {
"RequestId": "1234-5678-9012"
},
"ClusterId": "AKIAIOSFODNN7EXAMPLE"
}
}
```
若要選取此資訊的一部分，並傳遞具有靜態值的額外鍵值對，請在狀態的**輸出**索引標籤下的 **ResultSelector** 欄位中指定下列項目。
```
{
"result": "found",
"ClusterId.$": "$.output.ClusterId",
"ResourceType.$": "$.resourceType"
}
```
使用 `ResultSelector`會產生下列結果。
```
{
"result": "found",
"ClusterId": "AKIAIOSFODNN7EXAMPLE",
"ResourceType": "elasticmapreduce"
}
```
### 使用 ResultPath
狀態的輸出可以是其輸入的副本、其產生的結果，或其輸入和結果的組合。使用 `ResultPath` 以控制哪些組合會傳遞至狀態輸出。如需 的更多使用案例`ResultPath`，請參閱 [在 Step Functions 中使用 ResultPath 指定狀態輸出](input-output-resultpath.md)。
`ResultPath` 是下列狀態的選用輸出篩選條件：
+ [任務工作流程狀態](state-task.md) 狀態，這些狀態都列在狀態瀏覽器**的動作**索引標籤中。
+ [映射工作流程狀態](state-map.md) 狀態，在狀態瀏覽器的流程****索引標籤中。
+ [平行工作流程狀態](state-parallel.md) 狀態，在狀態瀏覽器的流程****索引標籤中。
+ [傳遞工作流程狀態](state-pass.md) 狀態，在狀態瀏覽器的流程****索引標籤中。
`ResultPath` 可用來將結果新增至原始狀態輸入。指定的路徑會指出新增結果的位置。
**Example 使用 ResultPath 篩選條件的範例**
假設以下是任務狀態的輸入。
```
{
"details": "Default example",
"who": "AWS Step Functions"
}
```
任務狀態的結果如下。
```
Hello, AWS Step Functions
```
您可以將此結果新增至狀態的輸入，方法是套用`ResultPath`並輸入參考[路徑](amazon-states-language-paths.md)，指出新增結果的位置，例如 `$.taskresult`：
使用此 `ResultPath`，以下是做為狀態輸出傳遞的 JSON。
```
{
"details": "Default example",
"who": "AWS Step Functions",
"taskresult": "Hello, AWS Step Functions!"
}
```
### 使用 OutputPath
`OutputPath` 篩選條件可讓您篩選掉不需要的資訊，並只傳遞您需要的 JSON 部分。`OutputPath` 是以 開頭的字串`$`，可識別 JSON 文字中的節點。
**Example 使用 OutputPath 篩選條件的範例**
假設除了 Lambda 函數的結果之外，Lambda 調用 API 呼叫還會傳回中繼資料。
```
{
"ExecutedVersion": "$LATEST",
"Payload": {
"foo": "bar",
"colors": [
"red",
"blue",
"green"
],
"car": {
"year": 2008,
"make": "Toyota",
"model": "Matrix"
}
},
"SdkHttpMetadata": {
"AllHttpHeaders": {
"X-Amz-Executed-Version": ["$LATEST"]
...
```
您可以使用 `OutputPath`篩選掉其他中繼資料。根據預設，透過 Workflow Studio 建立之 Lambda 調用狀態的 **OutputPath** 篩選條件值為 `$.Payload`。此預設值會移除其他中繼資料，並傳回相當於直接執行 Lambda 函數的輸出。
Lambda 調用任務結果範例和**輸出**篩選條件`$.Payload`的 值，會傳遞下列 JSON 資料做為輸出。
```
{
"foo": "bar",
"colors": [
"red",
"blue",
"green"
],
"car": {
"year": 2008,
"make": "Toyota",
"model": "Matrix"
}
}
```
`OutputPath` 篩選條件是最後一個要生效的輸出篩選條件，因此如果您使用其他輸出篩選條件，例如 `ResultSelector`或 `ResultPath`，您應該相應地修改`OutputPath`篩選條件`$.Payload`的預設值 。
# 在 Step Functions 中使用 Workflow Studio 設定執行角色
您可以使用 Workflow Studio 為您的工作流程設定執行角色。每個Step Functions狀態機器都需要一個 AWS Identity and Access Management (IAM) 角色，授予狀態機器對 AWS 服務 和 資源執行動作或呼叫 HTTPS APIs許可。此角色稱為*執行角色*。
執行角色必須包含每個動作IAM的政策，例如允許狀態機器叫用 AWS Lambda函數、執行AWS Batch任務或呼叫 Stripe API 的政策。 在下列情況下， Step Functions會要求您提供執行角色：
+ 您可以在主控台、 AWS SDKs AWS CLI 或使用 [CreateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html) API 建立狀態機器。
+ 您可以在主控台、 AWS SDKsAWS CLI或使用 [TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html) API [測試](test-state-isolation.md)狀態。
**Topics**
+ [關於自動產生的角色](#wfs-auto-gen-roles)
+ [自動產生角色](#auto-generating-roles)
+ [解決角色產生問題](#resolve-role-gen-problem)
+ [在 Workflow Studio 中測試 HTTP 任務的角色](#test-state-role-http)
+ [在 Workflow Studio 中測試最佳化服務整合的角色](#test-state-role-optimized)
+ [在 Workflow Studio 中測試 AWS SDK 服務整合的角色](#test-state-role-aws-sdk)
+ [在 Workflow Studio 中測試流程狀態的角色](#test-state-role-flow)
## 關於自動產生的角色
當您在Step Functions主控台中建立狀態機器時，[Workflow Studio](workflow-studio.md) 可以自動為您建立包含必要IAM政策的執行角色。Workflow Studio 會分析您的狀態機器定義，並產生具有執行工作流程所需最低權限的政策。
Workflow Studio 可以為下列項目產生IAM政策：
+ 呼叫 HTTPS APIs [HTTP 任務](call-https-apis.md)。
+ 任務狀態 AWS 服務 會使用[最佳化整合](integrate-optimized.md)呼叫其他 ，例如 [Lambda Invoke](connect-lambda.md)、[DynamoDBGetItem](connect-batch.md) 或 [AWS Glue StartJobRun](connect-glue.md)。
+ 執行[巢狀工作流程](connect-stepfunctions.md)的任務狀態。
+ [分散式映射狀態](state-map-distributed.md)，包括啟動子工作流程執行、列出Amazon S3儲存貯體和讀取或寫入 S3 物件[的政策](iam-policies-eg-dist-map.md)。
+ [X-Ray](concepts-xray-tracing.md) 追蹤。在 Workflow Studio 中自動產生的每個角色都包含一個政策，該[政策](concepts-xray-tracing.md#xray-iam)會授予狀態機器將追蹤傳送至 的許可X-Ray。
+ [使用 CloudWatch Logs 在 Step Functions 中記錄執行歷史記錄](cw-logs.md) 在狀態機器上啟用記錄時。
Workflow Studio 無法為 AWS 服務 使用 [AWS SDK 整合](supported-services-awssdk.md)呼叫其他 的任務狀態產生IAM政策。
## 自動產生角色
1. 開啟 [Step Functions 主控台](https://console.aws.amazon.com/states/home)，從功能表中選擇**狀態機器**，然後選擇**建立狀態機器**。
您也可以更新現有的狀態機器。如果您要更新狀態機器，請參閱步驟 4。
1. 選擇**從空白建立**。
1. 為您的狀態機器命名，然後選擇**繼續**在 Workflow Studio 中編輯您的狀態機器。
1. 選擇 **Config** 索引標籤。
1. 向下捲動至**許可**區段，然後執行下列動作：
1. 針對**執行角色**，請確定您保留**建立新角色**的預設選擇。
Workflow Studio 會自動為狀態機器定義中的每個有效狀態產生所有必要IAM的政策。它會在 中顯示含有訊息的橫幅，**系統會建立具有完整許可的執行角色。**
![\[Config 索引標籤的說明性螢幕擷取畫面，其中包含自動產生的許可預覽。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/wfs-full-permissions-role.png)
**提示**
若要檢閱 Workflow Studio 自動為狀態機器產生的許可，請選擇**檢閱自動產生的許可**。
**注意**
如果您刪除 Step Functions 建立的 IAM 角色，Step Functions 稍後無法重新建立該角色。同樣地，如果您修改角色 （例如，從 IAM 政策中的主體移除 Step Functions)，Step Functions 稍後無法還原其原始設定。
如果 Workflow Studio 無法產生所有必要IAM的政策，則會顯示橫幅，其中包含**無法自動產生特定動作的許可訊息。只會建立具有部分許可IAM的角色。**如需如何新增缺少許可的資訊，請參閱 [解決角色產生問題](#resolve-role-gen-problem)。
1. 如果您要**建立**狀態機器，請選擇建立。否則，請選擇 **Save (儲存)**。
1. 在出現的對話方塊中選擇**確認**。
Workflow Studio 會儲存您的狀態機器，並建立新的執行角色。
## 解決角色產生問題
在下列情況下，Workflow Studio 無法自動產生具有所有必要許可的執行角色：
+ 狀態機器中發生錯誤。請務必解決 Workflow Studio 中的所有驗證錯誤。此外，請確定您已解決儲存過程中遇到的任何伺服器端錯誤。
+ 您的狀態機器包含使用 AWS SDK 整合的任務。在這種情況下，Workflow Studio [無法自動產生](#auto-generating-roles)IAM政策。Workflow Studio 會顯示含有訊息的橫幅，**無法自動產生特定動作的許可。只會建立具有部分許可IAM的角色。**在**檢閱自動產生的許可**表中，選擇**狀態**中的內容，以取得有關執行角色遺失政策的詳細資訊。Workflow Studio 仍然可以產生執行角色，但此角色不會包含所有動作IAM的政策。請參閱**文件連結下方的連結**，以撰寫您自己的政策，並在產生後將其新增至角色。即使在您儲存狀態機器之後，仍可使用這些連結。
## 在 Workflow Studio 中測試 HTTP 任務的角色
[測試](call-https-apis.md#http-task-test) HTTP 任務狀態需要 執行角色。如果您沒有具有足夠許可的角色，請使用下列其中一個選項來建立角色：
+ **使用 Workflow Studio 自動產生角色 （建議）** – 這是安全選項。關閉**測試狀態**對話方塊，並遵循 中的指示[自動產生角色](#auto-generating-roles)。這需要您先建立或更新狀態機器，然後返回 Workflow Studio 以測試您的狀態。
+ **使用具有管理員存取權的角色** – 如果您有權建立具有 中所有服務和資源完整存取權的角色 AWS，您可以使用該角色在工作流程中測試任何類型的狀態。若要這樣做，您可以在IAM主控台 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 中建立Step Functions服務角色，並將 [AdministratorAccess 政策](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator)新增至該角色。
## 在 Workflow Studio 中測試最佳化服務整合的角色
呼叫[最佳化服務整合](integrate-optimized.md)的任務狀態需要 執行角色。如果您沒有具有足夠許可的角色，請使用下列其中一個選項來建立角色：
+ **使用 Workflow Studio 自動產生角色 （建議）** – 這是安全選項。關閉**測試狀態**對話方塊，並遵循 中的指示[自動產生角色](#auto-generating-roles)。這需要您先建立或更新狀態機器，然後返回 Workflow Studio 以測試您的狀態。
+ **使用具有管理員存取權的角色** - 如果您有權建立具有 中所有服務和資源完整存取權的角色 AWS，您可以使用該角色來測試工作流程中的任何類型的狀態。若要這樣做，您可以建立Step Functions服務角色，並將 [AdministratorAccess 政策](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator)新增至IAM主控台 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)。
## 在 Workflow Studio 中測試 AWS SDK 服務整合的角色
呼叫 [AWS SDK 整合](supported-services-awssdk.md)的任務狀態需要 執行角色。如果您沒有具有足夠許可的角色，請使用下列其中一個選項來建立角色：
+ **使用 Workflow Studio 自動產生角色 （建議）** – 這是安全選項。關閉**測試狀態**對話方塊，並遵循 中的指示[自動產生角色](#auto-generating-roles)。這需要您先建立或更新狀態機器，然後返回 Workflow Studio 以測試您的狀態。請執行下列操作：
1. 關閉**測試狀態**對話方塊
1. 選擇 **Config** 索引標籤以檢視 Config 模式。
1. 向下捲動至**許可**區段。
1. Workflow Studio 會顯示含有訊息的橫幅，**無法自動產生特定動作的許可。只會建立具有部分許可IAM的角色。**選擇**檢閱自動產生的許可**。
1. **檢閱自動產生的許可**表會顯示一列，顯示與您要測試的任務狀態對應的動作。請參閱 **文件連結下的連結**，將您自己的IAM政策寫入自訂角色。
+ **使用具有管理員存取權的角色** - 如果您有權建立具有 中所有服務和資源完整存取權的角色 AWS，您可以使用該角色來測試工作流程中任何類型的狀態。若要這樣做，您可以在IAM主控台 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 中建立Step Functions服務角色，並將 [AdministratorAccess 政策](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator)新增至該角色。
## 在 Workflow Studio 中測試流程狀態的角色
您需要執行角色，才能在 Workflow Studio 中測試流程狀態。流程狀態是直接執行流程的狀態，例如 [選擇工作流程狀態](state-choice.md)、、[平行工作流程狀態](state-parallel.md)[映射工作流程狀態](state-map.md)、[傳遞工作流程狀態](state-pass.md)[等待工作流程狀態](state-wait.md)、[工作流程狀態成功](state-succeed.md)、 或 [失敗的工作流程狀態](state-fail.md)。[TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html) API 不適用於映射或平行狀態。使用下列其中一個選項來建立角色以測試流程狀態：
+ **在您的 AWS 帳戶 （建議） 中使用任何角色** – 流程狀態不需要任何特定IAM政策，因為它們不會呼叫 AWS 動作或資源。因此，您可以使用 中的任何IAM角色 AWS 帳戶。
1. 在**測試狀態**對話方塊中，從**執行角色下拉式清單中選取任何角色**。
1. 如果下拉式清單中沒有顯示任何角色，請執行下列動作：
1. 在IAM主控台 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 中，選擇**角色**。
1. 從清單中選擇角色，然後從角色詳細資訊頁面複製其 ARN。您將需要在**測試狀態**對話方塊中提供此 ARN。
1. 在**測試狀態**對話方塊中，從**執行****角色下拉式清單中選取輸入角色 ARN**。
1. 在**角色 ARN 中貼上 ARN**。
+ **使用具有管理員存取權的角色** – 如果您有權建立具有 中所有服務和資源完整存取權的角色 AWS，您可以使用該角色來測試工作流程中任何類型的狀態。若要這樣做，您可以建立Step Functions服務角色，並在IAM主控台 https：//[https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) 中新增 [AdministratorAccess 政策](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator)。
# 在 Step Functions 中使用 Workflow Studio 設定錯誤處理
**管理狀態和轉換資料**
了解如何[使用變數在狀態與使用 JSONata 轉換資料之間傳遞資料](workflow-variables.md)。 [ JSONata](transforming-data.md)
您可以在 Workflow Studio 視覺化編輯器中設定錯誤處理。根據預設，當狀態報告錯誤時，Step Functions 會導致工作流程執行完全失敗。對於動作和某些流程狀態，您可以設定 Step Functions 如何處理錯誤。
即使您已設定錯誤處理，某些錯誤仍可能導致工作流程執行失敗。如需詳細資訊，請參閱[處理 Step Functions 工作流程中的錯誤](concepts-error-handling.md)。在 Workflow Studio 中，在 的錯誤處理索引標籤中設定**錯誤處理**[Inspector 面板](workflow-studio.md#workflow-studio-components-formdefinition)。
## 發生錯誤時重試
您可以在動作狀態和[平行工作流程狀態](state-parallel.md)流程狀態中新增一或多個規則，以便在發生錯誤時重試任務。這些規則稱為*重試器*。若要新增重試器，請在**重試器 \$11** 方塊中選擇編輯圖示，然後設定其選項：
+ （選用） 在**註解**欄位中，新增您的註解。它不會影響工作流程，但可用於註釋工作流程。
+ 將游標放在**錯誤**欄位中，然後選擇會觸發重試器的錯誤，或輸入自訂錯誤名稱。您可以選擇或新增多個錯誤。
+ （選用） 設定**間隔**。這是 Step Functions 進行第一次重試之前的秒數。其他重試將按照您可以使用**最大嘗試次數**和**退避率**設定的間隔進行。
+ （選用） 設定**最大嘗試**次數。這是 Step Functions 導致執行失敗前的重試次數上限。
+ （選用） 設定**退避率**。這是乘數，取決於每次嘗試的重試間隔將增加多少。
**注意**
並非所有錯誤處理選項都適用於所有狀態。Lambda 調用預設會設定一個重試器。
## 捕捉錯誤
您可以將一或多個規則新增至動作狀態，以及新增至 [平行工作流程狀態](state-parallel.md)和 [映射工作流程狀態](state-map.md) 流程狀態以擷取錯誤。這些規則稱為*捕捉器*。若要新增擷取器，請選擇**新增擷取器**，然後設定其選項：
+ （選用） 在**註解**欄位中，新增您的註解。它不會影響工作流程，但可用於註釋工作流程。
+ 將游標放在**錯誤**欄位中，然後選擇會觸發擷取器的錯誤，或輸入自訂錯誤名稱。您可以選擇或新增多個錯誤。
+ 在**備用狀態**欄位中，選擇[備用狀態](concepts-error-handling.md#error-handling-fallback-states)。這是在發現錯誤之後，工作流程將移至下一個狀態。
+ （選用） 在 **ResultPath** 欄位中，新增`ResultPath`篩選條件以將錯誤新增至原始狀態輸入。[`ResultPath`](input-output-resultpath.md) 必須是有效的 [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)。這將傳送至備用狀態。
## 逾時
您可以設定動作狀態的逾時，以設定狀態在失敗前可執行的秒數上限。使用逾時來防止執行停滯。若要設定逾時，請輸入狀態在執行失敗之前應等待的秒數。如需逾時的詳細資訊，請參閱 `TimeoutSeconds` [任務工作流程狀態](state-task.md) 狀態。
## HeartbeatSeconds
您可以設定任務傳送的*活動訊號*或定期通知。如果您設定活動訊號間隔，且狀態未以設定的間隔傳送活動訊號通知，則任務會標示為失敗。若要設定活動訊號，請設定正非零整數秒數。如需詳細資訊，請參閱 `HeartBeatSeconds` [任務工作流程狀態](state-task.md) 狀態。
# 在 中使用 Workflow Studio Infrastructure Composer 來建置 Step Functions 工作流程
中的 Workflow Studio 可協助您Infrastructure Composer設計和建置工作流程。中的 Workflow Studio Infrastructure Composer 提供視覺化基礎設施即程式碼 (IaC) 環境，可讓您輕鬆地將工作流程納入使用 IaC 工具建置的無伺服器應用程式中，例如 CloudFormation 範本。
AWS Infrastructure Composer 是一種視覺化建置器，可協助您使用簡單的圖形界面開發 AWS SAM和 AWS CloudFormation 範本。使用 Infrastructure Composer，您可以透過在視覺化畫布 AWS 服務 中拖曳、分組和連線來設計應用程式架構。 Infrastructure Composer 接著， 會從設計中建立 IaC 範本，您可以使用 AWS SAM命令列界面 (AWS SAM CLI) 或 來部署應用程式CloudFormation。若要進一步了解 Infrastructure Composer，請參閱[什麼是 Infrastructure Composer](https://docs.aws.amazon.com/application-composer/latest/dg/what-is-composer.html)。
當您在 中使用 Workflow Studio 時Infrastructure Composer， Infrastructure Composer 會將個別工作流程步驟連線至 AWS 資源，並在 AWS SAM 範本中產生資源組態。 Infrastructure Composer也會新增工作流程執行所需的IAM許可。在 中使用 Workflow StudioInfrastructure Composer，您可以建立應用程式的原型，並將其轉換為生產就緒的應用程式。
在 中使用 Workflow Studio 時Infrastructure Composer，您可以在Infrastructure Composer畫布和 Workflow Studio 之間來回切換。
**Topics**
+ [在 中使用 Workflow Studio Infrastructure Composer](#procedure-use-wfs-in-app-composer)
+ [使用CloudFormation定義替換動態參考資源](#use-cfn-sub-edit-state-machine-resource)
+ [將服務整合任務連接到增強型元件卡](#connect-service-integrations-enhanced-cards)
+ [匯入現有專案並在本機同步](#import-projects-local-sync)
+ [將 Step Functions 工作流程直接匯出至 AWS Infrastructure Composer](#export-wsf-projects-into-app-composer)
+ [中的無法使用 Workflow Studio 功能 AWS Infrastructure Composer](#wfs-features-unavailable-app-composer)
## 在 中使用 Workflow Studio Infrastructure Composer建置無伺服器工作流程
1. 開啟 [Infrastructure Composer 主控台](https://console.aws.amazon.com/composer/home)，然後選擇**建立專案**以建立專案。
1. 在**資源**面板的搜尋欄位中，輸入 **state machine**。
1. 將**Step Functions狀態機器**資源拖曳到畫布上。
1. 在 **Workflow Studio 中選擇編輯**，以編輯您的狀態機器資源。
下列動畫說明如何切換到 Workflow Studio 來編輯狀態機器定義。
![\[說明如何在 中使用 Workflow Studio 的動畫Infrastructure Composer。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/use-wfs-in-app-composer.gif)
與 Workflow Studio 整合以編輯在 中建立的狀態機器資源Infrastructure Composer僅適用於 [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-statemachine.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-statemachine.html) 資源。此整合不適用於使用 [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html) 資源的範本。
## 在 Workflow Studio 中使用CloudFormation定義替換動態參考資源
在工作流程 Studio 中，您可以在工作流程定義中使用CloudFormation定義替換來動態參考您在 IaC 範本中定義的資源。您可以使用 `${dollar_sign_brace}` 表示法將預留位置替換新增至工作流程定義，並在CloudFormation堆疊建立過程中將其替換為實際值。如需定義替換的詳細資訊，請參閱 [AWS SAM 範本中的 DefinitionSubstitutions](concepts-sam-sfn.md#sam-definition-substitution-eg)。
下列動畫顯示如何為狀態機器定義中的資源新增預留位置替換。
![\[動畫顯示如何為狀態機器中的資源新增預留位置替換。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/use-def-sub-wfs-app-composer.gif)
## 將服務整合任務連接到增強型元件卡
您可以將呼叫[最佳化服務整合](integrate-optimized.md)的任務連接到Infrastructure Composer畫布中的[增強型元件卡](https://docs.aws.amazon.com/application-composer/latest/dg/reference-cards.html#reference-cards-enhanced-components)。這樣做會自動映射工作流程定義中`${dollar_sign_brace}`符號所指定的任何預留位置替換，以及`StateMachine`資源的 `DefinitionSubstitution` 屬性。它也會為狀態機器新增適當的AWS SAM政策。
如果您使用[標準元件卡](https://docs.aws.amazon.com/application-composer/latest/dg/using-composer-cards.html#using-composer-cards-component-intro)映射最佳化的服務整合任務，則連線列不會出現在Infrastructure Composer畫布上。
下列動畫說明如何將最佳化任務連線至增強型元件卡，並檢視 [https://docs.aws.amazon.com/application-composer/latest/dg/using-change-inspector.html](https://docs.aws.amazon.com/application-composer/latest/dg/using-change-inspector.html) 中的變更。
![\[顯示如何連接任務和最佳化服務整合的動畫。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/make-connections-wfs-app-composer.gif)
您無法將任務狀態[AWS 的 SDK 整合](supported-services-awssdk.md)與增強型元件卡連線，也無法將最佳化的服務整合與標準元件卡連線。對於這些任務，您可以在Infrastructure Composer畫布的資源**屬性**面板中映射替代項目，並在AWS SAM範本中新增政策。
**提示**
或者，您也可以在**資源屬性**面板中的**定義替代下，映射狀態機器的預留位置替代**。當您執行此操作時，您必須在狀態機器執行角色中新增 AWS 服務 任務狀態呼叫所需的許可。如需執行角色可能需要之許可的相關資訊，請參閱 [在 Step Functions 中使用 Workflow Studio 設定執行角色](manage-state-machine-permissions.md)。
下列動畫說明如何在**資源屬性**面板中手動更新預留位置替換映射。
![\[動畫顯示如何在資源屬性面板中更新預留位置替換映射。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/manual-update-placeholder-mapping.gif)
## 匯入現有專案並在本機同步
您可以在 中開啟現有的 CloudFormation和 AWS SAM專案Infrastructure Composer，以視覺化方式呈現這些專案，以便進一步了解和修改其設計。使用 Infrastructure Composer的[本機同步](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html)功能，您可以自動同步範本和程式碼檔案，並將其儲存至本機建置機器。使用本機同步模式可以補充現有的開發流程。請確定您的瀏覽器支援[檔案系統存取 API](https://docs.aws.amazon.com/application-composer/latest/dg/reference-fsa.html)，讓 Web 應用程式讀取、寫入和儲存本機檔案系統中的檔案。我們建議使用 Google Chrome 或 Microsoft Edge。
## 將 Step Functions 工作流程直接匯出至 AWS Infrastructure Composer
AWS Step Functions 主控台可讓您將儲存的狀態機器工作流程匯出為 辨識為進階 IaC 資源的範本Infrastructure Composer。此功能會建立 IaC 範本做為 AWS SAM 結構描述，並引導您前往 Infrastructure Composer。如需詳細資訊，請參閱[將您的工作流程匯出至 IaC 範本](exporting-iac-templates.md)。
## 中的無法使用 Workflow Studio 功能 AWS Infrastructure Composer
當您在 中使用 Workflow Studio 時Infrastructure Composer，某些 Workflow Studio 功能無法使用。此外，[Inspector 面板](workflow-studio.md#workflow-studio-components-formdefinition)面板中可用的 **API 參數**區段支援CloudFormation定義替換。您可以使用 `${dollar_sign_brace}`表示法[程式碼模式](workflow-studio.md#wfs-interface-code-mode)在 中新增替代。如需此表示法的詳細資訊，請參閱 [AWS SAM 範本中的 DefinitionSubstitutions](concepts-sam-sfn.md#sam-definition-substitution-eg)。
下列清單說明當您在 中使用 Workflow Studio 時無法使用的 Workflow Studio 功能Infrastructure Composer：
+ [入門範本](starter-templates.md) – 入門範本是ready-to-run的範例專案，可自動建立工作流程原型和定義。這些範本會將專案所需的所有相關 AWS 資源部署至您的 AWS 帳戶。
+ [Config 模式](workflow-studio.md#wfs-interface-config-mode) – 此模式可讓您管理狀態機器的組態。您可以在 IaC 範本中更新狀態機器組態，或使用Infrastructure Composer畫布中的**資源屬性**面板。如需在**資源屬性**面板中更新組態的詳細資訊，請參閱 [將服務整合任務連接到增強型元件卡](#connect-service-integrations-enhanced-cards)。
+ [TestState](test-state-isolation.md) API
+ 從 Workflow Studio 中的**動作**下拉式清單按鈕匯入或匯出工作流程定義的選項。而是從Infrastructure Composer**功能表中**選取**開啟** > **專案資料夾**。請確定您已啟用[本機同步](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html)模式，以自動將畫Infrastructure Composer布中的變更直接儲存到本機機器。
+ **執行**按鈕。當您在 中使用 Workflow Studio 時Infrastructure Composer， 會為您的工作流程Infrastructure Composer產生 IaC 程式碼。因此，您必須先部署範本。然後，在 主控台或透過 AWS Command Line Interface 執行工作流程(AWS CLI)。
# 使用 AWS SAM 建置 Step Functions 工作流程
您可以使用 AWS Serverless Application Model 搭配 Step Functions 來建置工作流程並部署所需的基礎設施，包括 Lambda 函數、APIs和事件，以建立無伺服器應用程式。
您也可以將 AWS Serverless Application Model CLI 與 搭配使用， AWS Toolkit for Visual Studio Code 做為建置和部署 AWS Step Functions 狀態機器的整合體驗的一部分。您可以使用 建置無伺服器應用程式 AWS SAM，然後在 VS Code IDE 中建置您的狀態機器。然後，您可以驗證、封裝和部署您的 資源。
**提示**
若要部署使用 啟動 Step Functions 工作流程的範例無伺服器應用程式 AWS SAM，請參閱* AWS Step Functions 研討會*中的[使用 部署 AWS SAM](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-sam) 。
## 為什麼搭配 Step Functions 使用 AWS SAM？
當您搭配 Step Functions 使用時 AWS SAM ，您可以：
+ 開始使用 AWS SAM 範例範本。
+ 將您的狀態機器建置到無服務器應用程式中。
+ 在部署時，使用變數替換將 ARNs 取代為您的狀態機器。
AWS CloudFormation 支援 [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html#cfn-stepfunctions-statemachine-definitionsubstitutions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html#cfn-stepfunctions-statemachine-definitionsubstitutions)，可讓您將工作流程定義中的動態參考新增至您在CloudFormation範本中提供的值。您可以使用 `${dollar_sign_brace}` 表示法將替換新增至工作流程定義，以新增動態參考。您也需要在CloudFormation範本中 StateMachine 資源的 `DefinitionSubstitutions` 屬性中定義這些動態參考。這些替換會在CloudFormation堆疊建立過程中以實際值取代。如需詳細資訊，請參閱[AWS SAM 範本中的 DefinitionSubstitutions](#sam-definition-substitution-eg)。
+ 使用 AWS SAM 政策範本指定狀態機器的角色。
+ 使用 API Gateway、EventBridge 事件或 AWS SAM 範本中的排程啟動狀態機器執行。
## Step Functions 與 AWS SAM 規格整合
您可以使用[AWS SAM 政策範本](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html)將許可新增至狀態機器。透過這些許可，您可以協調 Lambda 函數和其他 AWS 資源，以形成複雜且強大的工作流程。
## Step Functions 與 SAM CLI 整合
Step Functions 已與 CLI AWS SAM 整合。使用此功能可將狀態機快速開發為無伺服器應用程式。
嘗試[使用 建立 Step Functions 狀態機器 AWS SAM](tutorial-state-machine-using-sam.md)教學課程，了解如何使用 AWS SAM 來建立狀態機器。
支援的 AWS SAM CLI 函數包括：
| CLI 命令 | Description |
| --- | --- |
| sam init | 使用 AWS SAM 範本初始化無伺服器應用程式。可與 Step Functions 的 SAM 範本搭配使用。 |
| sam validate | 驗證 AWS SAM 範本。 |
| sam package | 封裝 AWS SAM 應用程式。它會建立程式碼和相依項的 ZIP 檔案，然後將其上傳至 Amazon S3。然後它會傳回 AWS SAM 範本的副本，以命令上傳成品的 Amazon S3 位置取代本機成品的參考。 |
| sam deploy | 部署 AWS SAM 應用程式。 |
| sam publish | 將 AWS SAM 應用程式發佈至 AWS Serverless Application Repository。此命令會採用封裝 AWS SAM 範本，並將應用程式發佈至指定的區域。 |
**注意**
使用 AWS SAM 本機時，您可以在本機模擬 Lambda 和 API Gateway。不過，您無法在本機使用 模擬 Step Functions AWS SAM。
## AWS SAM 範本中的 DefinitionSubstitutions
您可以使用 CloudFormation 範本搭配 來定義狀態機器AWS SAM。使用 AWS SAM，您可以定義內嵌在範本或單獨的檔案中的狀態機器。下列AWS SAM範本包含模擬股票交易工作流程的狀態機器。此狀態機器會叫用三個 Lambda 函數來檢查股票的價格，並決定是否要購買或銷售股票。此交易接著會記錄在 Amazon DynamoDB資料表中。下列範本中Lambda函數和DynamoDB資料表ARNs 會使用 指定[https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html#cfn-stepfunctions-statemachine-definitionsubstitutions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html#cfn-stepfunctions-statemachine-definitionsubstitutions)。
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: |
step-functions-stock-trader
Sample SAM Template for step-functions-stock-trader
Resources:
StockTradingStateMachine:
Type: AWS::Serverless::StateMachine
Properties:
DefinitionSubstitutions:
StockCheckerFunctionArn: !GetAtt StockCheckerFunction.Arn
StockSellerFunctionArn: !GetAtt StockSellerFunction.Arn
StockBuyerFunctionArn: !GetAtt StockBuyerFunction.Arn
DDBPutItem: !Sub arn:${AWS::Partition}:states:::dynamodb:putItem
DDBTable: !Ref TransactionTable
Policies:
- DynamoDBWritePolicy:
TableName: !Ref TransactionTable
- LambdaInvokePolicy:
FunctionName: !Ref StockCheckerFunction
- LambdaInvokePolicy:
FunctionName: !Ref StockBuyerFunction
- LambdaInvokePolicy:
FunctionName: !Ref StockSellerFunction
DefinitionUri: statemachine/stock_trader.asl.json
StockCheckerFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: functions/stock-checker/
Handler: app.lambdaHandler
Runtime: nodejs18.x
Architectures:
- x86_64
StockSellerFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: functions/stock-seller/
Handler: app.lambdaHandler
Runtime: nodejs18.x
Architectures:
- x86_64
StockBuyerFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: functions/stock-buyer/
Handler: app.lambdaHandler
Runtime: nodejs18.x
Architectures:
- x86_64
TransactionTable:
Type: AWS::DynamoDB::Table
Properties:
AttributeDefinitions:
- AttributeName: id
AttributeType: S
```
下列程式碼是 檔案中的狀態機器定義`stock_trader.asl.json`，用於[使用 建立 Step Functions 狀態機器 AWS SAM](tutorial-state-machine-using-sam.md)教學課程。此狀態機器定義包含`DefinitionSubstitutions`以 `${dollar_sign_brace}` 表示的數個。例如，`${StockCheckerFunctionArn}`使用替換，而不是為`Check Stock Value`任務指定靜態Lambda函數 ARN。此替換是在 範本的 [DefinitionSubstitutions](#sam-template-def-substitution) 屬性中定義。 `DefinitionSubstitutions` 是狀態機器資源的鍵值對映射。在 中`DefinitionSubstitutions`，\$1\$1StockCheckerFunctionArn\$1 會使用CloudFormation內部函數 對應至`StockCheckerFunction`資源的 ARN[https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getatt.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-getatt.html)。當您部署AWS SAM範本時，範本`DefinitionSubstitutions`中的 會取代為實際值。
```
{
"Comment": "A state machine that does mock stock trading.",
"StartAt": "Check Stock Value",
"States": {
"Check Stock Value": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"OutputPath": "$.Payload",
"Parameters": {
"Payload.$": "$",
"FunctionName": "${StockCheckerFunctionArn}"
},
"Next": "Buy or Sell?"
},
"Buy or Sell?": {
"Type": "Choice",
"Choices": [
{
"Variable": "$.stock_price",
"NumericLessThanEquals": 50,
"Next": "Buy Stock"
}
],
"Default": "Sell Stock"
},
"Buy Stock": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"OutputPath": "$.Payload",
"Parameters": {
"Payload.$": "$",
"FunctionName": "${StockBuyerFunctionArn}"
},
"Retry": [
{
"ErrorEquals": [
"Lambda.ServiceException",
"Lambda.AWSLambdaException",
"Lambda.SdkClientException",
"Lambda.TooManyRequestsException"
],
"IntervalSeconds": 1,
"MaxAttempts": 3,
"BackoffRate": 2
}
],
"Next": "Record Transaction"
},
"Sell Stock": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"OutputPath": "$.Payload",
"Parameters": {
"Payload.$": "$",
"FunctionName": "${StockSellerFunctionArn}"
},
"Next": "Record Transaction"
},
"Record Transaction": {
"Type": "Task",
"Resource": "arn:aws:states:::dynamodb:putItem",
"Parameters": {
"TableName": "${DDBTable}",
"Item": {
"Id": {
"S.$": "$.id"
},
"Type": {
"S.$": "$.type"
},
"Price": {
"N.$": "$.price"
},
"Quantity": {
"N.$": "$.qty"
},
"Timestamp": {
"S.$": "$.timestamp"
}
}
},
"End": true
}
}
}
```
## 後續步驟
您可以進一步了解如何使用 Step Functions AWS SAM 搭配下列資源：
+ 完成[使用 建立 Step Functions 狀態機器 AWS SAM](tutorial-state-machine-using-sam.md)教學課程以使用 建立狀態機器 AWS SAM。
+ 指定 [AWS::Serverless::StateMachine](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-statemachine.html) 資源。
+ 尋找要使用的 [AWS SAM 政策範本](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html)。
+ [AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions.html) 與 Step Functions 搭配使用。
+ 檢閱 [AWS SAM CLI 參考](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html)，進一步了解 中可用的功能 AWS SAM。
您也可以使用視覺化建置器，例如 中的 Workflow Studio，在基礎設施中設計和建置工作流程做為程式碼 (IaC)Infrastructure Composer。如需詳細資訊，請參閱[在 中使用 Workflow Studio Infrastructure Composer 來建置 Step Functions 工作流程](use-wfs-in-app-composer.md)。
# 使用 在 Step Functions 中 CloudFormation 建立工作流程
在本教學課程中，您將使用 建立 AWS Lambda 函數 AWS CloudFormation。您將使用 CloudFormation 主控台和 YAML 範本來建立*堆疊* (IAM 角色、Lambda 函數和狀態機器）。然後，您將使用 Step Functions 主控台來啟動狀態機器執行。
如需詳細資訊，請參閱*AWS CloudFormation 《 使用者指南*`[AWS::StepFunctions::StateMachine](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)`》中的[使用 CloudFormation 範本](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html)和資源。
## 步驟 1：設定您的 CloudFormation 範本
在使用[範例範本](#lambda-state-machine-cfn-step-2)之前，建議您了解如何宣告 CloudFormation 範本的不同部分。
### 建立適用於 Lambda 的 IAM 角色
定義與 Lambda 函數的 IAM 角色相關聯的信任政策。下列範例使用 YAML 或 JSON 定義信任政策。
------
#### [ YAML ]
```
LambdaExecutionRole:
Type: "AWS::IAM::Role"
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: "sts:AssumeRole"
```
------
#### [ JSON ]
```
"LambdaExecutionRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
```
------
### 建立 Lambda 函數
為將列印訊息的 Lambda 函數定義下列屬性`Hello World`。
**重要**
確保您的 Lambda 函數與 AWS 區域 狀態機器位於相同的 AWS 帳戶下。
------
#### [ YAML ]
```
MyLambdaFunction:
Type: "AWS::Lambda::Function"
Properties:
Handler: "index.handler"
Role: !GetAtt [ LambdaExecutionRole, Arn ]
Code:
ZipFile: |
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
};
Runtime: "nodejs12.x"
Timeout: "25"
```
------
#### [ JSON ]
```
"MyLambdaFunction": {
"Type": "AWS::Lambda::Function",
"Properties": {
"Handler": "index.handler",
"Role": {
"Fn::GetAtt": [
"LambdaExecutionRole",
"Arn"
]
},
"Code": {
"ZipFile": "exports.handler = (event, context, callback) => {\n callback(null, \"Hello World!\");\n};\n"
},
"Runtime": "nodejs12.x",
"Timeout": "25"
}
},
```
------
### 為狀態機器執行建立 IAM 角色
定義與狀態機器執行的 IAM 角色相關聯的信任政策。
------
#### [ YAML ]
```
StatesExecutionRole:
Type: "AWS::IAM::Role"
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: "Allow"
Principal:
Service:
- !Sub states.${AWS::Region}.amazonaws.com
Action: "sts:AssumeRole"
Path: "/"
Policies:
- PolicyName: StatesExecutionPolicy
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- "lambda:InvokeFunction"
Resource: "*"
```
------
#### [ JSON ]
```
"StatesExecutionRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
{
"Fn::Sub": "states.${AWS::Region}.amazonaws.com"
}
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "StatesExecutionPolicy",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "*"
}
]
}
}
]
}
},
```
------
### 建立 Lambda 狀態機器
定義 Lambda 狀態機器。
------
#### [ YAML ]
```
MyStateMachine:
Type: "AWS::StepFunctions::StateMachine"
Properties:
DefinitionString:
!Sub
- |-
{
"Comment": "A Hello World example using an AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "${lambdaArn}",
"End": true
}
}
}
- {lambdaArn: !GetAtt [ MyLambdaFunction, Arn ]}
RoleArn: !GetAtt [ StatesExecutionRole, Arn ]
```
------
#### [ JSON ]
```
"MyStateMachine": {
"Type": "AWS::StepFunctions::StateMachine",
"Properties": {
"DefinitionString": {
"Fn::Sub": [
"{\n \"Comment\": \"A Hello World example using an AWS Lambda function\",\n \"StartAt\": \"HelloWorld\",\n \"States\": {\n \"HelloWorld\": {\n \"Type\": \"Task\",\n \"Resource\": \"${lambdaArn}\",\n \"End\": true\n }\n }\n}",
{
"lambdaArn": {
"Fn::GetAtt": [
"MyLambdaFunction",
"Arn"
]
}
}
]
},
"RoleArn": {
"Fn::GetAtt": [
"StatesExecutionRole",
"Arn"
]
}
}
}
```
------
## 步驟 2：使用 CloudFormation 範本建立 Lambda 狀態機器
了解 CloudFormation 範本的元件後，您可以將它們放在一起，並使用範本來建立 CloudFormation 堆疊。
### 建立 Lambda 狀態機器
1. 將下列範例資料複製到名為 `MyStateMachine.yaml` 的檔案中以用於 YAML 範例，或 `MyStateMachine.json` 以用於 JSON。
------
#### [ YAML ]
```
AWSTemplateFormatVersion: "2010-09-09"
Description: "An example template with an IAM role for a Lambda state machine."
Resources:
LambdaExecutionRole:
Type: "AWS::IAM::Role"
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: "sts:AssumeRole"
MyLambdaFunction:
Type: "AWS::Lambda::Function"
Properties:
Handler: "index.handler"
Role: !GetAtt [ LambdaExecutionRole, Arn ]
Code:
ZipFile: |
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
};
Runtime: "nodejs12.x"
Timeout: "25"
StatesExecutionRole:
Type: "AWS::IAM::Role"
Properties:
AssumeRolePolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: "Allow"
Principal:
Service:
- !Sub states.${AWS::Region}.amazonaws.com
Action: "sts:AssumeRole"
Path: "/"
Policies:
- PolicyName: StatesExecutionPolicy
PolicyDocument:
Version: "2012-10-17"
Statement:
- Effect: Allow
Action:
- "lambda:InvokeFunction"
Resource: "*"
MyStateMachine:
Type: "AWS::StepFunctions::StateMachine"
Properties:
DefinitionString:
!Sub
- |-
{
"Comment": "A Hello World example using an AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "${lambdaArn}",
"End": true
}
}
}
- {lambdaArn: !GetAtt [ MyLambdaFunction, Arn ]}
RoleArn: !GetAtt [ StatesExecutionRole, Arn ]
```
------
#### [ JSON ]
```
{
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "An example template with an IAM role for a Lambda state machine.",
"Resources": {
"LambdaExecutionRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
},
"MyLambdaFunction": {
"Type": "AWS::Lambda::Function",
"Properties": {
"Handler": "index.handler",
"Role": {
"Fn::GetAtt": [
"LambdaExecutionRole",
"Arn"
]
},
"Code": {
"ZipFile": "exports.handler = (event, context, callback) => {\n callback(null, \"Hello World!\");\n};\n"
},
"Runtime": "nodejs12.x",
"Timeout": "25"
}
},
"StatesExecutionRole": {
"Type": "AWS::IAM::Role",
"Properties": {
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
{
"Fn::Sub": "states.${AWS::Region}.amazonaws.com"
}
]
},
"Action": "sts:AssumeRole"
}
]
},
"Path": "/",
"Policies": [
{
"PolicyName": "StatesExecutionPolicy",
"PolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "*"
}
]
}
}
]
}
},
"MyStateMachine": {
"Type": "AWS::StepFunctions::StateMachine",
"Properties": {
"DefinitionString": {
"Fn::Sub": [
"{\n \"Comment\": \"A Hello World example using an AWS Lambda function\",\n \"StartAt\": \"HelloWorld\",\n \"States\": {\n \"HelloWorld\": {\n \"Type\": \"Task\",\n \"Resource\": \"${lambdaArn}\",\n \"End\": true\n }\n }\n}",
{
"lambdaArn": {
"Fn::GetAtt": [
"MyLambdaFunction",
"Arn"
]
}
}
]
},
"RoleArn": {
"Fn::GetAtt": [
"StatesExecutionRole",
"Arn"
]
}
}
}
}
}
```
------
1. 開啟 [CloudFormation 主控台](https://console.aws.amazon.com/cloudformation/home)，然後選擇 **Create Stack (建立堆疊)**。
1. 在 **Select Template (選取範本)** 頁面上，選擇 **Upload a template to Amazon S3 (將範本上傳到 Amazon S3)**。選擇您的 `MyStateMachine` 檔案，然後選擇 **Next (下一步)**。
1. 在 **Specify Details (指定詳細資訊)** 頁面上，為 **Stack Name (堆疊名稱)** 輸入 `MyStateMachine`，然後選擇 **Next (下一步)**。
1. 在**選項**頁面上，選擇**下一步**。
1. 在**檢閱**頁面上，選擇**我確認 CloudFormation 可能會建立 IAM 資源，**然後選擇**建立**。
CloudFormation 開始建立`MyStateMachine`堆疊，並顯示 **CREATE\$1IN\$1PROGRESS** 狀態。程序完成後， CloudFormation 會顯示 **CREATE\$1COMPLETE** 狀態。
1. (選用) 若要顯示堆疊中的資源，請選取堆疊，然後選擇 **Resources (資源)** 標籤。
## 步驟 3：啟動狀態機器執行
建立 Lambda 狀態機器後，您可以開始其執行。
### 開始狀態機器執行
1. 開啟 [Step Functions 主控台](https://console.aws.amazon.com/states/home)，然後選擇您建立的狀態機器名稱 CloudFormation。
1. 在 ***MyStateMachine-ABCDEFGHIJ1K*** 頁面上，選擇 **New execution (新執行)**。
系統會隨即顯示 **New execution (新執行)** 頁面。
1. （選用） 輸入自訂執行名稱以覆寫產生的預設值。
**非 ASCII 名稱和記錄**
Step Functions 接受包含非 ASCII 字元的狀態機器、執行、活動和標籤名稱。由於這類字元會阻止 Amazon CloudWatch 記錄資料，因此我們建議您僅使用 ASCII 字元，以便您可以追蹤 Step Functions 指標。
1. 選擇 **Start Execution (開始執行)**。
狀態機器會開始新執行，且隨即會出現新頁面顯示您正在執行的執行。
1. (選用) 在 **Execution Details (執行詳細資訊)** 中，檢閱 **Execution Status (執行狀態)**、**Started (已開始)** 和 **Closed (已結束)** 時間戳記。
1. 若要檢視執行結果，請選擇 **Output (輸出)**。
# 使用 在 Step Functions 中 AWS CDK 建立標準工作流程
您可以使用AWS Cloud Development Kit (AWS CDK)基礎設施即程式碼 (IAC) 架構來建立包含 AWS Lambda函數AWS Step Functions的狀態機器。
您將使用 CDK支援的其中一種語言來定義 AWS 基礎設施。定義基礎設施後，您會將應用程式合成至 CloudFormation 範本，並將其部署至 AWS 您的帳戶。
您將使用此方法定義包含 Lambda 函數的 Step Functions 狀態機器，然後從使用 Step Functions 的 執行狀態機器 AWS 管理主控台。
開始本教學課程之前，您必須設定AWS CDK開發環境，如 *AWS Cloud Development Kit (AWS CDK) 開發人員指南*中的 [AWS CDK- 先決條件入門](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_prerequisites)中所述。然後，在 AWS CDK使用下列命令安裝 AWS CLI：
```
npm install -g aws-cdk
```
本教學課程會產生與 相同的結果[使用 在 Step Functions 中 CloudFormation 建立工作流程](tutorial-lambda-state-machine-cloudformation.md)。不過，在本教學課程中， AWS CDK不需要您建立任何IAM角色； 會為您AWS CDK執行。AWS CDK 版本也包含一個[工作流程狀態成功](state-succeed.md)步驟，說明如何將其他步驟新增至您的狀態機器。
**提示**
若要部署使用 AWS CDK搭配 TypeScript 啟動Step Functions工作流程的範例無伺服器應用程式，請參閱* AWS Step Functions 研討會*中的[使用 部署AWS CDK](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-cdk)。
## 步驟 1：設定您的 AWS CDK 專案
1. 在您的主目錄中，或者如果您願意，請執行下列命令來為您的新AWS CDK應用程式建立目錄。
**重要**
請務必將目錄命名為 `step`。AWS CDK 應用程式範本使用 目錄的名稱來產生來源檔案和類別的名稱。若使用不同名稱，您的應用程式將與本教學課程不相符。
------
#### [ TypeScript ]
```
mkdir step && cd step
```
------
#### [ JavaScript ]
```
mkdir step && cd step
```
------
#### [ Python ]
```
mkdir step && cd step
```
------
#### [ Java ]
```
mkdir step && cd step
```
------
#### [ C\$1 ]
請確定您已安裝 .NET 6.0 版或更新版本。如需詳細資訊，請參閱[支援的版本](https://dotnet.microsoft.com/en-us/download/dotnet)。
```
mkdir step && cd step
```
------
1. 使用 **cdk init** 命令初始化應用程式。指定所需的範本 ("app") 和程式設計語言，如下列範例所示。
------
#### [ TypeScript ]
```
cdk init --language typescript
```
------
#### [ JavaScript ]
```
cdk init --language javascript
```
------
#### [ Python ]
```
cdk init --language python
```
初始化專案之後，請啟用專案的虛擬環境，並安裝 AWS CDK的基準相依性。
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
------
#### [ Java ]
```
cdk init --language java
```
------
#### [ C\$1 ]
```
cdk init --language csharp
```
------
## 步驟 2：使用 AWS CDK建立狀態機器
首先，我們將介紹定義Lambda函數和Step Functions狀態機器的個別程式碼片段。然後，我們將說明如何將它們放在您的AWS CDK應用程式中。最後，您將了解如何合成和部署這些資源。
### 建立 Lambda 函數
下列AWS CDK程式碼會定義 Lambda函數，並內嵌提供其原始程式碼。
------
#### [ TypeScript ]
```
const helloFunction = new lambda.Function(this, 'MyLambdaFunction', {
code: lambda.Code.fromInline(`
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
};
`),
runtime: lambda.Runtime.NODEJS_18_X,
handler: "index.handler",
timeout: cdk.Duration.seconds(3)
});
```
------
#### [ JavaScript ]
```
const helloFunction = new lambda.Function(this, 'MyLambdaFunction', {
code: lambda.Code.fromInline(`
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
};
`),
runtime: lambda.Runtime.NODEJS_18_X,
handler: "index.handler",
timeout: cdk.Duration.seconds(3)
});
```
------
#### [ Python ]
```
hello_function = lambda_.Function(
self, "MyLambdaFunction",
code=lambda_.Code.from_inline("""
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
}"""),
runtime=lambda_.Runtime.NODEJS_18_X,
handler="index.handler",
timeout=Duration.seconds(25))
```
------
#### [ Java ]
```
final Function helloFunction = Function.Builder.create(this, "MyLambdaFunction")
.code(Code.fromInline(
"exports.handler = (event, context, callback) => { callback(null, 'Hello World!' );}"))
.runtime(Runtime.NODEJS_18_X)
.handler("index.handler")
.timeout(Duration.seconds(25))
.build();
```
------
#### [ C\$1 ]
```
var helloFunction = new Function(this, "MyLambdaFunction", new FunctionProps
{
Code = Code.FromInline(@"`
exports.handler = (event, context, callback) => {
callback(null, 'Hello World!');
}"),
Runtime = Runtime.NODEJS_12_X,
Handler = "index.handler",
Timeout = Duration.Seconds(25)
});
```
------
您可以在此簡短範例程式碼中看到 ：
+ 函數的邏輯名稱 `MyLambdaFunction`。
+ 函數的原始程式碼，內嵌為AWS CDK應用程式的原始程式碼中的字串。
+ 其他函數屬性，例如要使用的執行時間 （節點 18.x)、函數的進入點和逾時。
### 建立 狀態機器
我們的狀態機器有兩個狀態：Lambda函數任務和[工作流程狀態成功](state-succeed.md)狀態。函數需要我們建立Step Functions[任務工作流程狀態](state-task.md)叫用函數的 。此任務狀態用作狀態機器中的第一個步驟。成功狀態會使用任務狀態的 `next()`方法新增至狀態機器。下列程式碼會先叫用名為 的函數`MyLambdaTask`，然後使用 `next()`方法來定義名為 的成功狀態`GreetedWorld`。
------
#### [ TypeScript ]
```
const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
definition: new tasks.LambdaInvoke(this, "MyLambdaTask", {
lambdaFunction: helloFunction
}).next(new sfn.Succeed(this, "GreetedWorld"))
});
```
------
#### [ JavaScript ]
```
const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
definition: new tasks.LambdaInvoke(this, "MyLambdaTask", {
lambdaFunction: helloFunction
}).next(new sfn.Succeed(this, "GreetedWorld"))
});
```
------
#### [ Python ]
```
state_machine = sfn.StateMachine(
self, "MyStateMachine",
definition=tasks.LambdaInvoke(
self, "MyLambdaTask",
lambda_function=hello_function)
.next(sfn.Succeed(self, "GreetedWorld")))
```
------
#### [ Java ]
```
final StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
.definition(LambdaInvoke.Builder.create(this, "MyLambdaTask")
.lambdaFunction(helloFunction)
.build()
.next(new Succeed(this, "GreetedWorld")))
.build();
```
------
#### [ C\$1 ]
```
var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps {
DefinitionBody = DefinitionBody.FromChainable(new LambdaInvoke(this, "MyLambdaTask", new LambdaInvokeProps
{
LambdaFunction = helloFunction
})
.Next(new Succeed(this, "GreetedWorld")))
});
```
------
### 建置和部署AWS CDK應用程式
在您新建立的AWS CDK專案中，編輯包含堆疊定義的檔案，使其看起來像下列範例程式碼。您將辨識先前章節中Lambda函數和Step Functions狀態機器的定義。
1. 更新堆疊，如下列範例所示。
------
#### [ TypeScript ]
`lib/step-stack.ts` 使用以下程式碼進行更新。
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
export class StepStack extends cdk.Stack {
constructor(app: cdk.App, id: string) {
super(app, id);
const helloFunction = new lambda.Function(this, 'MyLambdaFunction', {
code: lambda.Code.fromInline(`
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
};
`),
runtime: lambda.Runtime.NODEJS_18_X,
handler: "index.handler",
timeout: cdk.Duration.seconds(3)
});
const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
definition: new tasks.LambdaInvoke(this, "MyLambdaTask", {
lambdaFunction: helloFunction
}).next(new sfn.Succeed(this, "GreetedWorld"))
});
}
}
```
------
#### [ JavaScript ]
`lib/step-stack.js` 使用以下程式碼進行更新。
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as sfn from 'aws-cdk-lib/aws-stepfunctions';
import * as tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';
export class StepStack extends cdk.Stack {
constructor(app, id) {
super(app, id);
const helloFunction = new lambda.Function(this, 'MyLambdaFunction', {
code: lambda.Code.fromInline(`
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
};
`),
runtime: lambda.Runtime.NODEJS_18_X,
handler: "index.handler",
timeout: cdk.Duration.seconds(3)
});
const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
definition: new tasks.LambdaInvoke(this, "MyLambdaTask", {
lambdaFunction: helloFunction
}).next(new sfn.Succeed(this, "GreetedWorld"))
});
}
}
```
------
#### [ Python ]
`step/step_stack.py` 使用以下程式碼進行更新。
```
from aws_cdk import (
Duration,
Stack,
aws_stepfunctions as sfn,
aws_stepfunctions_tasks as tasks,
aws_lambda as lambda_
)
class StepStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
hello_function = lambda_.Function(
self, "MyLambdaFunction",
code=lambda_.Code.from_inline("""
exports.handler = (event, context, callback) => {
callback(null, "Hello World!");
}"""),
runtime=lambda_.Runtime.NODEJS_18_X,
handler="index.handler",
timeout=Duration.seconds(25))
state_machine = sfn.StateMachine(
self, "MyStateMachine",
definition=tasks.LambdaInvoke(
self, "MyLambdaTask",
lambda_function=hello_function)
.next(sfn.Succeed(self, "GreetedWorld")))
```
------
#### [ Java ]
`src/main/java/com.myorg/StepStack.java` 使用以下程式碼進行更新。
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
import software.amazon.awscdk.Duration;
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
import software.amazon.awscdk.services.stepfunctions.StateMachine;
import software.amazon.awscdk.services.stepfunctions.Succeed;
import software.amazon.awscdk.services.stepfunctions.tasks.LambdaInvoke;
public class StepStack extends Stack {
public StepStack(final Construct scope, final String id) {
this(scope, id, null);
}
public StepStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
final Function helloFunction = Function.Builder.create(this, "MyLambdaFunction")
.code(Code.fromInline(
"exports.handler = (event, context, callback) => { callback(null, 'Hello World!' );}"))
.runtime(Runtime.NODEJS_18_X)
.handler("index.handler")
.timeout(Duration.seconds(25))
.build();
final StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
.definition(LambdaInvoke.Builder.create(this, "MyLambdaTask")
.lambdaFunction(helloFunction)
.build()
.next(new Succeed(this, "GreetedWorld")))
.build();
}
}
```
------
#### [ C\$1 ]
`src/Step/StepStack.cs` 使用以下程式碼進行更新。
```
using Amazon.CDK;
using Constructs;
using Amazon.CDK.AWS.Lambda;
using Amazon.CDK.AWS.StepFunctions;
using Amazon.CDK.AWS.StepFunctions.Tasks;
namespace Step
{
public class StepStack : Stack
{
internal StepStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var helloFunction = new Function(this, "MyLambdaFunction", new FunctionProps
{
Code = Code.FromInline(@"exports.handler = (event, context, callback) => {
callback(null, 'Hello World!');
}"),
Runtime = Runtime.NODEJS_18_X,
Handler = "index.handler",
Timeout = Duration.Seconds(25)
});
var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps
{
DefinitionBody = DefinitionBody.FromChainable(new LambdaInvoke(this, "MyLambdaTask", new LambdaInvokeProps
{
LambdaFunction = helloFunction
})
.Next(new Succeed(this, "GreetedWorld")))
});
}
}
}
```
------
1. 儲存來源檔案，然後在應用程式的主目錄中執行 `cdk synth`命令。
AWS CDK 會執行應用程式並從中合成CloudFormation範本。AWS CDK然後 會顯示範本。
**注意**
如果您使用 TypeScript 建立AWS CDK專案，執行 `cdk synth`命令可能會傳回下列錯誤。
```
TSError: ⨯ Unable to compile TypeScript:
bin/step.ts:7:33 - error TS2554: Expected 2 arguments, but got 3.
```
修改 `bin/step.ts` 檔案，如下列範例所示，以解決此錯誤。
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { StepStack } from '../lib/step-stack';
const app = new cdk.App();
new StepStack(app, 'StepStack');
app.synth();
```
1. 若要將 Lambda 函數和 Step Functions 狀態機器部署到您的帳戶 AWS ，請發出 `cdk deploy`。系統會要求您核准 AWS CDK 產生的 IAM 政策。
## 步驟 3：啟動狀態機器執行
建立狀態機器後，您可以開始執行。
### 開始狀態機器執行
1. 開啟 [Step Functions 主控台](https://console.aws.amazon.com/states/home)，然後選擇您使用 建立的狀態機器名稱AWS CDK。
1. 在狀態機器頁面上，選擇**開始執行**。
隨即顯示**開始執行**對話方塊。
1. （選用） 輸入自訂執行名稱以覆寫產生的預設值。
**非 ASCII 名稱和記錄**
Step Functions 接受包含非 ASCII 字元的狀態機器、執行、活動和標籤名稱。由於這類字元會阻止 Amazon CloudWatch 記錄資料，因此我們建議您僅使用 ASCII 字元，以便您可以追蹤 Step Functions 指標。
1. 選擇 **Start Execution (開始執行)**。
狀態機器的執行開始，並顯示顯示執行中執行的新頁面。
1. Step Functions 主控台會將您導向至標題為執行 ID 的頁面。此頁面稱為*執行詳細資訊*頁面。在此頁面上，您可以在執行進行時或完成後檢閱執行結果。
若要檢閱執行結果，請在**圖形檢視**中選擇個別狀態，然後選擇[步驟詳細資訊](concepts-view-execution-details.md#exec-details-intf-step-details)窗格上的個別索引標籤，分別檢視每個狀態的詳細資訊，包括輸入、輸出和定義。如需您可以在執行詳細資訊頁面上檢視之*執行資訊的詳細資訊*，請參閱 [執行詳細資訊概觀](concepts-view-execution-details.md#exec-details-interface-overview)。
## 步驟 4：清除
測試狀態機器之後，建議您同時移除狀態機器和相關的 Lambda 函數，以釋放 中的資源 AWS 帳戶。在應用程式的主目錄中執行 `cdk destroy`命令，以移除您的狀態機器。
## 後續步驟
若要進一步了解如何使用 開發 AWS 基礎設施AWS CDK，請參閱 [AWS CDK開發人員指南](https://docs.aws.amazon.com/cdk/v2/guide/home.html)。
如需有關以所選語言編寫 AWS CDK 應用程式的資訊，請參閱：
------
#### [ TypeScript ]
[在 TypeScript AWS CDK中使用](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html)
------
#### [ JavaScript ]
[在 JavaScript AWS CDK中使用](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-javascript.html)
------
#### [ Python ]
[在 Python AWS CDK中使用](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html)
------
#### [ Java ]
[在 Java AWS CDK中使用](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-java.html)
------
#### [ C\$1 ]
[在 C\$1 AWS CDK中使用](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html)
------
如需本教學中使用的 AWS 建構程式庫模組的詳細資訊，請參閱下列 AWS CDK API 參考概觀：
+ [aws-lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [aws-stepfunctions](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions-readme.html)
+ [aws-stepfunctions-tasks](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions_tasks-readme.html)
# 使用 在 Step Functions 中 AWS CDK 建立 Express 工作流程
在本教學課程中，您將了解如何使用 AWS Cloud Development Kit (AWS CDK) Infrastructure as Code (IAC) 架構，使用同步快速狀態機器建立 API Gateway REST API 做為後端整合。
您將使用 `StepFunctionsRestApi` 建構來將狀態機器連線至 API Gateway。`StepFunctionsRestApi` 建構將設定預設輸入/輸出映射和 API Gateway REST API，具有必要的許可和 HTTP "ANY" 方法。
使用 AWS CDK 是基礎設施即程式碼 (IAC) 架構，您可以使用程式設計語言定義 AWS 基礎設施。您可以使用其中一種 CDK 支援的語言定義應用程式，將程式碼合成至 CloudFormation 範本，然後將基礎設施部署至 AWS 您的帳戶。
您將使用 CloudFormation 定義 API Gateway REST API，該 API 與 Synchronous Express State Machine 整合為後端，然後使用 AWS 管理主控台 啟動執行。
開始本教學課程之前，請依照 [AWS CDK - 先決條件入門](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_prerequisites)所述來設定您的 AWS CDK 開發環境，然後 AWS CDK 透過發出以下命令來安裝 ：
```
npm install -g aws-cdk
```
## 步驟 1：設定您的 AWS CDK 專案
首先，為您的新 AWS CDK 應用程式建立目錄並初始化專案。
------
#### [ TypeScript ]
```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language typescript
```
------
#### [ JavaScript ]
```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language javascript
```
------
#### [ Python ]
```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language python
```
初始化專案之後，請啟用專案的虛擬環境，並安裝 AWS CDK的基準相依性。
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
------
#### [ Java ]
```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language java
```
------
#### [ C\$1 ]
```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language csharp
```
------
#### [ Go ]
```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language go
```
------
**注意**
請務必將目錄命名為 `stepfunctions-rest-api`。 AWS CDK 應用程式範本使用 目錄的名稱來產生來源檔案和類別的名稱。若使用不同名稱，您的應用程式將與本教學課程不相符。
現在安裝適用於 AWS Step Functions 和 Amazon API Gateway 的建構程式庫模組。
------
#### [ TypeScript ]
```
npm install @aws-cdk/aws-stepfunctions @aws-cdk/aws-apigateway
```
------
#### [ JavaScript ]
```
npm install @aws-cdk/aws-stepfunctions @aws-cdk/aws-apigateway
```
------
#### [ Python ]
```
python -m pip install aws-cdk.aws-stepfunctions
python -m pip install aws-cdk.aws-apigateway
```
------
#### [ Java ]
編輯專案的 `pom.xml`，在現有的 `` 容器內新增下列相依性。
```
software.amazon.awscdk
stepfunctions
${cdk.version}
software.amazon.awscdk
apigateway
${cdk.version}
```
Maven 會在您下次建立應用程式時自動安裝這些相依性。若要建置，發行 `mvn compile` 或使用您的 Java IDE 的 **Build** 命令。
------
#### [ C\$1 ]
```
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.Stepfunctions
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.APIGateway
```
您也可以使用 Visual Studio NuGet GUI 安裝指定的套件，可透過 **Tools** (工具) > **NuGet Package Manager** (NuGet 套件管理員) > **Manage NuGet Packages for Solution** (管理解決方案的 NuGet 套件) 獲取。
------
安裝模組後，您可以透過匯入下列套件，在 AWS CDK 應用程式中使用這些模組。
------
#### [ TypeScript ]
```
@aws-cdk/aws-stepfunctions
@aws-cdk/aws-apigateway
```
------
#### [ JavaScript ]
```
@aws-cdk/aws-stepfunctions
@aws-cdk/aws-apigateway
```
------
#### [ Python ]
```
aws_cdk.aws_stepfunctions
aws_cdk.aws_apigateway
```
------
#### [ Java ]
```
software.amazon.awscdk.services.apigateway.StepFunctionsRestApi
software.amazon.awscdk.services.stepfunctions.Pass
software.amazon.awscdk.services.stepfunctions.StateMachine
software.amazon.awscdk.services.stepfunctions.StateMachineType
```
------
#### [ C\$1 ]
```
Amazon.CDK.AWS.StepFunctions
Amazon.CDK.AWS.APIGateway
```
------
#### [ Go ]
將以下內容新增至 `import`內部`stepfunctions-rest-api.go`。
```
"github.com/aws/aws-cdk-go/awscdk/awsapigateway"
"github.com/aws/aws-cdk-go/awscdk/awsstepfunctions"
```
------
## 步驟 2：使用 AWS CDK 建立具有同步快速狀態機器後端整合的 API Gateway REST API
首先，我們將提供定義同步快速狀態機器和 API Gateway REST API 的個別程式碼片段，然後說明如何將這些程式碼放在您的 AWS CDK 應用程式中。然後，您將了解如何合成和部署這些資源。
**注意**
我們將在此處顯示的 狀態機器將是具有 `Pass` 狀態的簡單 狀態機器。
### 建立快速狀態機器
這是定義具有 `Pass` 狀態之簡單狀態機器的 AWS CDK 程式碼。
------
#### [ TypeScript ]
```
const machineDefinition = new stepfunctions.Pass(this, 'PassState', {
result: {value:"Hello!"},
})
const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {
definition: machineDefinition,
stateMachineType: stepfunctions.StateMachineType.EXPRESS,
});
```
------
#### [ JavaScript ]
```
const machineDefinition = new sfn.Pass(this, 'PassState', {
result: {value:"Hello!"},
})
const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
definition: machineDefinition,
stateMachineType: stepfunctions.StateMachineType.EXPRESS,
});
```
------
#### [ Python ]
```
machine_definition = sfn.Pass(self,"PassState",
result = sfn.Result("Hello"))
state_machine = sfn.StateMachine(self, 'MyStateMachine',
definition = machine_definition,
state_machine_type = sfn.StateMachineType.EXPRESS)
```
------
#### [ Java ]
```
Pass machineDefinition = Pass.Builder.create(this, "PassState")
.result(Result.fromString("Hello"))
.build();
StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
.definition(machineDefinition)
.stateMachineType(StateMachineType.EXPRESS)
.build();
```
------
#### [ C\$1 ]
```
var machineDefinition = new Pass(this, "PassState", new PassProps
{
Result = Result.FromString("Hello")
});
var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps
{
Definition = machineDefinition,
StateMachineType = StateMachineType.EXPRESS
});
```
------
#### [ Go ]
```
var machineDefinition = awsstepfunctions.NewPass(stack, jsii.String("PassState"), &awsstepfunctions.PassProps
{
Result: awsstepfunctions.NewResult(jsii.String("Hello")),
})
var stateMachine = awsstepfunctions.NewStateMachine(stack, jsii.String("StateMachine"), &awsstepfunctions.StateMachineProps
{
Definition: machineDefinition,
StateMachineType: awsstepfunctions.StateMachineType_EXPRESS,
})
```
------
您可以在此簡短的程式碼片段中看到：
+ 名為 的機器定義`PassState`，其為 `Pass` 狀態。
+ 狀態機器的邏輯名稱 `MyStateMachine`。
+ 機器定義會用作狀態機器定義。
+ 狀態機器類型設定為 ，`EXPRESS`因為 `StepFunctionsRestApi` 只允許同步快速狀態機器。
### 使用 `StepFunctionsRestApi` 建構建立 API Gateway REST API
我們將使用 `StepFunctionsRestApi` 建構來建立具有必要許可和預設輸入/輸出映射的 API Gateway REST API。
------
#### [ TypeScript ]
```
const api = new apigateway.StepFunctionsRestApi(this,
'StepFunctionsRestApi', { stateMachine: stateMachine });
```
------
#### [ JavaScript ]
```
const api = new apigateway.StepFunctionsRestApi(this,
'StepFunctionsRestApi', { stateMachine: stateMachine });
```
------
#### [ Python ]
```
api = apigw.StepFunctionsRestApi(self, "StepFunctionsRestApi",
state_machine = state_machine)
```
------
#### [ Java ]
```
StepFunctionsRestApi api = StepFunctionsRestApi.Builder.create(this, "StepFunctionsRestApi")
.stateMachine(stateMachine)
.build();
```
------
#### [ C\$1 ]
```
var api = new StepFunctionsRestApi(this, "StepFunctionsRestApi", new StepFunctionsRestApiProps
{
StateMachine = stateMachine
});
```
------
#### [ Go ]
```
awsapigateway.NewStepFunctionsRestApi(stack, jsii.String("StepFunctionsRestApi"), &awsapigateway.StepFunctionsRestApiProps
{
StateMachine = stateMachine,
})
```
------
### 建置和部署 AWS CDK 應用程式
在您建立的 AWS CDK 專案中，編輯包含堆疊定義的檔案，使其看起來像下面的程式碼。您將從上方辨識 Step Functions 狀態機器和 API Gateway 的定義。
------
#### [ TypeScript ]
更新 ` lib/stepfunctions-rest-api-stack.ts`，讀取如下。
```
import * as cdk from 'aws-cdk-lib';
import * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions'
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
export class StepfunctionsRestApiStack extends cdk.Stack {
constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
super(scope, id, props);
const machineDefinition = new stepfunctions.Pass(this, 'PassState', {
result: {value:"Hello!"},
});
const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {
definition: machineDefinition,
stateMachineType: stepfunctions.StateMachineType.EXPRESS,
});
const api = new apigateway.StepFunctionsRestApi(this,
'StepFunctionsRestApi', { stateMachine: stateMachine });
```
------
#### [ JavaScript ]
更新 `lib/stepfunctions-rest-api-stack.js`，讀取如下。
```
const cdk = require('@aws-cdk/core');
const stepfunctions = require('@aws-cdk/aws-stepfunctions');
const apigateway = require('@aws-cdk/aws-apigateway');
class StepfunctionsRestApiStack extends cdk.Stack {
constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
const machineDefinition = new stepfunctions.Pass(this, "PassState", {
result: {value:"Hello!"},
})
const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
definition: machineDefinition,
stateMachineType: stepfunctions.StateMachineType.EXPRESS,
});
const api = new apigateway.StepFunctionsRestApi(this,
'StepFunctionsRestApi', { stateMachine: stateMachine });
}
}
module.exports = { StepStack }
```
------
#### [ Python ]
更新 `stepfunctions_rest_api/stepfunctions_rest_api_stack.py`，讀取如下。
```
from aws_cdk import App, Stack
from constructs import Construct
from aws_cdk import aws_stepfunctions as sfn
from aws_cdk import aws_apigateway as apigw
class StepfunctionsRestApiStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
machine_definition = sfn.Pass(self,"PassState",
result = sfn.Result("Hello"))
state_machine = sfn.StateMachine(self, 'MyStateMachine',
definition = machine_definition,
state_machine_type = sfn.StateMachineType.EXPRESS)
api = apigw.StepFunctionsRestApi(self,
"StepFunctionsRestApi",
state_machine = state_machine)
```
------
#### [ Java ]
更新 `src/main/java/com.myorg/StepfunctionsRestApiStack.java`，讀取如下。
```
package com.myorg;
import software.amazon.awscdk.core.Construct;
import software.amazon.awscdk.core.Stack;
import software.amazon.awscdk.core.StackProps;
import software.amazon.awscdk.services.stepfunctions.Pass;
import software.amazon.awscdk.services.stepfunctions.StateMachine;
import software.amazon.awscdk.services.stepfunctions.StateMachineType;
import software.amazon.awscdk.services.apigateway.StepFunctionsRestApi;
public class StepfunctionsRestApiStack extends Stack {
public StepfunctionsRestApiStack(final Construct scope, final String id) {
this(scope, id, null);
}
public StepfunctionsRestApiStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
Pass machineDefinition = Pass.Builder.create(this, "PassState")
.result(Result.fromString("Hello"))
.build();
StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
.definition(machineDefinition)
.stateMachineType(StateMachineType.EXPRESS)
.build();
StepFunctionsRestApi api = StepFunctionsRestApi.Builder.create(this, "StepFunctionsRestApi")
.stateMachine(stateMachine)
.build();
}
}
```
------
#### [ C\$1 ]
更新 `src/StepfunctionsRestApi/StepfunctionsRestApiStack.cs`，讀取如下。
```
using Amazon.CDK;
using Amazon.CDK.AWS.StepFunctions;
using Amazon.CDK.AWS.APIGateway;
namespace StepfunctionsRestApi
{
public class StepfunctionsRestApiStack : Stack
{
internal StepfunctionsRestApi(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
var machineDefinition = new Pass(this, "PassState", new PassProps
{
Result = Result.FromString("Hello")
});
var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps
{
Definition = machineDefinition,
StateMachineType = StateMachineType.EXPRESS
});
var api = new StepFunctionsRestApi(this, "StepFunctionsRestApi", new StepFunctionsRestApiProps
{
StateMachine = stateMachine
});
}
}
}
```
------
#### [ Go ]
更新 `stepfunctions-rest-api.go`，讀取如下。
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk"
"github.com/aws/aws-cdk-go/awscdk/awsapigateway"
"github.com/aws/aws-cdk-go/awscdk/awsstepfunctions"
"github.com/aws/constructs-go/constructs/v3"
"github.com/aws/jsii-runtime-go"
)
type StepfunctionsRestApiGoStackProps struct {
awscdk.StackProps
}
func NewStepfunctionsRestApiGoStack(scope constructs.Construct, id string, props *StepfunctionsRestApiGoStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// The code that defines your stack goes here
var machineDefinition = awsstepfunctions.NewPass(stack, jsii.String("PassState"), &awsstepfunctions.PassProps
{
Result: awsstepfunctions.NewResult(jsii.String("Hello")),
})
var stateMachine = awsstepfunctions.NewStateMachine(stack, jsii.String("StateMachine"), &awsstepfunctions.StateMachineProps{
Definition: machineDefinition,
StateMachineType: awsstepfunctions.StateMachineType_EXPRESS,
});
awsapigateway.NewStepFunctionsRestApi(stack, jsii.String("StepFunctionsRestApi"), &awsapigateway.StepFunctionsRestApiProps{
StateMachine = stateMachine,
})
return stack
}
func main() {
app := awscdk.NewApp(nil)
NewStepfunctionsRestApiGoStack(app, "StepfunctionsRestApiGoStack", &StepfunctionsRestApiGoStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
// env determines the AWS environment (account+region) in which our stack is to
// be deployed. For more information see: https://docs.aws.amazon.com/cdk/latest/guide/environments.html
func env() *awscdk.Environment {
// If unspecified, this stack will be "environment-agnostic".
// Account/Region-dependent features and context lookups will not work, but a
// single synthesized template can be deployed anywhere.
//---------------------------------------------------------------------------
return nil
// Uncomment if you know exactly what account and region you want to deploy
// the stack to. This is the recommendation for production stacks.
//---------------------------------------------------------------------------
// return &awscdk.Environment{
// Account: jsii.String("account-id"),
// Region: jsii.String("us-east-1"),
// }
// Uncomment to specialize this stack for the AWS Account and Region that are
// implied by the current CLI configuration. This is recommended for dev
// stacks.
//---------------------------------------------------------------------------
// return &awscdk.Environment{
// Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")),
// Region: jsii.String(os.Getenv("CDK_DEFAULT_REGION")),
// }
}
```
------
保存來源檔案，然後在應用程式的主目錄中發行 `cdk synth`。會 AWS CDK 執行應用程式並從中合成 CloudFormation 範本，然後顯示範本。
若要將 Amazon API Gateway 和 AWS Step Functions 狀態機器實際部署到您的 AWS 帳戶，請發出 `cdk deploy`。系統會要求您核准 AWS CDK 產生的 IAM 政策。
## 步驟 3：測試 API Gateway
使用同步快速狀態機器建立 API Gateway REST API 做為後端整合後，您可以測試 API Gateway。
### 使用 API Gateway 主控台測試部署的 API Gateway
1. 開啟 [Amazon API Gateway 主控台](https://console.aws.amazon.com/apigateway/)並登入。
1. 選擇名為 的 REST API`StepFunctionsRestApi`。
1. 在**資源**窗格中，選擇 `ANY`方法。
1. 選擇**測試**標籤。您可能需要選擇向右箭頭按鈕才能顯示此索引標籤。
1. 針對 **Method** (方法) 選擇 **POST**。
1. 針對**請求內文**，複製下列請求參數。
```
{
"key": "Hello"
}
```
1. 選擇 **Test (測試)**。下列資訊會隨即顯示：
+ **Request (請求)** 是針對方法所呼叫的資源路徑。
+ **Status (狀態)** 是回應的 HTTP 狀態碼。
+ **Latency (延遲)** 是從發起人收到請求到傳回回應之間的時間。
+ **回應內文**是 HTTP 回應內文。
+ **回應標頭**是 HTTP 回應標頭。
+ **日誌**會顯示模擬的 Amazon CloudWatch Logs 項目，如果是在 API Gateway 主控台之外呼叫此方法，則會寫入這些項目。
**注意**
雖然 CloudWatch Logs 項目是模擬的，但方法呼叫的結果是真實的。
**回應內文**輸出應該如下：
```
"Hello"
```
**提示**
嘗試使用不同的方法和無效的輸入來查看錯誤輸出。您可能想要變更狀態機器以尋找特定金鑰，並在測試期間提供錯誤的金鑰，讓狀態機器執行失敗，並在**回應內文**輸出中產生錯誤訊息。
### 使用 cURL 測試已部署的 API
1. 開啟終端機視窗。
1. 複製以下 cURL 命令，並將它貼到終端機視窗，同時將 `` 取代為您 API 的 API ID，以及將 `` 取代為 API 的部署區域。
```
curl -X POST\
'https://.execute-api..amazonaws.com/prod' \
-d '{"key":"Hello"}' \
-H 'Content-Type: application/json'
```
**回應內文**輸出應該如下所示：
```
"Hello"
```
**提示**
嘗試使用不同的方法和無效的輸入來查看錯誤輸出。您可能想要變更狀態機器以尋找特定金鑰，並在測試期間提供錯誤的金鑰，讓狀態機器執行失敗，並在**回應內文**輸出中產生錯誤訊息。
## 步驟 4：清除
完成嘗試 API Gateway 後，您可以使用 AWS CDK 來銷毀狀態機器和 API Gateway。在您的應用程式的主目錄中發行 `cdk destroy`。
# 使用 Terraform 在 Step Functions 中部署狀態機器
HashiCorp 的 [Terraform](https://www.terraform.io/intro/) 是使用基礎設施即程式碼 (IaC) 建置應用程式的架構。使用 Terraform，您可以建立狀態機器並使用功能，例如預覽基礎設施部署和建立可重複使用的範本。Terraform 範本會將程式碼分解為較小的區塊，協助您維護和重複使用程式碼。
如果您熟悉 Terraform，則可以遵循本主題所述的開發生命週期，做為在 Terraform 中建立和部署狀態機器的模型。如果您不熟悉 Terraform，建議您先完成 [上的 Terraform 研討會簡介 AWS](https://catalog.workshops.aws/terraform101/en-US)，以便熟悉 Terraform。
**提示**
若要部署使用 Terraform 建置的狀態機器範例，請參閱 * AWS Step Functions 研討會*中的[使用 Terraform 部署](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-terraform)。
**Topics**
+ [先決條件](#terraform-sfn-prerequisites)
+ [使用 Terraform 的開發生命週期](#terraform-sfn-dev-lifecycle)
+ [狀態機器的 IAM 角色和政策](#terraform-sfn-iam-policy)
## 先決條件
開始之前，請務必完成下列先決條件：
+ 在機器上安裝 Terraform。如需安裝 Terraform 的詳細資訊，請參閱[安裝 Terraform](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)。
+ 在機器上安裝 Step Functions Local。我們建議您安裝 Step Functions Local Docker 映像，以使用 Step Functions Local。如需詳細資訊，請參閱[使用 Step Functions Local 測試狀態機器 （不支援）](sfn-local.md)。
+ 安裝 AWS SAM CLI。如需安裝資訊，請參閱《 *AWS Serverless Application Model 開發人員指南*》中的[安裝 AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html)。
+ 安裝 AWS Toolkit for Visual Studio Code 以檢視狀態機器的工作流程圖表。如需安裝資訊，請參閱*AWS Toolkit for Visual Studio Code 《 使用者指南*[》中的安裝 AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html) 。
## 使用 Terraform 的狀態機器開發生命週期
下列程序說明如何使用您在 Step Functions 主控台中使用 [Workflow Studio](workflow-studio.md) 建置的狀態機器原型，做為使用 Terraform 和 進行本機開發的起點[AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/welcome.html)。
若要檢視與 Terraform 討論狀態機器開發並詳細說明最佳實務的完整範例，請參閱[撰寫 Step Functions Terraform 專案的最佳實務](https://aws.amazon.com/blogs/devops/best-practices-for-writing-step-functions-terraform-projects/)。
**使用 Terraform 啟動狀態機器的開發生命週期**
1. 使用以下命令引導新的 Terraform 專案。
```
terraform init
```
1. 開啟 [Step Functions 主控台](https://console.aws.amazon.com/states/home?region=us-east-1#/)，為您的狀態機器建立原型。
1. 在 Workflow Studio 中，執行下列動作：
1. 建立您的工作流程原型。
1. 匯出工作流程的 [Amazon States Language (ASL)](concepts-amazon-states-language.md) 定義。若要執行此作業，請選擇**匯入/匯出**下拉式清單，然後選取**匯出 JSON 定義**。
1. 將匯出的 ASL 定義儲存在專案目錄中。
您可以將匯出的 ASL 定義做為輸入參數傳遞給使用 [https://developer.hashicorp.com/terraform/language/functions/templatefile](https://developer.hashicorp.com/terraform/language/functions/templatefile)函數的 [https://registry.terraform.io/modules/terraform-aws-modules/step-functions/aws/latest](https://registry.terraform.io/modules/terraform-aws-modules/step-functions/aws/latest) Terraform 資源。此函數會在傳遞匯出 ASL 定義和任何變數替換的定義欄位中使用。
**提示**
由於 ASL 定義檔案可以包含冗長的文字區塊，我們建議您避免內嵌 EOF 方法。這可讓您更輕鬆地將參數取代為您的狀態機器定義。
1. （選用） 更新 IDE 中的 ASL 定義，並使用 視覺化您的變更 AWS Toolkit for Visual Studio Code。
![\[Visual Studio Code 中工作流程的 ASL 定義及其視覺化呈現的螢幕擷取畫面。\]](http://docs.aws.amazon.com/zh_tw/step-functions/latest/dg/images/visualize-sm-terraform-iac.png)
為了避免持續匯出定義並將其重構到專案中，建議您在 IDE 中於本機進行更新，並使用 [Git](https://git-scm.com/) 追蹤這些更新。
1. 使用 [Step Functions Local](sfn-local.md) 測試您的工作流程。
**提示**
您也可以使用 [AWS SAM CLI Local](sfn-local-lambda.md)，在本機測試服務與狀態機器中 Lambda 函數和 API Gateway APIs整合。
1. 部署狀態機器之前，請預覽您的狀態機器和其他 AWS 資源。若要進行這項動作，請執行以下命令。
```
terraform plan
```
1. 使用下列命令，從本機環境或透過 [CI/CD 管道](https://aws.amazon.com/blogs/developer/build-infrastructure-ci-for-terraform-code-leveraging-aws-developer-tools-and-terratest/)部署您的狀態機器。
```
terraform apply
```
1. （選用） 使用下列命令清除資源並刪除狀態機器。
```
terraform destroy
```
## 狀態機器的 IAM 角色和政策
使用 [Terraform 服務整合政策](https://registry.terraform.io/modules/terraform-aws-modules/step-functions/aws/latest#service-integration-policies)將必要的 IAM 許可新增至您的狀態機器，例如調用 Lambda 函數的許可。您也可以定義明確的角色和政策，並將其與您的狀態機器建立關聯。
下列 IAM 政策範例授予您的狀態機器存取，以叫用名為 的 Lambda 函數`myFunction`。
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-east-1:123456789012:function:myFunction"
}
]
}
```
在 Terraform 中為您的狀態機器定義 IAM 政策時，我們也建議使用 [https://registry.terraform.io/providers/hashicorp/aws/latest/docs/data-sources/iam_policy_document](https://registry.terraform.io/providers/hashicorp/aws/latest/docs/data-sources/iam_policy_document) 資料來源。這可協助您檢查政策是否格式錯誤，並以變數取代任何資源。
下列 IAM 政策範例使用 `aws_iam_policy_document` 資料來源，並授予狀態機器呼叫名為 之 Lambda 函數的存取權`myFunction`。
```
data "aws_iam_policy_document" "state_machine_role_policy" {
statement {
effect = "Allow"
actions = [
"lambda:InvokeFunction"
]
resources = ["${aws_lambda_function.function-1.arn}:*"]
}
}
```
**提示**
若要檢視使用 Terraform 部署的更進階 AWS 架構模式，請參閱 [Serverless Land Workflows Collection 中的 Terraform 範例](https://serverlessland.com/workflows?framework=Terraform)。
# 將您的工作流程匯出至 IaC 範本
AWS Step Functions 主控台可讓您將儲存的工作流程匯出並下載為 AWS CloudFormation 或 AWS SAM (SAM) 範本。對於 AWS 區域 該支援 AWS Infrastructure Composer，它還提供將工作流程匯出至 Infrastructure Composer 的功能，並導覽至 Infrastructure Composer 主控台，您可以在其中繼續使用新產生的範本。
## 範本組態選項
此功能提供下列選項。如果您選擇匯出和下載 IaC 範本檔案，主控台會顯示適用於已儲存狀態機器的選項以供選取。如果您要匯出至 Infrastructure Composer，Step Functions 主控台會自動實作適用於您狀態機器的組態。
+ **包含主控台代表您建立的 IAM 角色** – 此選項會匯出執行角色政策。它會在範本中建構 IAM 角色，並將其連接到狀態機器資源。此選項僅適用於狀態機器具有由主控台建立的執行角色時。
+ **包含 CloudWatch Log Group** – 在範本中建構 CloudWatch 日誌群組，並將其連接到狀態機器資源。只有在狀態機器已連接 CloudWatch 日誌群組，且[日誌層級](cw-logs.md#cloudwatch-log-level)*未*設定為 時，此選項才適用`OFF`。
+ **以 DefinitionSubstitutions 取代資源參考** – 此選項會為下列元件產生 [DefinitionSubstitutions](concepts-sam-sfn.md#sam-definition-substitution-eg)：
+ [分散式映射](state-map-distributed.md) S3 欄位。
+ `Activity` 資源。匯出包含任何`Run Activity`任務之 CloudFormation 範本中的`Activity`資源。匯出也提供`DefinitionSubstitutions`參考已建立`Activity`的資源。
+ 所有服務整合`S3URI`的承載欄位中的任何 `ARN`或 。
+ 除了 `ARN`和 `S3URI` 欄位之外，匯出還會`DefinitionSubstitutions`為其他常用的服務整合承載欄位產生 。特定服務整合如下：
+ `athena:startQueryExecution`
+ `batch:submitJob`
+ `dynamodb:getItem`, `dynamodb:updateItem`, `dynamodb:updateItem`, `dynamodb:deleteItem`
+ `ecs:runTask`
+ `glue:startJobRun`
+ `http:invoke`
+ `lambda:invoke`
+ `sns:publish`
+ `sqs:sendMessage`
+ `states:startExecution`
## 匯出和下載工作流程的 IaC 範本
**將工作流程匯出至 IaC 範本檔案**
1. 開啟 [Step Functions 主控台](https://console.aws.amazon.com/states/home?region=us-east-1#/)，然後選取您要使用的狀態機器。在繼續下一個步驟之前，請確定已儲存狀態機器的任何變更。
1. 從**動作**功能表中選取**匯出至 CloudFormation 或 SAM 範本**。
1. 從出現的對話方塊中選取**類型**做為 **SAM** 或 **CloudFormation**。
+ 如果您選取 **CloudFormation** 範本，接下來選擇 **JSON** 或 **YAML** 檔案格式。
+ 如果您選取 **SAM** 範本，則不會顯示任何格式選項。SAM 範本預設為 YAML 檔案格式。
1. 展開**其他組態**。預設會選取所有選項。檢閱並更新 IaC 範本的選項選擇。這些選項會在上一節中詳細說明，標題為 [範本組態選項](#exporting-iac-templates-config-options)。
如果選項不適用於您的特定工作流程，則不會顯示在對話方塊中。
1. 選擇**下載**以匯出和下載產生的 IaC 範本檔案。
## 將您的工作流程直接匯出至 AWS Infrastructure Composer
**將您的工作流程匯出至 Infrastructure Composer**
1. 開啟 [Step Functions 主控台](https://console.aws.amazon.com/states/home?region=us-east-1#/)，然後選取您要使用的狀態機器。在繼續下一個步驟之前，請確定已儲存狀態機器的任何變更。
1. 從**動作**功能表中選取**匯出至基礎設施編寫器**。
1. 匯出**至基礎設施編寫器**對話方塊隨即顯示。您可以使用 **Transfer 儲存貯體名稱**欄位中顯示的預設名稱，或輸入新名稱。Amazon S3 儲存貯體的名稱必須是全域唯一的，並遵循[儲存貯體命名規則](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html)。
1. 選擇**確認並建立專案**，將您的工作流程匯出至 Infrastructure Composer。
1. 若要在 Infrastructure Composer 中儲存專案和工作流程定義，請啟用[本機同步模式](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html)。
**注意**
如果您之前已使用 **Export to Infrastructure Composer** 功能，並使用預設名稱建立 Amazon S3 儲存貯體，則 Step Functions 可以在儲存貯體仍然存在時重新使用此儲存貯體。接受對話方塊中的預設儲存貯體名稱，以重新使用現有儲存貯體。
### Amazon S3 傳輸儲存貯體組態
Step Functions 為傳輸工作流程所建立的 Amazon S3 儲存貯體會使用 AES 256 加密標準自動加密物件。Step Functions 也會將儲存貯體設定為使用[儲存貯體擁有者條件](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html)，以確保只有您的 AWS 帳戶 能夠將物件新增至儲存貯體。
預設儲存貯體名稱使用字首 `states-templates`、10 位數英數字串，以及 AWS 區域 您在 中建立工作流程的 ：`states-templates-amzn-s3-demo-bucket-us-east-1`。為避免將額外費用新增至您的 AWS 帳戶，我們建議您在完成將工作流程匯出至 Infrastructure Composer 後，立即刪除 Amazon S3 儲存貯體。
適用標準 [Amazon S3 定價](https://aws.amazon.com/s3/pricing/)。
### 所需的許可
若要搭配 Infrastructure Composer 使用這個 Step Functions 匯出功能，您需要特定許可才能下載 AWS SAM 範本並將範本組態寫入 Amazon S3。
若要下載 AWS SAM 範本，您必須具有使用下列 API 動作的許可：
+ [iam：GetPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html)
+ [iam:GetPolicyVersion](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicyVersion.html)
+ [iam:GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)
+ [iam:GetRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRolePolicy.html)
+ [iam:ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)
+ [iam:ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html)
+ [iam:ListRoles](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRoles.html)
若要讓 Step Functions 將函數的組態寫入 Amazon S3，您必須具有使用下列 API 動作的許可：
+ [S3:PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [S3:CreateBucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html)
+ [S3:PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)
如果您無法將函數組態匯出至 Infrastructure Composer，請檢查您的帳戶是否具有執行這些操作所需要的許可。