Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Verwenden CloudFormation , um einen Workflow in Step Functions zu erstellen
In diesem Tutorial erstellen Sie eine AWS Lambda Funktion mit AWS CloudFormation. Sie verwenden die CloudFormation Konsole und eine YAML-Vorlage, um einen *Stack* (IAM-Rollen, die Lambda-Funktion und die Zustandsmaschine) zu erstellen. Anschließend verwenden Sie die Step Functions Functions-Konsole, um die Ausführung der Zustandsmaschine zu starten.
Weitere Informationen finden Sie unter [Arbeiten mit CloudFormation Vorlagen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) und in der entsprechenden `[AWS::StepFunctions::StateMachine](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)` Ressource im *AWS CloudFormation Benutzerhandbuch*.
## Schritt 1: Richten Sie Ihre CloudFormation Vorlage ein
Bevor Sie die [Beispielvorlagen](#lambda-state-machine-cfn-step-2) verwenden, sollten Sie verstehen, wie die verschiedenen Teile einer CloudFormation -Vorlage deklariert werden.
### So erstellen Sie eine IAM-Rolle für Lambda
Definieren Sie die Vertrauensrichtlinie, die der IAM-Rolle für die Lambda-Funktion zugeordnet ist. Die folgenden Beispiele definieren eine Vertrauensrichtlinie, die entweder YAML oder JSON verwendet.
------
#### [ 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"
}
]
}
}
```
------
### So erstellen Sie eine Lambda-Funktion
Definieren Sie die folgenden Eigenschaften für eine Lambda-Funktion, die die Nachricht `Hello World` ausgibt.
**Wichtig**
Stellen Sie sicher, dass sich Ihre Lambda-Funktion unter demselben AWS Konto und AWS-Region wie Ihre Zustandsmaschine befindet.
------
#### [ 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"
}
},
```
------
### Um eine IAM-Rolle für die State-Machine-Ausführung zu erstellen
Definieren Sie die Vertrauensrichtlinie, die der IAM-Rolle für die State-Machine-Ausführung zugeordnet ist.
------
#### [ 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": "*"
}
]
}
}
]
}
},
```
------
### So erstellen Sie eine Lambda-Zustandsmaschine
Definieren Sie die Lambda-Zustandsmaschine.
------
#### [ 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"
]
}
}
}
```
------
## Schritt 2: Verwenden Sie die CloudFormation Vorlage, um eine Lambda State Machine zu erstellen
Sobald Sie die Komponenten der CloudFormation Vorlage verstanden haben, können Sie sie zusammenfügen und die Vorlage verwenden, um einen CloudFormation Stack zu erstellen.
### Um die Lambda-Zustandsmaschine zu erstellen
1. Kopieren Sie die folgenden Beispieldaten in eine Datei mit dem Namen `MyStateMachine.yaml` für das YAML-Beispiel oder `MyStateMachine.json` für 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. Öffnen Sie die [CloudFormation -Konsole](https://console.aws.amazon.com/cloudformation/home) und wählen Sie **Create Stack (Stack erstellen)** aus.
1. Wählen Sie auf der Seite **Select Template (Vorlage auswählen)** **Upload a template to Amazon S3 (Eine Vorlage zu Amazon S3 hochladen)** aus. Wählen Sie Ihre Datei `MyStateMachine` und anschließend **Next** aus.
1. Geben Sie auf der Seite **Specify Details (Details angeben)** unter **Stack name (Stack-Name)** `MyStateMachine` ein und wählen Sie dann **Next (Weiter)** aus.
1. Wählen Sie auf der Seite **Optionen** **Weiter** aus.
1. Wählen Sie auf der Seite **„Überprüfen**“ die Option **Ich bestätige, dass CloudFormation möglicherweise IAM-Ressourcen erstellt** werden. und wählen Sie dann **Erstellen**.
CloudFormation beginnt mit der Erstellung des `MyStateMachine` Stacks und zeigt den Status **CREATE\$1IN\$1PROGRESS** an. Wenn der Prozess abgeschlossen ist, zeigt CloudFormation den Status **CREATE\$1COMPLETE** an.
1. (Optional) Wählen Sie zum Anzeigen der Ressourcen in Ihrem Stack den Stack und anschließend die Registerkarte **Resources** aus.
## Schritt 3: Starten Sie eine State Machine-Ausführung
Nachdem Sie Ihre Lambda-Zustandsmaschine erstellt haben, können Sie deren Ausführung starten.
### Starten der Ausführung des Zustandsautomaten
1. Öffnen Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home) und wählen Sie den Namen der Zustandsmaschine aus, mit der Sie erstellt haben CloudFormation.
1. Wählen Sie auf der ***MyStateMachine-ABCDEFGHIJ1K***Seite **Neue Ausführung** aus.
Die Seite **New execution** wird angezeigt.
1. (Optional) Geben Sie einen benutzerdefinierten Ausführungsnamen ein, um den generierten Standard zu überschreiben.
**Nicht-ASCII-Namen und Protokollierung**
Step Functions akzeptiert Namen für Zustandsmaschinen, Ausführungen, Aktivitäten und Labels, die Nicht-ASCII-Zeichen enthalten. Da solche Zeichen Amazon CloudWatch daran hindern, Daten zu protokollieren, empfehlen wir, nur ASCII-Zeichen zu verwenden, damit Sie die Step Functions Functions-Metriken verfolgen können.
1. Wählen Sie **Start Execution** aus.
Eine neue Ausführung Ihres Zustandsautomaten startet und eine neue Seite mit Ihrer laufenden Ausführung wird angezeigt.
1. (Optional) Überprüfen Sie unter **Execution Details (Ausführungsdetails)** den **Execution Status (Ausführungsstatus)** sowie die Zeitstempel **Started (Gestartet)** und **Closed (Geschlossen)**.
1. Um die Ergebnisse Ihrer Ausführung anzuzeigen, wählen Sie **Output (Ausgabe)**.