翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# Step Functions を使用したワークフローの開発
Step Functions コンソールと Workflow Studio ビジュアルエディタでワークフローの構築を開始することをお勧めします。空のキャンバスから開始することもできれば、一般的なシナリオの場合はスターターテンプレートを選択することもできます。
ワークフローを構築するには、次のタスクが必要です。
+ ワークフローの定義
+ ワークフローの実行とデバッグ
+ ワークフローのデプロイ
Amazon States Language でステートマシンを定義します。Amazon States Language の定義を手動で作成できますが、Workflow Studio はチュートリアルで取り上げられます。Workflow Studio を使用すると、マシン定義の定義、ステップの視覚化と編集、ワークフローの実行とデバッグ、および結果のすべてを Step Functions コンソール内で表示できます。
**Visual Studio Code での Workflow Studio の使用**
AWS ツールキットを使用すると、VS Code 内から Workflow Studio を使用して、ステートマシン内の個々の状態を視覚化、構築、テストすることもできます。ステートへの入力と変数を設定し、テストを開始すると、データがどのように変換されるかを確認できます。ワークフローを調整して再テストできます。完了したら、変更を適用してステートマシンを更新できます。詳細については、 AWS Toolkit for Visual Studio Codeの「[Workflow Studio の使用](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html)」を参照してください。
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 関数を呼び出す 1 つのステップでワークフローを定義し、ワークフローを実行して結果を表示する方法を示します。
## ワークフローの定義
ワークフロー開発の最初のステップは、Amazon States Language でステップを定義することです。設定とツールに応じて、Step Functions ステートマシンを JSON、YAML、または文字列化された Amazon States Language (ASL) 定義として定義できます。
次の表で、ツール別にサポートされる ASL ベースの定義の形式を示します。
| AWS ツール | サポートされる形式 |
| --- | --- |
| 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 は、 AWS SDKs for Java、.NET、Ruby、PHP、Python (Boto 3)、JavaScript、Go、C\$1\$1 でサポートされています。これらの SDK は、複数のプログラミング言語で Step Functions HTTPS API アクションを使用する便利な方法を提供します。これらの SDK ライブラリで公開されている API アクションを使用して、ステートマシン、アクティビティ、ステートマシンスターターを開発できます。また、これらのライブラリを使用して可視性オペレーションにアクセスし、独自の Step Functions のモニタリングおよびレポートツールを開発できます。現行の AWS SDK および [Amazon Web Services のツール](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 を使用して、機械学習モデルを処理してパブリッシュするワークフローを作成できます。 AWS インフラストラクチャを大規模に調整する Python の複数ステップの機械学習ワークフローを作成することもできます。 AWS Step Functions Data Science SDK は、Step Functions ワークフローを作成して呼び出すことができる Python API を提供します。これらのワークフローは、Python および Jupyter ノートブックで直接管理および実行できます。詳細については、「[GitHub のAWS Step Functions データサイエンスプロジェクト](https://github.com/aws/aws-step-functions-data-science-sdk-python)」、「[データサイエンス SDK ドキュメント](https://aws-step-functions-data-science-sdk.readthedocs.io/)」、「[Jupyter Notebook の例](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-nbexamples.html)」、「[GitHub の SageMaker の例](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/step-functions-data-science-sdk)」を参照してください。
## ワークフローの実行とデバッグ
ワークフローは、コンソールから、API コール (Lambda 関数など)、Amazon EventBridge および EventBridge スケジューラから、別の Step Functions ステートマシンからなど、さまざまな方法で開始できます。ワークフローを実行すると、サードパーティーのサービスに接続し、 AWS SDKs、実行中にデータを操作できます。ステートマシンを通過する実行ステップとデータの実行し、デバッグするために、さまざまなツールがあります。以下のセクションでは、ワークフローを実行およびデバッグするための追加のリソースを提供します。
ステートマシンの実行を開始する方法の詳細については、「[Step Functions でステートマシンの実行を開始する](statemachine-starting.md)」を参照してください。
**ワークフローを実行するエンドポイントを選択する**
レイテンシーを減らし、要件を満たす場所にデータを保存するために、Step Functions は異なる AWS リージョンのエンドポイントを提供します。Step Functions の各エンドポイントは完全に独立しています。ステートマシンまたはアクティビティは、それが作成されたリージョン内にのみ存在します。あるリージョンで作成されたステートマシンおよびアクティビティは、別のリージョンで作成されたものとデータや属性を共有しません。例えば、2 つの異なるリージョンに `STATES-Flows-1` というステートマシンを登録できます。一方のリージョンの `STATES-Flows-1` ステートマシンは、もう一方のリージョンの `STATES-Flow-1` ステートマシンとはデータや属性を共有しません。Step Functions エンドポイントのリストについては、「*AWS 全般のリファレンス*」の「[AWS Step Functions のリージョンとエンドポイント](https://docs.aws.amazon.com/general/latest/gr/step-functions.html)」を参照してください。
**VS Code での開発**
AWS ツールキットを使用すると、VS Code 内から Workflow Studio を使用して、ステートマシン内の個々の状態を視覚化、構築、テストすることもできます。SAM と CloudFormation の定義置換も使用できます。ステートへの入力と変数を設定し、テストを開始すると、データがどのように変換されるかを確認できます。[ステート定義] タブでワークフローを調整して再テストできます。完了したら、変更を適用してステートマシンを更新できます。詳細については、 AWS Toolkit for Visual Studio Codeの「[Step Functions の使用](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/bulding-stepfunctions.html)」および「[Workflow Studio の使用](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html)」を参照してください。
## ワークフローのデプロイ
ワークフローを定義してデバッグした後は、Infrastructure as Code フレームワークを使用してデプロイすることをお勧めします。ステートマシンは AWS Serverless Application Model、、、、Terraform など CloudFormation AWS CDK、さまざまな IaC オプションを使用してデプロイできます。
**AWS Serverless Application Model**
Step Functions AWS Serverless Application Model で を使用すると、ワークフローを構築し、Lambda 関数、APIs、イベントなどの必要なインフラストラクチャをデプロイして、サーバーレスアプリケーションを作成できます。統合エクスペリエンス AWS Toolkit for Visual Studio Code の一部として CLI AWS SAM を と組み合わせて使用することもできます。
詳細については、「[AWS SAM を使用して Step Functions ワークフローを構築する](concepts-sam-sfn.md)」を参照してください。
**CloudFormation**
ステートマシンの定義は、 CloudFormation テンプレートで直接使用できます。
詳細については、「[CloudFormation を使用して Step Functions でワークフローを作成する](tutorial-lambda-state-machine-cloudformation.md)」を参照してください。
**AWS CDK**
Standard ステートマシンと Express ステートマシンは、 を使用して構築できます AWS CDK。
Standard ワークフローを構築するには、「[CDK を使用して Standard ワークフローを作成する](tutorial-lambda-state-machine-cdk.md)」を参照してください。
Express ワークフローを構築するには、「[CDK を使用して Express ワークフローを作成する](tutorial-step-functions-rest-api-integration-cdk.md)」を参照してください。
**Terraform**
[Terraform](https://www.terraform.io/intro/) by HashiCorp は、Infrastructure as Code (IaC) を使用してアプリケーションを構築するためのフレームワークです。Terraform では、ステートマシンを作成したり、インフラストラクチャデプロイのプレビューや再利用可能なテンプレートの作成などの機能を使用したりできます。Terraform テンプレートを使用すると、コードが小さなチャンクに分割されるため、コードを保守して再利用しやすくなります。
詳細については、「[Terraform を使用して Step Functions でステートマシンをデプロイする](terraform-sfn.md)」を参照してください。
# Step Functions Workflow Studio でのワークフローの開発
AWS Step Functions コンソールでワークフローを編集するときは、Workflow Studio と呼ばれるビジュアルツールを使用します。Workflow Studio では、ステートをキャンバスにドラッグアンドドロップしてワークフローを構築できます。また、ステートの追加、編集、設定、入力/出力フィルターの設定、結果の変換、エラー処理の設定が可能です。
ワークフローの状態を変更すると、Workflow Studio はステートマシン定義を検証して自動生成します。組み込みのコードエディタを使用して、生成されたコードの確認、設定の編集、テキスト定義の変更を行うことができます。完了したら、ワークフローを保存して実行し、結果を調べることができます。
Workflow Studio には Step Functions コンソールからアクセスして、ワークフローを作成または編集します。
また、ビジュアルデザイナーである AWS Infrastructure Composer **内**で Workflow Studio を使用して、 AWS Serverless Application Model と AWS CloudFormation で Infrastructure as Code を作成することもできます。このアプローチの利点については、「[Infrastructure Composer の Workflow Studio を使用する](use-wfs-in-app-composer.md)」を参照してください。
Workflow Studio には、**[デザイン]**、**[コード]**、および **[設定]** の 3 つのモードがあります。*[デザイン] モード*では、状態をキャンバスにドラッグアンドドロップできます。*[コード] モード*には、コンソール内でワークフロー定義を編集するための組み込みコードエディタが用意されています。*[設定] モード*では、ワークフロー設定を管理できます。
**Visual Studio Code での Workflow Studio の使用**
AWS ツールキットを使用すると、VS Code 内から Workflow Studio を使用して、ステートマシン内の個々の状態を視覚化、構築、テストすることもできます。ステートへの入力と変数を設定し、テストを開始すると、データがどのように変換されるかを確認できます。ワークフローを調整して再テストできます。完了したら、変更を適用してステートマシンを更新できます。詳細については、 AWS Toolkit for Visual Studio Codeの「[Workflow Studio の使用](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html)」を参照してください。
## デザインモード
[デザイン] モードには、プロトタイプを作成する際にワークフローを可視化するグラフィカルインターフェイスがあります。次の図は、Workflow Studio の **[デザイン]** モードの状態ブラウザ、ワークフローキャンバス、インスペクター、コンテキストヘルプパネルを示しています。
![\[状態ブラウザ、ワークフローキャンバス、インスペクター、ヘルプパネルを示す [デザイン] モードのスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/step-functions/latest/dg/images/wfs_main_01.png)
1. モードボタンは 3 つのモード間で切り替わります。ASL ワークフロー定義が無効な場合、モードを切り替えることはできません。
1. [[State browser] (状態ブラウザ)](#workflow-studio-components-states) には次の 3 つのタブがあります。
+ Actions ****タブには、キャンバスのワークフローグラフにドラッグアンドドロップできる AWS APIs のリストが表示されます。各アクションは [Task ワークフロー状態](state-task.md) 状態を示します。
+ **[フロー]** タブは、キャンバス内のワークフローのグラフにドラッグアンドドロップできるフロー状態のリストを表示します。
+ **[パターン]** タブには、さまざまなユースケースに使用できる、すぐに使える再利用可能なビルディングブロックがいくつか用意されています。例えば、これらのパターンを使用して Amazon S3 バケットのデータを繰り返し処理できます。
1. [キャンバスとワークフローのグラフ](#workflow-studio-components-grapheditor) は、状態をワークフローのグラフにドラッグアンドドロップし、状態の順序を変更します。状態を選択して、状態を設定または表示に選択します。
1. [インスペクターパネル](#workflow-studio-components-formdefinition) パネルでは、キャンバス上で選択した任意の状態のプロパティを表示および編集できます。**[定義]** トグルをオンにすると、現在選択されているステートが強調表示された状態で、ワークフローの Amazon States Language コードが表示されます。
1. **[Info]** (情報) リンクは、ヘルプが必要になるとコンテキスト情報を含むパネルを開きます。これらのパネルには、Step Functions ドキュメントの関連トピックへのリンクも含まれます。
1. デザインツールバー - 元に戻す、削除、ズームインなどの一般的なアクションを実行するボタンのセットが含まれています。
1. ユーティリティボタン - ワークフローの保存や、ASL 定義を JSON ファイルや YAML ファイルにエクスポートするなどのタスクを実行するためのボタンのセットです。
### [State browser] (状態ブラウザ)
[状態ブラウザ] では、ワークフローのキャンバスにドラッグアンドドロップする状態を選択できます。Actions ****タブには、サードパーティーの HTTP エンドポイントと AWS APIs。**[フロー]** タブには、ワークフローを指示および制御できる状態のリストが表示されます。フローの状態には、Choice、Parallel、Map、Pass、Wait、Success、Fail が含まれます。**[パターン]** タブには、すぐに使用できる再利用可能な事前定義の構成要素が用意されています。パネルの上部にある検索ボックスを使用して、すべての状態タイプを検索できます。
![\[アクション、フロー、パターン、検索を示すスクリーンショットの図解コレクション。\]](http://docs.aws.amazon.com/ja_jp/step-functions/latest/dg/images/wfe-states-browser-01.png)
### キャンバスとワークフローのグラフ
ワークフローに追加する状態を選択した後、キャンバスにドラッグし、ワークフローのグラフにドロップできます。状態をドラッグアンドドロップして、ワークフロー内で移動することもできます。ワークフローが大きい場合は、ズームインまたはズームアウトして、ワークフローグラフのさまざまな部分をキャンバスで表示できます。
### インスペクターパネル
右側の **[インスペクター]** パネルからワークフローに追加する状態を設定できます。設定する状態を選択すると、**[Inspector]** パネルにその設定オプションが表示されます。ワークフローコード用に自動生成された [ASL 定義](concepts-amazon-states-language.md)を確認するには、**[定義]** トグルをオンにします。選択した状態に関連付けられている ASL 定義がハイライトされます。
![\[設定パネルを示す Workflow Studio インスペクターのスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/step-functions/latest/dg/images/wfe-forms-definitions-01.png)
![\[コード定義を示す Workflow Studio インスペクターパネルのスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/step-functions/latest/dg/images/wfs-code-mode.png)
1. モードボタンは 3 つのモード間で切り替わります。ASL ワークフロー定義が無効な場合、モードを切り替えることはできません。
1. ここで [コードエディタ](#wfs-interface-code-editor) は、Workflow Studio 内でワークフローの [ASL 定義](concepts-amazon-states-language.md)を記述して編集します。コードエディタには、構文の強調表示やオートコンプリートなどの機能もあります。
1. [グラフの視覚化](#wfs-interface-code-graph-viz) - ワークフローをリアルタイムでグラフィカルに可視化します。
1. ユーティリティボタン - ワークフローの保存や、ASL 定義を JSON ファイルや YAML ファイルにエクスポートするなどのタスクを実行するためのボタンのセットです。
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 の **[設定]** モードでは、ステートマシンの一般的な設定を管理できます。このモードでは、次のような設定を指定できます。
+ **詳細**: ワークフローの**名前**と**タイプ**を設定します。ステートマシンの作成後に両方を変更することは**できません**。
+ **アクセス許可**: 新しいロール (推奨) の作成、既存のロールの選択、または特定のロールの ARN の入力を行うことができます。新しいロールを作成するオプションを選択すると、Step Functions は最小特権を使用してステートマシンの実行ロールを作成します。生成された IAM ロールは、ステートマシンを作成する AWS リージョン に対して有効です。作成前に、Step Functions がステートマシンに対して自動的に生成するアクセス許可を確認できます。
+ **ログ記録**: ステートマシンのログレベルを有効にして設定できます。Step Functions は、選択内容に基づいて実行履歴イベントを記録します。オプションとして、ログの暗号化にカスタマーマネージドキーを使用できます。ログレベルの詳細については、「[Step Functions 実行イベントのログレベル](cw-logs.md#cloudwatch-log-level)」を参照してください。
**[追加設定]** で、以下の**オプション**の設定を 1 つ以上設定できます。
+ **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)
## ステートマシンを作成する
Workflow Studio では、スターターテンプレートを選択するか、空白のテンプレートを選択してワークフローを作成できます。
スターターテンプレートは、ワークフロープロトタイプと定義を自動的に作成し、プロジェクトに必要なすべての関連 AWS リソースを にデプロイするready-to-runサンプルプロジェクトです 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. **[次へ]** を選択して続行します。
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) のワークフローの設定を管理します。例えば、ワークフローの名前を入力し、そのタイプを選択します。
## ワークフローの設計
追加する状態の名前がわかっている場合は、[[State browser] (状態ブラウザ)](workflow-studio.md#workflow-studio-components-states) の上部にある検索ボックスを使用して検索します。それ以外の場合は、ブラウザで必要な状態を探し、キャンバスに追加します。
ワークフロー内の別の場所にドラッグして、ワークフローの状態を並べ替えることができます。状態をキャンバスにドラッグすると、次のスクリーンショットに示すように、状態がワークフローに挿入される場所を示す線が表示されます。
![\[状態の宛先を示す青い線が表示されたスクリーンショットの例。\]](http://docs.aws.amazon.com/ja_jp/step-functions/latest/dg/images/wfe-design-02.png)
状態がキャンバスにドロップされると、そのコードが自動生成され、ワークフロー定義内に追加されます。定義を確認するには、[インスペクターパネル](workflow-studio.md#workflow-studio-components-formdefinition)の**[定義]** トグルをオンにします。[コードモード](workflow-studio.md#wfs-interface-code-mode) を選択して、組み込みコードエディタを使用して定義を編集できます。
ステートをキャンバスにドロップすると、右側の [インスペクターパネル](workflow-studio.md#workflow-studio-components-formdefinition) パネルでそのステートを設定できます。このパネルには、キャンバスに配置した各ステートまたは API アクションの **[設定]**、**[入力]**、**[出力]**、および **[エラー処理]** タブがあります。ワークフローに含めるステートは、**[設定]** タブで設定します。
例えば、Lambda Invoke API アクションの **[設定]** タブは次のオプションを提供しています。
+ **状態名**: 状態をカスタム名で識別するか、デフォルト生成名を受け入れることができます。
+ **[API]** には、ステートが使用する API アクションが表示されます。
+ **統合タイプ**: 他のサービスで API アクションを呼び出すために使用されるサービス統合タイプを選択できます。
+ **[関数名]** には、次のオプションがあります。
+ **[Enter a function name]** (関数名を入力): 関数名またはその ARN を入力できます。
+ **[Get function name at runtime from state input]** (状態入力からランタイムに関数名を取得): このオプションを使用すると、指定したパスに基づいて、状態入力から関数名を動的に取得できます。
+ **[Select function name]** (関数名を選択): アカウントとリージョンで利用可能な機能から直接選択できます。
+ **ペイロード**: 状態入力、JSON オブジェクト、またはペイロードなしのいずれかを使用して、Lambda 関数にペイロードとして渡すことができます。JSON を選択した場合、静的な値と状態入力から選択した値を両方とも含めることができます。
+ (オプション) 一部の状態には、**[タスクが完了するまで待機]** または **[コールバックを待つ]** を選択するオプションがあります。使用可能な場合、次の[サービス統合パターン](connect-to-resource.md)の一つを選択できます。
+ **[No option selected]** (オプションの選択なし): Step Functions は [レスポンスのリクエスト](connect-to-resource.md#connect-default) 統合パターンを使用します。Step Functions は HTTP 応答を待ってから、次の状態に進みます。Step Functions はジョブが完了するまで待機することはしません。使用可能なオプションがない場合、状態はこのパターンを使用します。
+ **[Wait for task to complete]** (タスクの完了を待つ): Step Functions は [ジョブの実行 (.sync)](connect-to-resource.md#connect-sync) 統合パターンを使用します。
+ **[Wait for callback]** (コールバックを待つ): 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 入力内の既存のキーと値のペアへの参照パスを指定します。
+ **[Next state]** (次の状態) 次に移行したい状態を選択できます。
+ (オプション) **[コメント]** フィールドはワークフローには影響しませんが、ワークフローに注釈を付けるために使用できます。
一部の状態には、さらに包括的な設定オプションがあります。例えば、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 がデータを記録できなくなるため、Step Functions のメトリクスを追跡できるように ASCII 文字のみを使用することをお勧めします。
1. (オプション) **[入力]** ボックスに、JSON 形式の入力値を入力してワークフローを実行します。
1. **[実行のスタート]** を選択します。
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) でワークフロー定義を編集することもできます。**[コード]** ボタンを選択して、Workflow 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 または [Infrastructure Composer で Workflow Studio](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 Send Message 状態については、**[キュー URL]** を選択し、その後、**[キュー URL を入力]** を選択します。プレースホルダーキュー URL を入力します。
+ Amazon SNS 発行ステートの場合は、**[トピック]** からトピック ARN を選択します。
+ **[Actions]** (アクション) の下にリストされている他の状況すべてについては、デフォルト設定を使用できます。
**注記**
ワークフローにエラーが見つかった場合は、**[デザイン]** モードで修正する必要があります。ワークフローにエラーがある場合は、**[コード]** モードまたは **[設定]** モードに切り替えることはできません。
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 を使用して状態の入力と出力を設定する
**ステートの管理とデータの変換**
[変数を使用したステート間のデータ受け渡し](workflow-variables.md)と [JSONata を使用したデータ変換](transforming-data.md)について説明します。
各状態は、受け取った入力に基づいて決定を下すか、アクションを実行します。ほとんどの場合、出力を他の状態に渡します。Workflow Studio では、[インスペクターパネル](workflow-studio.md#workflow-studio-components-formdefinition) パネルの **[入力]** タブおよび **[出力]** タブでステートが入力と出力データをフィルタリングし、操作する方法を設定できます。**[Info]** リンクを使用して、入力と出力を設定する時にコンテキストヘルプにアクセスします。
![\[状態入力、出力、および情報ヘルプパネルを示すスクリーンショットの例\]](http://docs.aws.amazon.com/ja_jp/step-functions/latest/dg/images/wfs_input_output_01.png)
Step Functions の入出力処理方法の詳細については、[Step Functions の入力および出力処理](concepts-input-output-filtering.md) を参照してください。
## 状態へ入力を構成する
各状態は、前の状態からの入力を JSON として受け取ります。入力をフィルターする場合は、[インスペクターパネル](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 ]
```
[Parallel ワークフローの状態](state-parallel.md)、[Map 状態のワークフロー](state-map.md)、[Pass ワークフロー状態](state-pass.md) フローには、**[入力]** タブで `Parameters` と呼ばれる追加の入力フィルタリングオプションがあります。このフィルターは InputPath フィルターの後に有効になり、1 つ以上のキーバリューペアで構成されるカスタム JSON オブジェクトを構築するために使用できます。各ペアの値は、静的な値のいずれかとなり、入力から選択するか、パスを使って [Step Functions の Context オブジェクトから実行データにアクセスする](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]** 内の **[出力]** タブでリストされます。[Task ワークフロー状態](state-task.md) 状態では、選択した出力フィルターは次の順序で処理されます。
1. `ResultSelector`: 状態の結果を操作するためにこのフィルターを使用します。結果の一部を使用して新しい JSON オブジェクトを作成できます。
1. `Step Functions で ResultPath を使用してステートの出力を指定する`: このフィルターを使用して、出力に渡す状態入力とタスク結果の組み合わせを選択します。
1. `OutputPath を使用したステートの出力のフィルタリング`: このフィルターを使用して、JSON 出力をフィルターして、結果からどの情報を次の状態に渡すのか選択します。
### ResultSelector の使用
`ResultSelector` は、次の状態に対するオプションの出力フィルターです。
+ [Task ワークフロー状態](state-task.md) 状態とは、[[State browser] (状態ブラウザ)](workflow-studio.md#workflow-studio-components-states) の **[アクション]** タブにあげられているすべての状態です。
+ 状態ブラウザの **[フロー]** タブにある [Map 状態のワークフロー](state-map.md) 状態。
+ 状態ブラウザの **[フロー]** タブにある [Parallel ワークフローの状態](state-parallel.md) 状態。
`ResultSelector` を使用して、1 つ以上のキーバリューペアで構成されるカスタム JSON オブジェクトを作成できます。各ペアの値は、静的な値にすることも、状態の結果からパスで選択することもできます。
**注記**
パラメータでパスを使用して、結果内の JSON ノードをリファレンスにするように指定するには、パラメータ名の末尾を `.$` で終了します。
**Example ResultSelector フィルターの使用例**
この例では、`ResultSelector` を使って、Amazon EMR `CreateCluster` 状態の Amazon EMR CreateCluster API コールからのレスポンスを操作します。以下は、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` は、次の状態に対するオプションの出力フィルターです。
+ [Task ワークフロー状態](state-task.md) 状態は、状態ブラウザの **[アクション]** パネルにあげられているすべての状態です。
+ 状態ブラウザの **[フロー]** タブにある [Map 状態のワークフロー](state-map.md) 状態。
+ 状態ブラウザの **[フロー]** タブにある [Parallel ワークフローの状態](state-parallel.md) 状態。
+ 状態ブラウザの **[フロー]** タブにある [Pass ワークフロー状態](state-pass.md) 状態。
`ResultPath` は、結果を元の状態の入力に追加するために使用できます。指定されたパスは、結果を追加する場所を示します。
**Example ResultPath フィルターの使用例**
次のものがタスクステートへの入力であるとします。
```
{
"details": "Default example",
"who": "AWS Step Functions"
}
```
タスクステートの結果は次のとおりです。
```
Hello, AWS Step Functions
```
`ResultPath` を適用し、`$.taskresult` のように、結果を追加する場所を示すリファレンス[パス](amazon-states-language-paths.md)を入力して、状態の入力にこの結果を追加します。
この `ResultPath` を使って、状態の出力として渡される JSON を次に示します。
```
{
"details": "Default example",
"who": "AWS Step Functions",
"taskresult": "Hello, AWS Step Functions!"
}
```
### OutputPath を使用する
`OutputPath` フィルターを使うと、不要な情報をフィルターして、必要な一部の JSON のみを渡すことができるようになります。`OutputPath` は `$` で始まる文字列で、JSON テキスト内のノードを識別します。
**Example OutputPath フィルターの使用例**
Lambda Invoke API コールが Lambda 関数の結果に加えてメタデータを返すとしましょう。
```
{
"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 Invoke 状態の **[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 のサービス やリソースに対してアクションを実行したり、HTTPS API を呼び出したりするアクセス許可をステートマシンに付与する AWS Identity and Access Management (IAM) ロールが必要です。このロールは、実行ロール**と呼ばれます。
この実行ロールには、ステートマシンが AWS Lambda 関数を呼び出したり、AWS Batch ジョブを実行したり、Stripe API を呼び出したりすることを許可する IAM ポリシーなど、アクションごとのポリシーが含まれている必要があります。Step Functions では、次の場合に実行ロールを指定する必要があります。
+ [CreateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html) API を使用して、コンソール、AWS SDK、または AWS CLI でステートマシンを作成する場合。
+ [TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html) API を使用して、コンソール、AWS SDK、または AWS CLI でステートを[テスト](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 API を呼び出す [HTTP タスク](call-https-apis.md)。
+ [最適化された統合](integrate-optimized.md) を使用して他の AWS のサービス を呼び出す、[Lambda Invoke](connect-lambda.md)、[DynamoDB GetItem](connect-batch.md)、または [AWS Glue StartJobRun](connect-glue.md) などのタスクステート。
+ [ネストされたワークフロー](connect-stepfunctions.md)を実行するタスクステート。
+ 子ワークフロー実行の開始、Amazon S3 バケットのリスト、S3 オブジェクトの読み取りと記述などの[ポリシー](iam-policies-eg-dist-map.md)を含む、[分散マップ状態](state-map-distributed.md)。
+ [X-Ray](concepts-xray-tracing.md) トレース。Workflow Studio で自動生成されるすべてのロールには、X-Ray にトレースを送信するアクセス許可をステートマシンに付与する[ポリシー](concepts-xray-tracing.md#xray-iam)が含まれています。
+ ステートマシンでロギングが有効になっている場合の [CloudWatch Logs を使用した Step Functions の実行履歴のログ記録](cw-logs.md)。
Workflow Studio は、[AWS SDK 統合](supported-services-awssdk.md)を使用して他の AWS のサービス を呼び出すタスクステートの IAM ポリシーを生成できません。
## ロールを自動生成する
1. [Step Functions コンソール](https://console.aws.amazon.com/states/home)を開き、メニューから **[ステートマシン]** を選択したら、**[ステートマシンの作成]** を選択します。
既存のステートマシンを更新することもできます。ステートマシンを更新する場合は、ステップ 4 を参照してください。
1. **[空白から作成]** を選択します。
1. ステートマシンに名前を付け、**[続行]** を選択して Workflow Studio でステートマシンを編集します。
1. **[設定]** タブを選択します。
1. **[アクセス許可]** セクションまでスクロールして、次の操作を行います。
1. **[実行ロール]** では、デフォルトの **[新しいロールを作成]** を選択したままにしてください。
Workflow Studio は、ステートマシン定義内の有効なステートごとに、必要なすべての IAM ポリシーを自動的に生成します。**[完全なアクセス許可で実行ロールが作成されます]** というメッセージを含むバナーが表示されます。
![\[自動生成されたアクセス許可のプレビューを含む Config タブのスクリーンショットの例。\]](http://docs.aws.amazon.com/ja_jp/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. ステートマシンを作成する場合は **[作成]** を選択します。問題がなければ、[**保存**] を選択します。
1. 表示されるダイアログボックスで、**[確認]** を選択します。
Workflow Studio はステートマシンを保存し、新しい実行ロールを作成します。
## ロール生成に関する問題を解決する
以下の場合、Workflow Studio は必要なすべてのアクセス許可を含む実行ロールを自動的に生成できません。
+ ステートマシンにエラーがある。Workflow Studio の検証エラーをすべて解決してください。また、保存中に発生したサーバー側のエラーには必ず対処してください。
+ ステートマシンに AWS SDK 統合を使用するタスクが含まれている。この場合、Workflow Studio は IAM ポリシーを[自動生成](#auto-generating-roles)できません。Workflow Studio には、**[特定のアクションのアクセス許可は自動生成できません] というメッセージを含むバナーが表示されます。IAM ロールは部分的なアクセス許可のみで作成されます。****[自動生成アクセス許可の確認]** テーブルで、**[ステータス]** の内容を選択すると、実行ロールにないポリシーの詳細が表示されます。Workflow Studio は引き続き実行ロールを生成できますが、このロールにはすべてのアクションの IAM ポリシーが含まれるわけではありません。独自のポリシーを作成し、生成後にロールに追加するには、**[ドキュメントリンク]** の下のリンクを参照してください。これらのリンクは、ステートマシンを保存した後でも使用できます。
## Workflow Studio で HTTP タスクをテストするためのロール
HTTP Task ステートの[テスト](call-https-apis.md#http-task-test)には、実行ロールが必要です。十分なアクセス許可を持つロールがない場合は、以下のオプションのいずれかを使用してロールを作成してください。
+ **Workflow Studio でロールを自動生成する (推奨)** — これは安全なオプションです。**[ステートをテスト]** ダイアログボックスを閉じて、[ロールを自動生成する](#auto-generating-roles) の指示に従います。そのためには、まずステートマシンを作成または更新してから、Workflow Studio に戻ってステートをテストする必要があります。
+ **管理者アクセス権を持つロールを使用する** — AWS 内のすべてのサービスとリソースへの完全なアクセスを持つロールを作成するアクセス許可がある場合は、そのロールを使用してワークフロー内のあらゆるタイプのステートをテストできます。これを行うには、IAM コンソール [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)を呼び出す Task ステートには、実行ロールが必要です。十分なアクセス許可を持つロールがない場合は、以下のオプションのいずれかを使用してロールを作成してください。
+ **Workflow Studio でロールを自動生成する (推奨)** — これは安全なオプションです。**[ステートをテスト]** ダイアログボックスを閉じて、[ロールを自動生成する](#auto-generating-roles) の指示に従います。そのためには、まずステートマシンを作成または更新してから、Workflow Studio に戻ってステートをテストする必要があります。
+ **管理者アクセス権を持つロールを使用する** — AWS 内のすべてのサービスとリソースへの完全なアクセスを持つロールを作成するアクセス許可がある場合は、そのロールを使用してワークフロー内のあらゆるタイプのステートをテストできます。これを行うには、IAM コンソール [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 で AWS SDK サービス統合をテストするためのロール
[AWSSDK 統合](supported-services-awssdk.md)を呼び出す Task ステートにも、実行ロールが必要です。十分なアクセス許可を持つロールがない場合は、以下のオプションのいずれかを使用してロールを作成してください。
+ **Workflow Studio でロールを自動生成する (推奨)** — これは安全なオプションです。**[ステートをテスト]** ダイアログボックスを閉じて、[ロールを自動生成する](#auto-generating-roles) の指示に従います。そのためには、まずステートマシンを作成または更新してから、Workflow Studio に戻ってステートをテストする必要があります。以下の操作を実行します。
1. **[ステートをテスト]** ダイアログボックスを閉じます。
1. **[設定]** タブを選択し、設定モードを表示します。
1. **[アクセス許可]** セクションまで下にスクロールします。
1. Workflow Studio には、**[特定のアクションのアクセス許可は自動生成できません] というメッセージを含むバナーが表示されます。IAM ロールは部分的なアクセス許可のみで作成されます。****[自動生成されたアクセス許可を確認]** を選択します。
1. **[自動生成されたアクセス許可を確認]** テーブルには、テストするタスクステートに対応するアクションを示す行が表示されます。カスタムロールに独自の IAM ポリシーを記述するには、**[ドキュメントリンク]** の下のリンクを参照してください。
+ **管理者アクセス権を持つロールを使用する** — AWS 内のすべてのサービスとリソースへの完全なアクセスを持つロールを作成するアクセス許可がある場合は、そのロールを使用してワークフロー内のあらゆるタイプのステートをテストできます。これを行うには、IAM コンソール [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 でフローステートをテストするには実行ロールが必要です。フローステートは、[Choice ワークフローの状態](state-choice.md)、[Parallel ワークフローの状態](state-parallel.md)、[Map 状態のワークフロー](state-map.md)、[Pass ワークフロー状態](state-pass.md)、[Wait ワークフロー状態](state-wait.md)、[Succeed ワークフロー状態](state-succeed.md)、または [ワークフロー状態に失敗する](state-fail.md) などの実行フローを指示する状態です。[TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html) API は Map ステートや Parallel ステートでは機能しません。次のいずれかのオプションを使用してフロー状態をテストするためのロールを作成します。
+ **AWS アカウント の任意のロールを使用 (推奨)** — Flow ステートでは AWS アクションやリソースを呼び出さないため、特定の IAM ポリシーは必要ありません。そのため、AWS アカウント ではどの IAM ロールでも使用できます。
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 内のすべてのサービスとリソースへの完全なアクセスを持つロールを作成するアクセス許可がある場合は、そのロールを使用してワークフロー内のあらゆるタイプのステートをテストできます。これを行うには、IAM コンソール [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)をそのサービスロールに追加します。
# Step Functions で Workflow Studio を使用してエラー処理を設定する
**ステートの管理とデータの変換**
[変数を使用したステート間のデータ受け渡し](workflow-variables.md)と [JSONata を使用したデータ変換](transforming-data.md)について説明します。
Workflow Studio ビジュアルエディタでエラー処理を設定できます。デフォルトでは、ステートでエラーが報告されると、Step Functions の実行全体が失敗します。アクションといくつかのフロー状態については、Step Functions のエラー処理方法を設定できます。
エラー処理を設定した場合でも、一部のエラーによってワークフロー実行が失敗する可能性があります。詳細については、「[Step Functions ワークフローでのエラー処理](concepts-error-handling.md)」を参照してください。Workflow Studio で、エラー処理を [インスペクターパネル](workflow-studio.md#workflow-studio-components-formdefinition) の **[エラー処理]** タブで設定します。
## エラーを再試行
1 つ以上のルールをアクション状態と [Parallel ワークフローの状態](state-parallel.md) フロー状態に追加し、エラーが発生したときにタスクを再試行できます。これらのルールは *retriers* と呼ばれます。retrier を追加するには、**[Retrier \$11]** ボックスで編集アイコンを選択し、そのオプションを設定します。
+ (オプション) **[コメント]** フィールドで、コメントを追加します。ワークフローには影響しませんが、ワークフローに注釈を付けるために使用できます。
+ **[エラー]** フィールドにカーソルを置き、retrier をトリガーするエラーを選択するか、カスタムエラー名を入力します。複数のエラーを選択または追加できます。
+ (オプション) **[Interval]** (間隔) を設定します。これは、Step Functions が最初の再試行を行うまでの秒単位の時間です。追加の再試行は、**[Max attempts]** (最大試行回数) と **[Backoff rate]** (バックオフ率) で設定できる間隔の後で行われます。
+ (オプション) **[Max attempts]** (最大試行回数) を設定します。これは、Step Functions の実行が失敗するまでの最大再試行回数です。
+ (オプション) **[Backoff rate]** (バックオフ率) を設定します。これは、試行ごとに再試行間隔がどのくらい増加するかを決定する乗数です。
**注記**
どんなエラー処理オプションでも、あらゆる状態で利用できるわけではありません。Lambda Invoke には、デフォルトで retrier が 1 つが設定されています。
## エラーの捕捉
1 つ以上のルールをアクション状態に追加し、エラーをキャッチするため、[Parallel ワークフローの状態](state-parallel.md) と [Map 状態のワークフロー](state-map.md) フロー状態に追加できます。これらのルールは *catchers* と呼ばれます。キャッチャーを追加するには、**[Add new catcher]** (新しいキャッチャーの追加) を選択し、そのオプションを設定します。
+ (オプション) **[コメント]** フィールドで、コメントを追加します。ワークフローには影響しませんが、ワークフローに注釈を付けるために使用できます。
+ **[エラー]** フィールドにカーソルを置き、catcher をトリガーするエラーを選択するか、カスタムエラー名を入力します。複数のエラーを選択または追加できます。
+ **[フォールバック状態]** フィールドで、[フォールバック状態](concepts-error-handling.md#error-handling-fallback-states)を選択します。これは、エラーがキャッチされた後にワークフローが次へと移動する状態です。
+ (オプション) **[ResultPath]** フィールドで、`ResultPath` フィルターを追加して、元の状態入力にエラーを追加します。[`ResultPath`](input-output-resultpath.md) は有効な [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/) である必要があります。これはフォールバック状態に送信されます。
## タイムアウト
アクション状態のタイムアウトを設定して、失敗する前に状態を実行できる最大秒数を設定できます。タイムアウトを使用して実行のスタックを回避する タイムアウトを設定するには、実行が失敗するまでの状態の待機秒数を入力します。タイムアウトの詳細については、[Task ワークフロー状態](state-task.md) ステートの「`TimeoutSeconds`」を参照してください。
## HeartbeatSeconds
*ハートビート*または、タスクから定期的に送信される通知を設定できます。ハートビート間隔を設定し、設定された間隔で状態がハートビート通知を送信しない場合、タスクは失敗としてマークされます。ハートビートを設定するには、0 以外の正の整数の秒数を設定します。詳細については、[Task ワークフロー状態](state-task.md) ステートの「`HeartBeatSeconds`」を参照してください。
# Infrastructure Composer で Workflow Studio を使用して Step Functions ワークフローを構築する
Infrastructure Composer で使用できる Workflow Studio は、ワークフローの設計と構築に役立ちます。Infrastructure Composer の Workflow Studio にはビジュアル Infrastructure as Code (IaC) 環境が用意されているため、CloudFormation テンプレートなどの IaC ツールを使用して構築されたサーバーレスアプリケーションにワークフローを簡単に組み込むことができます。
AWS Infrastructure Composer は、シンプルなグラフィカルインターフェイスを使用して AWS SAM および AWS CloudFormation テンプレートを開発するのに役立つビジュアルビルダーです。ではInfrastructure Composer、ビジュアルキャンバス AWS のサービス でドラッグ、グループ化、接続してアプリケーションアーキテクチャを設計します。 Infrastructure Composer は、 コマンドラインインターフェイス (AWS SAM CLI) AWS SAM または を使用してアプリケーションをデプロイするために使用できる IaC テンプレートを設計から作成します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 テンプレートでリソース設定を生成します。 は、ワークフローの実行に必要なIAMアクセス許可Infrastructure Composerも追加します。Infrastructure Composer の Workflow Studio を使用すると、アプリケーションのプロトタイプを作成して、本番環境ですぐに使えるアプリケーションに転換することができます。
Infrastructure Composer の Workflow Studio を使用する際は、Infrastructure Composer キャンバスと Workflow Studio を自由に切り替えることができます。
**Topics**
+ [Infrastructure Composer の Workflow Studio を使用する](#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)
+ [AWS Infrastructure Composer の Workflow Studio で使用できない機能](#wfs-features-unavailable-app-composer)
## Infrastructure Composer の Workflow Studio を使用してサーバーレスワークフローを構築する
1. [Infrastructure Composer コンソール](https://console.aws.amazon.com/composer/home)を開き、**[プロジェクトを作成]** を選択してプロジェクトを作成します。
1. **[リソース]** パレットの検索フィールドに、「**state machine**」と入力します。
1. **[Step Functions ステートマシン]** リソースをキャンバスにドラッグします。
1. **[Workflow Studio で編集]** を選択し、ステートマシンリソースを編集します。
次のアニメーションは、Workflow Studio に切り替えてステートマシン定義を編集する方法を示しています。
![\[Infrastructure Composer の Workflow Studio の使用方法を示すアニメーション。\]](http://docs.aws.amazon.com/ja_jp/step-functions/latest/dg/images/use-wfs-in-app-composer.gif)
Infrastructure Composer で作成されたステートマシンのリソースを編集するための Workflow Studio との統合は、[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 の定義の置換を使用してリソースを動的に参照する
Workflow Studio では、ワークフロー定義で CloudFormation 定義の置換を使用して、IaC テンプレートで定義したリソースを動的に参照できます。`${dollar_sign_brace}` 表記を使用してワークフロー定義にプレースホルダー置換を追加すると、CloudFormation スタックの作成プロセス中に実際の値に置き換えられます。定義の置換の詳細については、「[AWS SAM テンプレート内の DefinitionSubstitutions](concepts-sam-sfn.md#sam-definition-substitution-eg)」を参照してください。
次のアニメーションは、ステートマシンの定義におけるリソースのプレースホルダー置換の方法を示します。
![\[ステートマシンのリソースにプレースホルダー置換を追加する方法を示すアニメーション。\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/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/ja_jp/step-functions/latest/dg/images/manual-update-placeholder-mapping.gif)
## 既存のプロジェクトをインポートしてローカルに同期する
Infrastructure Composer で既存の CloudFormation プロジェクトや AWS SAM プロジェクトを開いて視覚化し、理解を深めたり、デザインを変更したりできます。Infrastructure Composer の[ローカル同期](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html)機能を使用すると、テンプレートとコードファイルをローカルビルドマシンに自動的に同期して保存できます。ローカル同期モードを使用すると、既存の開発フローを補完できます。ブラウザが [File System Access 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。この機能では、 AWS SAM スキーマとして IaC テンプレートを作成し、 に移動しますInfrastructure Composer。詳細については、「[IaC テンプレートへのワークフローのエクスポート](exporting-iac-templates.md)」を参照してください。
## AWS Infrastructure Composer の Workflow Studio で使用できない機能
Infrastructure Composer の Workflow Studio を使用すると、Workflow Studio の一部の機能が使用できなくなります。さらに、[インスペクターパネル](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)」を参照してください。
次のリストでは、Infrastructure Composer の Workflow Studio を使用する際に使用できない Workflow Studio の機能について説明します。
+ [スターターテンプレート](starter-templates.md) - スターターテンプレートは、ワークフローのプロトタイプと定義を自動的に作成する、すぐに実行できるサンプルプロジェクトです。これらのテンプレートは、プロジェクトに必要なすべての関連 AWS リソースを にデプロイします AWS アカウント。
+ [設定モード](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 **[メニュー]** から **[開く]** > **[プロジェクトフォルダ]** を選択します。Infrastructure Composer キャンバス内の変更がローカルマシンに直接自動的に保存されるように、[ローカル同期](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html)モードを有効にしていることを確認してください。
+ **[実行]** ボタン。Infrastructure Composer の Workflow Studio を使用すると、Infrastructure Composer はワークフロー用の IaC コードを生成します。したがって、テンプレートをデプロイする必要があります。次に、コンソールまたは AWS Command Line Interface (AWS CLI) を使用してワークフローを実行します。
# AWS SAM を使用して Step Functions ワークフローを構築する
Step Functions AWS Serverless Application Model で を使用すると、ワークフローを構築し、Lambda 関数、APIs、イベントなどの必要なインフラストラクチャをデプロイして、サーバーレスアプリケーションを作成できます。
統合エクスペリエンス AWS Toolkit for Visual Studio Code の一部として AWS Serverless Application Model CLI を と組み合わせて使用して、 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 サンプルテンプレートの使用を開始します。
+ ステートマシンをサーバーレスアプリケーションにビルドします。
+ 変数置換を使用して、デプロイ時に ARN をステートマシンに置き換えます。
AWS CloudFormation は、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) をサポートしています。`${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 リソースをオーケストレーションして、複雑で堅牢なワークフローを作成できます。
## SAM CLI との Step Functions の統合
Step Functions は CLI AWS SAM と統合されています。これを使用して、ステートマシンをサーバーレスアプリケーションにすばやく開発します。
[を使用して Step Functions ステートマシンを作成する AWS SAM](tutorial-state-machine-using-sam.md) チュートリアルを試 AWS SAM して、 を使用してステートマシンを作成する方法を学習します。
サポートされている AWS SAM CLI 関数は次のとおりです。
| CLI コマンド | 説明 |
| --- | --- |
| 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 テンプレートを受け取り、指定されたリージョンにアプリケーションを公開します。 |
**注記**
local を使用する場合は AWS SAM 、Lambda と API Gateway をローカルでエミュレートできます。ただし、 を使用して Step Functions をローカルでエミュレートすることはできません AWS SAM。
## AWS SAM テンプレート内の DefinitionSubstitutions
ステートマシンは、AWS SAM で CloudFormation テンプレートを使用して定義できます。AWS SAM では、ステートマシンをテンプレート内でインラインで定義するか、別個のファイルに定義できます。以下の AWS SAM テンプレートには、株取引のワークフローをシミュレートするステートマシンが含まれています。このステートマシンは 3 つの Lambda 関数を呼び出して、株の価格を確認し、株を売買するかを決定します。その後、この取引は Amazon DynamoDB テーブルに記録されます。次のテンプレートの Lambda 関数と DynamoDB テーブルの ARN は、[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
```
以下のコードは、[を使用して Step Functions ステートマシンを作成する AWS SAM](tutorial-state-machine-using-sam.md) チュートリアルで使用する、`stock_trader.asl.json` ファイルのステートマシン定義です。このステートマシン定義には、`${dollar_sign_brace}` 表記で示される複数の `DefinitionSubstitutions` が含まれています。例えば、`Check Stock Value` タスクに静的 Lambda 関数 ARN を指定する代わりに、置換 `${StockCheckerFunctionArn}` が使用されます。この置換はテンプレートの [DefinitionSubstitutions](#sam-template-def-substitution) プロパティで定義されます。`DefinitionSubstitutions` はステートマシンリソースのキーと値のペアのマップです。`DefinitionSubstitutions` では、\$1\$1StockCheckerFunctionArn\$1 は CloudFormation 組み込み関数 [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) を使用して `StockCheckerFunction` リソースの ARN にマッピングされます。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
}
}
}
```
## 次の手順
AWS SAM で Step Functions を使用する方法の詳細については、次のリソースを参照してください。
+ [を使用して 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) を検索します。
+ Step Functions と共に [AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions.html) を使用
+ AWS SAMで利用できる機能の詳細については「[AWS SAM CLI リファレンス](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html)」を確認してください。
Infrastructure Composer の Workflow Studio などのビジュアルビルダーを使用して、Infrastructure as Code (IaC) でワークフローを設計および構築することもできます。詳細については、「[Infrastructure Composer で Workflow Studio を使用して Step Functions ワークフローを構築する](use-wfs-in-app-composer.md)」を参照してください。
# CloudFormation を使用して Step Functions でワークフローを作成する
このチュートリアルでは、 を使用して AWS Lambda 関数を作成します AWS CloudFormation。 CloudFormation コンソールと YAML テンプレートを使用して*スタック* (IAM ロール、Lambda 関数、ステートマシン) を作成します。その後、Step Functions コンソールを使用してステートマシンの実行を開始します。
詳細については、*AWS CloudFormation ユーザーガイド*の [CloudFormation テンプレートの使用](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html)と `[AWS::StepFunctions::StateMachine](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.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 関数を作成するには
`Hello World` というメッセージを印刷する Lambda 関数の以下のプロパティを定義します。
**重要**
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. 以下のサンプルデータを YAML 例の `MyStateMachine.yaml`、あるいは JSON の `MyStateMachine.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. **[Options]** (オプション) ページで、**[Next]** (次へ) を選択します。
1. **[Review]** (レビュー) ページで、**[I acknowledge that CloudFormation might create resources]** ( によるIAM リソース作成の可能性があることを認める) を選択し、**[Create]** (作成) を選択します。
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 がデータを記録できなくなるため、Step Functions のメトリクスを追跡できるように ASCII 文字のみを使用することをお勧めします。
1. **[実行のスタート]** を選択します。
ステートマシンの新しい実行がスタートされ、実行中の実行が表示されている新しいページが表示されます。
1. (オプション) **[実行の詳細]** で、**[実行ステータス]**、および **[開始]** と **[終了]** のタイムスタンプを確認します。
1. 実行結果を表示するには、**[Output]** (出力) タブを選択します。
# AWS CDK を使用して Step Functions で標準ワークフローを作成する
AWS Cloud Development Kit (AWS CDK) Infrastructure as Code (IAC) フレームワークを使用して、AWS Lambda 関数を含む AWS Step Functions ステートマシンを作成できます。
CDKでサポートされている言語のいずれかを使用して AWS インフラストラクチャを定義します。インフラストラクチャを定義したら、アプリケーションを CloudFormation テンプレートに合成し、 AWS アカウントにデプロイします。
この方法を使用して、Lambda 関数を含む Step Functions ステートマシンを定義し、Step Functions AWS マネジメントコンソールを使用してステートマシンを実行します。
このチュートリアルを開始する前に、「*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 で次のコマンドを使用して AWS CDK をインストールします。
```
npm install -g aws-cdk
```
このチュートリアルでは、[CloudFormation を使用して Step Functions でワークフローを作成する](tutorial-lambda-state-machine-cloudformation.md) と同じ結果になります。ただし、このチュートリアルでは、AWS CDK では IAM ロールの作成は必要なく、代わりに AWS CDK が作成します。AWS CDK バージョンには、ステートマシンにさらにステップを追加する方法を説明する [Succeed ワークフロー状態](state-succeed.md) ステップも含まれています。
**ヒント**
TypeScript AWS CDKで を使用して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 関数を作成するには
次のものは、Lambda 関数を定義する AWS CDK コードで、ソースコードをインラインで提供します。
------
#### [ 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 アプリケーションのソースコードに文字列として埋め込まれている関数のソースコード。
+ 使用するランタイム (Node 18.x)、関数のエントリポイント、タイムアウトなど、その他の関数属性。
### ステートマシンを作成するには
ステートマシンには、Lambda 関数タスクと [Succeed ワークフロー状態](state-succeed.md) 状態の 2 つの状態があります。この関数では、関数を呼び出す Step Functions [Task ワークフロー状態](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 がデータを記録できなくなるため、Step Functions のメトリクスを追跡できるように ASCII 文字のみを使用することをお勧めします。
1. **[実行のスタート]** を選択します。
ステートマシンの実行が開始され、実行中の実行が表示されている新しいページが表示されます。
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)
# AWS CDK を使用して Step Functions で Express ワークフローを作成する
このチュートリアルでは、Infrastructure as Code (IAC) フレームワークを使用して、同期エクスプレスステートマシンをバックエンド統合として API Gateway REST API AWS Cloud Development Kit (AWS CDK) を作成する方法について説明します。
このチュートリアルでは、`StepFunctionsRestApi` コンストラクトを使用してステートマシンを API Gateway に接続します。`StepFunctionsRestApi` コンストラクトは、必要なアクセス許可と HTTP「ANY」メソッドを使用して、デフォルトの入出力マッピングと API Gateway REST API を設定します。
AWS CDK は Infrastructure as Code (IAC) フレームワークで、プログラミング言語を使用して AWS インフラストラクチャを定義します。CDK でサポートされている言語のいずれかでアプリケーションを定義し、コードを CloudFormation テンプレートに合成してから、インフラストラクチャを AWS アカウントにデプロイします。
CloudFormation を使用して、同期 Express ステートマシンと統合された API Gateway REST API をバックエンドとして定義し、 を使用して実行 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の**構築する**コマンドを使用します。
------
#### [ C\$1 ]
```
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.Stepfunctions
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.APIGateway
```
また、Visual Studio NuGet GUIを使用して、示されたパッケージをインストールすることもできます。**ツール** > **NuGet パッケージマネージャー** > **ソリューションの 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 ]
`stepfunctions-rest-api.go` 内の `import` に次のものを追加します。
```
"github.com/aws/aws-cdk-go/awscdk/awsapigateway"
"github.com/aws/aws-cdk-go/awscdk/awsstepfunctions"
```
------
## ステップ 2: AWS CDK を使用して、同期 Express ステートマシンバックエンド統合で 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`。
+ マシンの定義がステートマシン定義として使用されます。
+ `StepFunctionsRestApi` は同期高速ステートマシンのみを許可するため、ステートマシンタイプは `EXPRESS` に設定されています。
### `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. `StepFunctionsRestApi` という名前の REST API を選択します。
1. **[リソース]** ペインで、`ANY` メソッドを選択します。
1. **[テスト]** タブを選択します。タブを表示するには、右矢印ボタンを選択する必要がある場合があります。
1. [**Method (メソッド)**] で [**POST**] を選択します。
1. **[リクエスト本文]** には、以下のリクエストパラメータをコピーします。
```
{
"key": "Hello"
}
```
1. **[テスト]** を選択します。次の情報が表示されます。
+ [**リクエスト**]: メソッド用に呼び出されたリソースのパスです。
+ [**ステータス**]: 応答の HTTP ステータスコードです。
+ [**レイテンシー**]: 発信者からリクエストを受信してから応答を返すまでの時間です。
+ **[レスポンス本文]** は HTTP レスポンスの本文です。
+ **[レスポンスヘッダー]** は HTTP レスポンスのヘッダーです。
+ **[ログ]** にはシミュレートされた Amazon CloudWatch Logs エントリが表示され、このメソッドが API Gateway コンソール外で呼び出された場合は書き込まれています。
**注記**
CloudWatch Logs エントリはシミュレートされていますが、メソッドの呼び出しの結果は現実のものです。
**[レスポンス本文]** の出力は、次のようになります。
```
"Hello"
```
**ヒント**
さまざまなメソッドと無効な入力で API Gateway を試して、エラー出力を確認してください。特定のキーを検索するステートマシンを変更し、テスト中に間違ったキーを指定してステートマシンの実行を失敗させ、**[レスポンス本文]** の出力にエラーメッセージを生成させる場合があります。
### 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"
```
**ヒント**
さまざまなメソッドと無効な入力で API Gateway を試して、エラー出力を確認してください。特定のキーを検索するステートマシンを変更し、テスト中に間違ったキーを指定してステートマシンの実行を失敗させ、**[レスポンス本文]** の出力にエラーメッセージを生成させる場合があります。
## ステップ 4: クリーンアップする
API Gateway の試行が完了したら、AWS CDK を使用してステートマシンと API Gateway の両方をティアダウンできます。アプリケーションのメインディレクトリで `cdk destroy` を発行します。
# Terraform を使用して Step Functions でステートマシンをデプロイする
[Terraform](https://www.terraform.io/intro/) by HashiCorp は、Infrastructure as Code (IaC) を使用してアプリケーションを構築するためのフレームワークです。Terraform では、ステートマシンを作成したり、インフラストラクチャデプロイのプレビューや再利用可能なテンプレートの作成などの機能を使用したりできます。Terraform テンプレートを使用すると、コードが小さなチャンクに分割されるため、コードを保守して再利用しやすくなります。
Terraform に精通していれば、Terraform でステートマシンを作成してデプロイするためのモデルとして、このトピックで説明する開発ライフサイクルをたどることができます。Terraform に慣れていない場合は、まず「[AWS Introduction to Terraform on ](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 を使用するには、Step Functions Local の Docker イメージをインストールすることをお勧めします。詳細については、「[Step Functions Local を使用したステートマシンのテスト (非サポート)](sfn-local.md)」を参照してください。
+ CLI AWS SAM をインストールします。インストールの詳細については、「 *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 を使ったステートマシン開発について説明してベストプラクティスの詳細を示す完全な例を見るには、「[Best Practices for Writing Step Functions Terraform Projects](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/ja_jp/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 API とのサービス統合をローカルでテストすることもできます。
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 ポリシーの以下の例では、`myFunction` という Lambda 関数を呼び出すためのアクセス権をステートマシンに付与します。
****
```
{
"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` データソースを使用して、`myFunction` という Lambda 関数を呼び出すためのアクセス権をステートマシンに付与します。
```
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 examples](https://serverlessland.com/workflows?framework=Terraform)」を参照してください。
# IaC テンプレートへのワークフローのエクスポート
AWS Step Functions コンソールで、保存されたワークフローを AWS CloudFormation または AWS SAM (SAM) テンプレートとしてエクスポートおよびダウンロードできるようになりました。AWS Infrastructure Composer をサポートしている AWS リージョン では、ワークフローを Infrastructure Composer にエクスポートし、Infrastructure Composer コンソールに移動して、新しく生成されたテンプレートで作業を続行できるようになりました。
## テンプレート設定オプション
この機能では、次のオプションを使用できます。IaC テンプレートファイルをエクスポートおよびダウンロードする際、保存したステートマシンに適用されるオプションがコンソールに表示されます。Infrastructure Composer にエクスポートする場合、Step Functions コンソールにより、ステートマシンに適用される設定が自動的にテンプレートに実装されます。
+ **コンソールによって作成された IAM ロールを含める** – このオプションでは、実行ロールのポリシーをテンプレートにエクスポートします。これにより、テンプレート内に IAM ロールが構築され、ステートマシンリソースにアタッチされます。このオプションは、ステートマシンにコンソールによって作成された実行ロールがある場合にのみ適用されます。
+ **CloudWatch ロググループを含める** – このオプションでは、テンプレート内に 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` リソースがすべて含まれます。エクスポートには、作成された `Activity` リソースを参照する `DefinitionSubstitutions` も含まれます。
+ すべてのサービス統合のペイロードフィールドに含まれる `ARN` または `S3URI`。
+ `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. **[アクション]** メニューから **[Infrastructure Composer にエクスポート]** を選択します。
1. **[Infrastructure Composer にエクスポート]** ダイアログボックスが表示されます。**[転送バケット名]** フィールドに表示されるデフォルト名をそのまま使用するか、新しい名前を入力できます。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)を有効にします。
**注記**
以前に **[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 にエクスポートできない場合は、アカウントにこれらのオペレーションに必要なアクセス許可があることを確認してください。