

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.

# Entwicklung von Workflows mit Step Functions
<a name="developing-workflows"></a>

Wir empfehlen, mit der Erstellung von Workflows in der Step Functions Functions-Konsole und dem visuellen Editor von Workflow Studio zu beginnen. Sie können mit einer leeren Arbeitsfläche beginnen oder Startvorlagen für allgemeine Szenarien auswählen.

Für die Erstellung Ihrer Workflows sind die folgenden Aufgaben erforderlich:
+ Definieren Sie Ihren Workflow
+ Ihren Workflow ausführen und debuggen
+ Bereitstellen Ihres Workflows

Sie definieren eine Zustandsmaschine in der Sprache Amazon States. Sie können Ihre Amazon States-Sprachdefinitionen manuell erstellen, Workflow Studio wird jedoch in Tutorials vorgestellt. Mit Workflow Studio können Sie Ihre Maschinendefinition definieren, die Schritte visualisieren und bearbeiten, Ihren Workflow ausführen und debuggen und die Ergebnisse anzeigen — alles von der Step Functions Functions-Konsole aus.

**Arbeiten mit Workflow Studio in Visual Studio Code**  
Mit dem AWS Toolkit können Sie Workflow Studio von VS Code aus verwenden, um einzelne Zustände in Ihren Zustandsmaschinen zu visualisieren, zu erstellen und sogar zu testen. Sie geben Zustandseingaben ein und legen Variablen fest, starten den Test und können dann sehen, wie Ihre Daten transformiert werden. Sie können den Arbeitsablauf anpassen und erneut testen. Wenn Sie fertig sind, können Sie die Änderungen anwenden, um die Zustandsmaschine zu aktualisieren. Weitere Informationen finden Sie unter [Arbeiten mit Workflow Studio](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html) in der AWS Toolkit for Visual Studio Code. 

Sie können auch viele Funktionen von Step Functions aus AWS Command Line Interface (AWS CLI) verwenden. Sie können beispielsweise eine Zustandsmaschine erstellen und Ihre vorhandenen Zustandsmaschinen auflisten. Sie können Step Functions Functions-Befehle in verwenden, AWS CLI um Ausführungen zu starten und zu verwalten, Aktivitäten abzufragen, Task-Heartbeats aufzuzeichnen und vieles mehr. Eine vollständige Liste der Step Functions Functions-Befehle, Beschreibungen der verfügbaren Argumente und Beispiele für ihre Verwendung finden Sie in der *AWS CLI Befehlsreferenz*. [AWS CLI Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/)

AWS CLI Die Befehle orientieren sich eng an der Sprache von Amazon States, sodass Sie die verwenden können, AWS CLI um mehr über die API-Aktionen von Step Functions zu erfahren. Sie können auch Ihre vorhandenen API-Kenntnisse verwenden, um Code zu prototypisieren oder Step Functions Functions-Aktionen von der Befehlszeile aus auszuführen.

**Validierung von State-Machine-Definitionen**  
Sie können die API verwenden, um Zustandsmaschinen zu **validieren** und potenzielle Probleme zu finden, bevor Sie Ihren Workflow erstellen.  
Weitere Informationen zur Validierung von Workflows finden Sie [ValidateStateMachineDefinition](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ValidateStateMachineDefinition.html)in der Step Functions API-Referenz.

Um mit minimalem Setup zu beginnen, können Sie dem Tutorial [Creating a Lambda State Machine](tutorial-creating-lambda-state-machine.md) folgen, das Ihnen zeigt, wie Sie einen Workflow mit einem einzigen Schritt definieren, der eine Lambda-Funktion aufruft, dann den Workflow ausführen und die Ergebnisse anzeigen.

## Definieren Sie Ihren Workflow
<a name="development-define"></a>

Der erste Schritt bei der Entwicklung Ihres Workflows besteht darin, die Schritte in der Sprache von Amazon States zu definieren. Je nach Ihren Vorlieben und Ihrem Tool können Sie Ihre Step Functions Functions-Zustandsmaschinen in JSON, YAML oder als stringifizierte Amazon States Language (ASL) -Definition definieren.

Die folgende Tabelle zeigt die Unterstützung des ASL-basierten Definitionsformats nach Tool. 


| AWS Werkzeug | Unterstützte (s) Format (e) | 
| --- | --- | 
| Step Functions Functions-Konsole | JSON | 
| HTTPS-Service-API | Stringifizierte ASL | 
| AWS CLI | Stringifizierte ASL | 
| Step Functions Lokal | Stringifizierte ASL | 
| AWS Toolkit for Visual Studio Code | JSON, YAML | 
| AWS SAM | JSON, YAML | 
| CloudFormation | JSON, YAML, stringifizierte ASL | 

Einzeilige YAML-Kommentare in der State-Machine-Definition einer Vorlage werden nicht in die Definition der erstellten Ressource übernommen. Wenn Sie einen Kommentar beibehalten müssen, sollten Sie die `Comment` Eigenschaft in der State-Machine-Definition verwenden. Weitere Informationen finden Sie unter [Struktur der Zustandsmaschine](statemachine-structure.md).

Mit CloudFormation und AWS SAM können Sie Ihre State-Machine-Definitionen in Amazon S3 (JSON- oder YAML-Format) hochladen und den Amazon S3 S3-Speicherort der Definition in der Vorlage angeben. Weitere Informationen finden Sie auf der Seite [AWS::StepFunctions::StateMachine S3Location](https://docs.aws.amazon.com//AWSCloudFormation/latest/UserGuide/aws-properties-stepfunctions-statemachine-s3location.html). 

Die folgenden CloudFormation Beispielvorlagen zeigen, wie Sie dieselbe State-Machine-Definition mit unterschiedlichen Eingabeformaten bereitstellen können. 

------
#### [ 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
```

------

**Entwickeln Sie Workflows mit AWS SDKs**  
Step Functions wird von den AWS SDKs für Java, .NET, Ruby, PHP, Python (Boto 3) JavaScript, Go und C\$1\$1 unterstützt. Diese SDKs bieten eine bequeme Möglichkeit, die HTTPS-API-Aktionen von Step Functions in mehreren Programmiersprachen zu verwenden. Sie können Zustandsautomaten, Aktivitäten oder Zustandsautomat-Starter mithilfe der API-Aktionen entwickeln, die von diesen SDK-Bibliotheken bereitgestellt werden. Mithilfe dieser Bibliotheken können Sie auch auf Sichtbarkeitsoperationen zugreifen, um Ihre eigenen Überwachungs- und Berichtstools von Step Functions zu entwickeln. In der Referenzdokumentation finden Sie die aktuelle Version AWS SDKs und die [Tools für Amazon Web Services](https://aws.amazon.com/tools/).

**Entwickeln Sie Workflows mithilfe von HTTPS-Anfragen**  
Step Functions bietet Serviceoperationen, auf die über HTTPS-Anfragen zugegriffen werden kann. Sie können diese Operationen verwenden, um direkt mit Step Functions aus Ihren eigenen Bibliotheken zu kommunizieren. Sie können mithilfe der Service-API-Aktionen Zustandsautomaten, Worker oder Zustandsautomaten-Starter entwickeln. Sie können über die API-Aktionen auch auf Sichtbarkeitsoperationen zugreifen, um Ihre eigenen Überwachungs- und Reporting-Tools zu entwickeln. Einzelheiten finden Sie in der [AWS Step Functions API-Referenz](https://docs.aws.amazon.com/step-functions/latest/apireference/).

**Entwickeln Sie Workflows mit dem AWS Step Functions Data Science SDK**  
Datenwissenschaftler können Workflows erstellen, die mithilfe von SageMaker KI und Step Functions Modelle für maschinelles Lernen verarbeiten und veröffentlichen. Sie können auch mehrstufige Workflows für maschinelles Lernen in Python erstellen, die die AWS Infrastruktur in großem Umfang orchestrieren. Das AWS Step Functions Data Science SDK bietet eine Python-API, mit der Step Functions Functions-Workflows erstellt und aufgerufen werden können. Sie können diese Workflows direkt in Python sowie in Jupyter-Notebooks verwalten und ausführen. Weitere Informationen finden Sie unter: [AWS Step Functions Data Science Project auf Github](https://github.com/aws/aws-step-functions-data-science-sdk-python), [Data Science SDK-Dokumentation](https://aws-step-functions-data-science-sdk.readthedocs.io/) und [Beispiel-Jupyter-Notebooks](https://docs.aws.amazon.com/sagemaker/latest/dg/howitworks-nbexamples.html) und [SageMaker KI-Beispiele](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/step-functions-data-science-sdk) auf. GitHub

## Ausführen und Debuggen Ihrer Workflows
<a name="development-run-debug"></a>

Sie können Workflows auf verschiedene Arten starten, z. B. über die Konsole, einen API-Aufruf (z. B. über eine Lambda-Funktion), über Amazon EventBridge und EventBridge Scheduler oder über eine andere Step Functions Functions-Zustandsmaschine. Beim Ausführen von Workflows kann eine Verbindung zu Diensten von Drittanbietern hergestellt und während der Ausführung Daten verwendet AWS SDKs und bearbeitet werden. Es gibt verschiedene Tools, mit denen Sie die Ausführungsschritte und Daten, die durch Ihre Zustandsmaschine fließen, ausführen und debuggen können. In den folgenden Abschnitten finden Sie zusätzliche Ressourcen zum Ausführen und Debuggen Ihrer Workflows. 

Weitere Informationen darüber, wie Sie State-Machine-Ausführungen starten können, finden Sie unter. [State-Machine-Ausführungen in Step Functions starten](statemachine-starting.md)

**Wählen Sie einen Endpunkt für die Ausführung Ihrer Workflows**  
Um die Latenz zu reduzieren und Daten an einem Ort zu speichern, der Ihren Anforderungen entspricht, bietet Step Functions Endpunkte in verschiedenen AWS Regionen. Jeder Endpunkt in Step Functions ist völlig unabhängig. Zustandsautomaten oder Aktivitäten existieren nur in der Region, in der sie erstellt wurden. Alle Zustandsmaschinen und Aktivitäten, die Sie in einer Region erstellen, teilen keine Daten oder Attribute mit denen, die in einer anderen Region erstellt wurden. Sie können beispielsweise einen Zustandsmaschine registrieren, der `STATES-Flows-1` in zwei verschiedenen Regionen benannt ist. Die `STATES-Flows-1` Zustandsmaschine in einer Region teilt keine Daten oder Attribute mit der `STATES-Flow-1` Zustandsmaschine in der anderen Region. Eine Liste der Step Functions Functions-Endpunkte finden Sie unter [AWS Step Functions Regionen und Endpunkte](https://docs.aws.amazon.com/general/latest/gr/step-functions.html) in der. *Allgemeine AWS-Referenz*

**Entwicklung mit VS Code**  
Mit dem AWS Toolkit können Sie Workflow Studio von VS Code aus verwenden, um einzelne Zustände in Ihren Zustandsmaschinen zu visualisieren, zu erstellen und sogar zu testen. Sie können auch Ihr SAM und CloudFormation Definitionsersetzungen verwenden. Sie geben Zustandseingaben ein und legen Variablen fest, starten den Test und können dann sehen, wie Ihre Daten transformiert werden. Auf der Registerkarte Statusdefinition können Sie den Workflow anpassen und erneut testen. Wenn Sie fertig sind, können Sie die Änderungen anwenden, um den Zustandsmaschine zu aktualisieren. Weitere Informationen finden Sie unter [Arbeiten mit Step Functions](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/bulding-stepfunctions.html) und [Arbeiten mit Workflow Studio](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html) in der AWS Toolkit for Visual Studio Code. 

## Bereitstellen Ihrer Workflows
<a name="development-deploy"></a>

Nachdem Sie Ihre Workflows definiert und debuggt haben, möchten Sie sie wahrscheinlich mithilfe von Infrastructure-as-Code-Frameworks bereitstellen. Sie können wählen, ob Sie Ihre Zustandsmaschinen mithilfe einer Vielzahl von IaC-Optionen bereitstellen möchten, darunter: AWS Serverless Application Model, CloudFormation AWS CDK, und Terraform.

**AWS Serverless Application Model**  
Sie können Step Functions verwenden AWS Serverless Application Model , um Workflows zu erstellen und die Infrastruktur bereitzustellen, die Sie benötigen, einschließlich Lambda-Funktionen APIs und Ereignisse, um serverlose Anwendungen zu erstellen. Sie können die AWS SAM CLI auch in Verbindung mit der AWS Toolkit for Visual Studio Code als Teil einer integrierten Erfahrung verwenden.  
Weitere Informationen finden Sie unter [Zum Erstellen von Step Functions Functions-Workflows verwenden AWS SAM](concepts-sam-sfn.md).

**CloudFormation**  
Sie können Ihre State-Machine-Definitionen direkt in CloudFormation Vorlagen verwenden.  
Weitere Informationen finden Sie unter [Verwenden CloudFormation , um einen Workflow in Step Functions zu erstellen](tutorial-lambda-state-machine-cloudformation.md).

**AWS CDK**  
Sie können Standard- und Express-Zustandsmaschinen mit erstellen AWS CDK.  
Informationen zum Erstellen eines Standard-Workflows finden Sie unter[Verwenden von CDK zum Erstellen eines Standard-Workflows](tutorial-lambda-state-machine-cdk.md).  
Informationen zum Erstellen eines Express-Workflows finden Sie unter[Verwenden von CDK zum Erstellen eines Express-Workflows](tutorial-step-functions-rest-api-integration-cdk.md).

**Terraform**  
[Terraform](https://www.terraform.io/intro/) by HashiCorp ist ein Framework für die Erstellung von Anwendungen unter Verwendung von Infrastructure as Code (IaC). Mit Terraform können Sie Zustandsmaschinen erstellen und Funktionen wie die Vorschau von Infrastrukturbereitstellungen und die Erstellung wiederverwendbarer Vorlagen verwenden. Terraform-Vorlagen helfen Ihnen dabei, den Code zu verwalten und wiederzuverwenden, indem sie ihn in kleinere Abschnitte aufteilen.  
Weitere Informationen finden Sie unter [Verwendung von Terraform zur Bereitstellung von Zustandsmaschinen in Step Functions](terraform-sfn.md).

# Entwicklung von Workflows in Step Functions Workflow Studio
<a name="workflow-studio"></a>

Wenn Sie einen Workflow in der AWS Step Functions Konsole bearbeiten, verwenden Sie ein visuelles Tool namens Workflow Studio. Mit Workflow Studio können Sie drag-and-drop Status auf einer Arbeitsfläche anzeigen, um Ihre Workflows zu erstellen. Sie können Status hinzufügen, bearbeiten und konfigurieren, Eingabe- und Ausgabefilter festlegen, Ergebnisse transformieren und die Fehlerbehandlung einrichten.

Wenn Sie Status in Ihrem Workflow ändern, validiert und generiert Workflow Studio automatisch die State-Machine-Definition. Mit dem integrierten Code-Editor können Sie den generierten Code überprüfen, die Konfiguration bearbeiten und sogar die Textdefinition ändern. Wenn Sie fertig sind, können Sie Ihren Workflow speichern, ausführen und dann die Ergebnisse überprüfen.

Sie können über die Step Functions Functions-Konsole auf Workflow Studio zugreifen, wenn Sie einen Workflow erstellen oder bearbeiten. 

**Sie können Workflow Studio auch von einem visuellen Designer aus verwendenAWS Infrastructure Composer, um Infrastruktur als Code mit AWS Serverless Application Model und zu erstellenAWS CloudFormation.** Informationen zu den Vorteilen dieses Ansatzes finden Sie unter[Verwenden von Workflow Studio in Infrastructure Composer](use-wfs-in-app-composer.md).

Workflow Studio hat drei Modi: **Design**, **Code** und **Config**. Im *Designmodus* können Sie drag-and-drop Status auf der Arbeitsfläche anzeigen. *Der Codemodus* bietet einen integrierten Code-Editor zum Bearbeiten Ihrer Workflow-Definitionen in der Konsole. Im *Konfigurationsmodus* können Sie Ihre Workflow-Konfiguration verwalten.

**Arbeiten mit Workflow Studio in Visual Studio Code**  
Mit dem AWS Toolkit können Sie Workflow Studio von VS Code aus verwenden, um einzelne Zustände in Ihren Zustandsmaschinen zu visualisieren, zu erstellen und sogar zu testen. Sie geben Zustandseingaben ein und legen Variablen fest, starten den Test und können dann sehen, wie Ihre Daten transformiert werden. Sie können den Workflow anpassen und erneut testen. Wenn Sie fertig sind, können Sie die Änderungen anwenden, um die Zustandsmaschine zu aktualisieren. Weitere Informationen finden Sie unter [Arbeiten mit Workflow Studio](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions-workflowstudio.html) in der AWS Toolkit for Visual Studio Code. 

## Entwurfsmodus
<a name="wfs-interface-design-mode"></a>

Der Entwurfsmodus bietet eine grafische Oberfläche zur Visualisierung Ihrer Workflows, während Sie deren Prototypen erstellen. Die folgende Abbildung zeigt den Statusbrowser, die Workflow-Arbeitsfläche, den Inspektor und die kontextuelle Hilfe im **Designmodus** von Workflow Studio.

![\[Screenshot des Entwurfsmodus mit den Statusfenstern Browser, Workflow-Arbeitsfläche, Inspektor und Hilfe.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/wfs_main_01.png)


1. Die Modustasten schalten zwischen den drei Modi um. Sie können den Modus nicht wechseln, wenn Ihre ASL-Workflow-Definition ungültig ist.

1. Die [Staaten (Browser)](#workflow-studio-components-states) enthält die folgenden drei Registerkarten:
   + Die Registerkarte **Aktionen** enthält eine Liste von Aktionen AWS APIs, die Sie per Drag-and-Drop in Ihr Workflow-Diagramm auf der Arbeitsfläche ziehen können. Jede Aktion steht für einen [Workflow-Status der Aufgabe](state-task.md) Status.
   + Die Registerkarte **Flow** enthält eine Liste von Flow-Status, die Sie per Drag-and-Drop in Ihr Workflow-Diagramm auf der Arbeitsfläche ziehen können.
   + Die Registerkarte **Muster** enthält mehrere ready-to-use wiederverwendbare Bausteine, die Sie für eine Vielzahl von Anwendungsfällen verwenden können. Sie können diese Muster beispielsweise verwenden, um Daten in einem Amazon S3 S3-Bucket iterativ zu verarbeiten.

1. [Arbeitsfläche und Workflow-Diagramm](#workflow-studio-components-grapheditor)Hier ziehen Sie Status per Drag-and-Drop in Ihr Workflow-Diagramm, ändern die Reihenfolge der Status und wählen Status aus, die konfiguriert oder angezeigt werden sollen.

1. In [Inspektor-Panel](#workflow-studio-components-formdefinition) diesem Bereich können Sie die Eigenschaften jedes Status, den Sie auf der Leinwand ausgewählt haben, anzeigen und bearbeiten. Aktivieren Sie den Schalter **Definition**, um den Sprachcode für die Amazon-Staaten für Ihren Workflow anzuzeigen, wobei der aktuell ausgewählte Bundesstaat hervorgehoben ist. 

1. Mit **Informationslinks** wird ein Fenster mit Kontextinformationen geöffnet, falls Sie Hilfe benötigen. Diese Bereiche enthalten auch Links zu verwandten Themen in der Step Functions Functions-Dokumentation. 

1. Entwurfssymbolleiste — Enthält eine Reihe von Schaltflächen für allgemeine Aktionen wie Rückgängigmachen, Löschen und Vergrößern.

1. Hilfsschaltflächen — Eine Reihe von Schaltflächen, mit denen Sie Aufgaben ausführen können, z. B. das Speichern Ihrer Workflows oder das Exportieren ihrer ASL-Definitionen in eine JSON- oder YAML-Datei.

### Staaten (Browser)
<a name="workflow-studio-components-states"></a>

Im States-Browser können Sie Staaten auswählen, die Sie per Drag-and-Drop auf Ihre Workflow-Arbeitsfläche ziehen möchten. Die Registerkarte „**Aktionen**“ enthält eine Liste der Aufgabenstatus, die eine Verbindung zu HTTP-Endpunkten von Drittanbietern herstellen, und AWS APIs. Die Registerkarte **Flow** enthält eine Liste von Status, anhand derer Sie Ihren Workflow steuern und steuern können. Zu den Flow-Status gehören: Auswahl, Parallel, Zuordnung, Bestanden, Warten, Erfolgreich und Fehlgeschlagen. Die Registerkarte „**Muster**“ enthält ready-to-use wiederverwendbare vordefinierte Bausteine. Mit dem Suchfeld oben im Panel können Sie unter allen Statustypen suchen.

![\[Illustrative Sammlung von Screenshots, die Aktionen, Ablauf, Muster und Suche zeigen.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/wfe-states-browser-01.png)


### Arbeitsfläche und Workflow-Diagramm
<a name="workflow-studio-components-grapheditor"></a>

Nachdem Sie einen Status ausgewählt haben, den Sie Ihrem Workflow hinzufügen möchten, können Sie ihn auf die Arbeitsfläche ziehen und in Ihr Workflow-Diagramm einfügen. Sie können Status auch per Drag-and-Drop verschieben, um sie innerhalb Ihres Workflows zu verschieben. Wenn Ihr Workflow umfangreich ist, können Sie die Ansicht vergrößern oder verkleinern, um verschiedene Teile Ihres Workflow-Diagramms auf der Arbeitsfläche anzuzeigen. 

### Inspektor-Panel
<a name="workflow-studio-components-formdefinition"></a>

Sie können alle Status, die Sie Ihrem Workflow hinzufügen, im **Inspektorfenster** auf der rechten Seite konfigurieren. Wählen Sie den Status aus, den Sie konfigurieren möchten, und Sie werden seine Konfigurationsoptionen im **Inspektorfenster** sehen. Um die automatisch generierte [ASL-Definition](concepts-amazon-states-language.md) für Ihren Workflow-Code zu sehen, aktivieren Sie den Schalter **Definition**. Die ASL-Definition, die dem ausgewählten Status zugeordnet ist, wird hervorgehoben angezeigt.

![\[Illustrativer Screenshot des Workflow Studio-Inspektors mit dem Konfigurationsfenster\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/wfe-forms-definitions-01.png)


![\[Illustrativer Screenshot des Workflow Studio-Inspektorfensters mit der Codedefinition\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/wfe-forms-definitions-02.png)


## Code-Modus
<a name="wfs-interface-code-mode"></a>

Im **Codemodus** von Workflow Studio können Sie einen integrierten Code-Editor verwenden, um die [Verwendung von Amazon States Language zur Definition von Step Functions Functions-Workflows](concepts-amazon-states-language.md) (ASL-) Definition Ihrer Workflows in der Step Functions Functions-Konsole anzuzeigen, zu schreiben und zu bearbeiten. Der folgende Screenshot zeigt die Komponenten im **Codemodus**.

![\[Illustrativer Screenshot der Bearbeitung einer Workflow-Definition im Codemodus.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/wfs-code-mode.png)


1. Die Modustasten schalten zwischen den drei Modi um. Sie können den Modus nicht wechseln, wenn Ihre ASL-Workflow-Definition ungültig ist.

1. [Code-Editor](#wfs-interface-code-editor)Hier schreiben und bearbeiten Sie die [ASL-Definition](concepts-amazon-states-language.md) Ihrer Workflows im Workflow Studio. Der Code-Editor bietet auch Funktionen wie Syntaxhervorhebung und automatische Vervollständigung.

1. [Diagrammvisualisierung](#wfs-interface-code-graph-viz)— Zeigt eine grafische Echtzeitvisualisierung Ihres Workflows.

1. Hilfsschaltflächen — Eine Reihe von Schaltflächen zum Ausführen von Aufgaben, z. B. zum Speichern Ihrer Workflows oder zum Exportieren ihrer ASL-Definitionen in eine JSON- oder YAML-Datei.

1. Codesymbolleiste — Enthält eine Reihe von Schaltflächen, mit denen allgemeine Aktionen ausgeführt werden können, z. B. das Rückgängigmachen einer Aktion oder das Formatieren des Codes.

1. Grafiksymbolleiste — Enthält eine Reihe von Schaltflächen für allgemeine Aktionen, wie z. B. das Vergrößern und Verkleinern des Workflow-Diagramms.

### Code-Editor
<a name="wfs-interface-code-editor"></a>

Der Code-Editor bietet eine IDE-ähnliche Oberfläche zum Schreiben und Bearbeiten Ihrer Workflow-Definitionen mithilfe von JSON im Workflow Studio. Der Code-Editor enthält mehrere Funktionen, z. B. Syntaxhervorhebung, Vorschläge zur automatischen Vervollständigung, Überprüfung der [ASL-Definition](concepts-amazon-states-language.md) und kontextsensitive Hilfeanzeige. Wenn Sie Ihre Workflow-Definition aktualisieren, wird ein Echtzeitdiagramm Ihres Workflows [Diagrammvisualisierung](#wfs-interface-code-graph-viz) gerendert. Sie können das aktualisierte Workflow-Diagramm auch in der [Entwurfsmodus](#wfs-interface-design-mode) sehen.

Wenn Sie im Bereich [Entwurfsmodus](#wfs-interface-design-mode) oder im Bereich der Grafikvisualisierung einen Status auswählen, wird die ASL-Definition dieses Status im Code-Editor hervorgehoben angezeigt. Die ASL-Definition Ihres Workflows wird automatisch aktualisiert, wenn Sie einen Status im **Entwurfsmodus** oder im Bereich der Grafikvisualisierung neu anordnen, löschen oder hinzufügen.

Der Code-Editor kann Vorschläge zur automatischen Vervollständigung von Feldern und Status machen.
+ Um eine Liste der Felder zu sehen, die Sie in einen bestimmten Status aufnehmen können, drücken Sie**Ctrl\$1Space**.
+ Um einen Codeausschnitt für einen neuen Status in Ihrem Workflow zu generieren, drücken Sie **Ctrl\$1Space** hinter der Definition des aktuellen Status.
+ Um eine Liste aller verfügbaren Befehle und **Tastenkombinationen** anzuzeigen, drücken Sie. **F1**

### Diagrammvisualisierung
<a name="wfs-interface-code-graph-viz"></a>

Das Bedienfeld zur Grafikvisualisierung zeigt Ihren Arbeitsablauf in einem grafischen Format. Wenn Sie Ihre Workflow-Definitionen in Workflow Studio schreiben, rendert der Bereich zur Grafikvisualisierung ein Echtzeitdiagramm Ihres Workflows. [Code-Editor](#wfs-interface-code-editor) 

Wenn Sie einen Status im Bereich der Grafikvisualisierung neu anordnen, löschen oder duplizieren, wird die Workflow-Definition im Code-Editor automatisch aktualisiert. Ebenso wird die Visualisierung automatisch aktualisiert, wenn Sie Ihre Workflow-Definitionen aktualisieren, neu anordnen, löschen oder einen Status im Code-Editor hinzufügen.

Wenn der JSON-Code in der ASL-Definition Ihres Workflows ungültig ist, unterbricht der Bereich zur Grafikvisualisierung das Rendern und zeigt am unteren Rand des Bereichs eine Statusmeldung an.

## Konfigurationsmodus
<a name="wfs-interface-config-mode"></a>

Im **Konfigurationsmodus** von Workflow Studio können Sie die allgemeine Konfiguration Ihrer Zustandsmaschinen verwalten. In diesem Modus können Sie Einstellungen wie die folgenden angeben:
+ **Details**: Legen Sie den **Namen und den **Typ** des** Workflows fest. Beachten Sie, dass beide **nicht geändert werden können**, nachdem Sie die Zustandsmaschine erstellt haben.
+ **Berechtigungen**: Sie können eine neue Rolle erstellen (empfohlen), eine bestehende Rolle auswählen oder einen ARN für eine bestimmte Rolle eingeben. Wenn Sie die Option zum Erstellen einer neuen Rolle auswählen, erstellt Step Functions eine Ausführungsrolle für Ihre Zustandsmaschinen mit den geringsten Rechten. Die generierten IAM-Rollen gelten für die Rollen, AWS-Region in denen Sie die Zustandsmaschine erstellen. Vor der Erstellung können Sie die Berechtigungen überprüfen, die Step Functions automatisch für Ihre Zustandsmaschine generiert.
+ **Protokollierung**: Sie können eine Protokollebene für Ihre Zustandsmaschine aktivieren und festlegen. Step Functions protokolliert die Ereignisse des Ausführungsverlaufs auf der Grundlage Ihrer Auswahl. Sie können optional einen vom Kunden verwalteten Schlüssel verwenden, um Ihre Protokolle zu verschlüsseln. Weitere Informationen zu Protokollebenen finden Sie unter[Protokollebenen für Ausführungsereignisse von Step Functions](cw-logs.md#cloudwatch-log-level).

Unter **Zusätzliche Konfiguration** können Sie eine oder mehrere der folgenden **optionalen** Konfigurationsoptionen festlegen:
+ **X-Ray-Tracing aktivieren**: Sie können Traces X-Ray für State-Machine-Ausführungen an senden, auch wenn keine Trace-ID von einem Upstream-Dienst übergeben wird. Weitere Informationen finden Sie unter [Trace Step Functions fordern Daten an AWS X-Ray](concepts-xray-tracing.md).
+ **Version bei Erstellung veröffentlichen**: Eine *Version* ist ein nummerierter, unveränderlicher Snapshot einer Zustandsmaschine, den Sie ausführen können. Wählen Sie diese Option, um eine Version Ihrer Zustandsmaschine zu veröffentlichen, während Sie die Zustandsmaschine erstellen. Step Functions veröffentlicht Version 1 als erste Revision der State Machine. Weitere Informationen zu Versionen erhalten Sie unter [State-Machine-Versionen in Step Functions Functions-Workflows](concepts-state-machine-version.md).
+ **Mit einem vom Kunden verwalteten Schlüssel verschlüsseln**: Sie können einen Schlüssel angeben, den Sie direkt verwalten, um Ihre Daten zu verschlüsseln. Weitere Informationen finden Sie unter [Verschlüsselung von Daten im Ruhezustand](encryption-at-rest.md)
+ **Stichwörter**: Wählen Sie dieses Feld, um Tags hinzuzufügen, die Ihnen helfen, die mit Ihren Ressourcen verbundenen Kosten nachzuverfolgen und zu verwalten und für mehr Sicherheit in Ihren IAM-Richtlinien zu sorgen. Weitere Informationen zu Tags erhalten Sie unter [Zustandsmaschinen und Aktivitäten in Step Functions kennzeichnen](sfn-best-practices.md#concepts-tagging).

# Erstellen eines Workflows mit Workflow Studio in Step Functions
<a name="workflow-studio-create"></a>

Erfahren Sie, wie Sie Workflows mit Step Functions Workflow Studio erstellen, bearbeiten und ausführen. Sobald Ihr Workflow fertig ist, können Sie ihn speichern, ausführen und exportieren. 

**Topics**
+ [Erstellen eines Zustandsautomaten](#workflow-studio-components-create)
+ [Entwerfen Sie einen Workflow](#workflow-studio-build)
+ [Führen Sie Ihren Workflow aus](#workflow-studio-components-create-run)
+ [Bearbeiten Sie Ihren Workflow](#workflow-studio-components-create-edit)
+ [Exportieren Sie Ihren Workflow](#workflow-studio-components-create-export)
+ [Erstellen eines Workflow-Prototyps mit Platzhaltern](#workflow-studio-components-create-prototype)

## Erstellen eines Zustandsautomaten
<a name="workflow-studio-components-create"></a>

In Workflow Studio können Sie entweder eine Startvorlage oder eine leere Vorlage auswählen, um einen Workflow zu erstellen.

Eine Startvorlage ist ein ready-to-run Beispielprojekt, das automatisch den Workflow-Prototyp und die Workflow-Definition erstellt und alle zugehörigen AWS Ressourcen bereitstellt, die Ihr Projekt für Sie AWS-Konto benötigt. Sie können diese Startvorlagen verwenden, um sie unverändert bereitzustellen und auszuführen, oder die Workflow-Prototypen verwenden, um darauf aufzubauen. Weitere Informationen zu Starter-Vorlagen finden Sie unter[Stellen Sie eine Zustandsmaschine mithilfe einer Startvorlage für Step Functions bereit](starter-templates.md).

Bei einer leeren Vorlage verwenden Sie den [Entwurfs](workflow-studio.md#wfs-interface-design-mode) - oder [Codemodus](workflow-studio.md#wfs-interface-code-mode), um Ihren benutzerdefinierten Workflow zu erstellen.

### Erstellen Sie eine Zustandsmaschine mithilfe einer Startvorlage
<a name="wfs-create-workflow-templates"></a>

1. Öffnen Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/) und wählen Sie **Create State Machine**.

1. Führen **Sie im Dialogfeld „Vorlage auswählen**“ einen der folgenden Schritte aus, um ein Beispielprojekt auszuwählen:
   + Geben Sie **Task Timer** in das Feld Nach Schlüsselwort suchen einen Text ein, und wählen Sie dann in den Suchergebnissen die Option **Task-Timer** aus.
   + Durchsuchen Sie die Beispielprojekte, die im rechten Bereich unter **Alle** aufgeführt sind, und wählen Sie dann **Task Timer** aus.

1. Wählen Sie **Next** (Weiter), um fortzufahren.

1. Wählen Sie aus, wie die Vorlage verwendet werden soll:

1. Wählen Sie **Vorlage verwenden**, um mit Ihrer Auswahl fortzufahren.

1. **Eine Demo ausführen** — erstellt eine Zustandsmaschine mit Schreibschutz. Nach der Überprüfung können Sie den Workflow und alle zugehörigen Ressourcen erstellen.

1. **Darauf aufbauen** — bietet eine bearbeitbare Workflow-Definition, die Sie mit Ihren eigenen Ressourcen überprüfen, anpassen und bereitstellen können. (Verwandte Ressourcen, wie Funktionen oder Warteschlangen, werden **nicht** automatisch erstellt.)

### Erstellen Sie einen Workflow mit einer leeren Vorlage
<a name="wfs-create-workflow-blank"></a>

Wenn Sie mit einer leeren Arbeitsfläche beginnen möchten, erstellen Sie einen Workflow aus der leeren Vorlage.

1. Öffnen Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/).

1. Wählen Sie **Create State Machine (Zustandsautomaten erstellen)**.

1. Wählen Sie **Aus leerem Feld erstellen**.

1. Geben Sie Ihrem Zustandsmaschine einen Namen und wählen Sie dann **Weiter**, um Ihren Zustandsmaschine in Workflow Studio zu bearbeiten.

   Sie können jetzt mit dem Entwerfen Ihres Workflows beginnen [Entwurfsmodus](workflow-studio.md#wfs-interface-design-mode) oder Ihre Workflow-Definition in schreiben[Code-Modus](workflow-studio.md#wfs-interface-code-mode).

1. Wählen Sie **Config**, um die Konfiguration Ihres Workflows in der zu verwalten[Konfigurationsmodus](workflow-studio.md#wfs-interface-config-mode). Geben Sie beispielsweise einen Namen für Ihren Workflow ein und wählen Sie dessen Typ aus.

## Entwerfen Sie einen Workflow
<a name="workflow-studio-build"></a>

Wenn Sie den Namen des Bundesstaates kennen, den Sie hinzufügen möchten, verwenden Sie das Suchfeld oben in der[Staaten (Browser)](workflow-studio.md#workflow-studio-components-states), um ihn zu finden. Suchen Sie andernfalls im Browser nach dem gewünschten Status und fügen Sie ihn der Arbeitsfläche hinzu. 

Sie können Status in Ihrem Workflow neu anordnen, indem Sie sie an eine andere Stelle in Ihrem Workflow ziehen. Wenn Sie einen Status auf die Leinwand ziehen, wird eine Linie angezeigt, die angibt, wo der Status in Ihren Workflow eingefügt wird, wie im folgenden Screenshot gezeigt: 

![\[Illustrativer Screenshot, der die blaue Linie zeigt, die das Ziel für einen Status angibt.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/wfe-design-02.png)


Nachdem ein Status auf der Arbeitsfläche abgelegt wurde, wird sein Code automatisch generiert und der Workflow-Definition hinzugefügt. Um die Definition zu sehen, aktivieren Sie den Schalter **Definition** im [Inspektorfenster](workflow-studio.md#workflow-studio-components-formdefinition). Sie können wählen[Code-Modus](workflow-studio.md#wfs-interface-code-mode), ob Sie die Definition mit dem integrierten Code-Editor bearbeiten möchten.

Nachdem Sie einen Status auf der Arbeitsfläche abgelegt haben, können Sie ihn im [Inspektor-Panel](workflow-studio.md#workflow-studio-components-formdefinition) Bereich auf der rechten Seite konfigurieren. Dieser Bereich enthält die Registerkarten **Konfiguration**, **Eingabe**, **Ausgabe** und **Fehlerbehandlung** für jeden Status oder jede API-Aktion, die Sie auf der Arbeitsfläche platzieren. Sie konfigurieren die Status, die Sie in Ihre Workflows aufnehmen, auf der Registerkarte **Konfiguration**. 

Die Registerkarte „**Konfiguration**“ für die Lambda-API-Aktion „Aufrufen“ bietet beispielsweise die folgenden Optionen:
+ **Name des Bundesstaates**: Sie können den Status mit einem benutzerdefinierten Namen identifizieren oder den generierten Standardnamen akzeptieren.
+ Die **API** zeigt, welche API-Aktion vom Staat verwendet wird. 
+ **Integrationstyp**: Sie können den Serviceintegrationstyp auswählen, der zum Aufrufen von API-Aktionen für andere Dienste verwendet wird.
+ **Der Funktionsname** bietet Optionen für:
  +  **Geben Sie einen Funktionsnamen** ein: Sie können Ihren Funktionsnamen oder seinen ARN eingeben. 
  +  **Funktionsnamen zur Laufzeit aus der Statuseingabe abrufen**: Sie können diese Option verwenden, um den Funktionsnamen dynamisch aus der Statuseingabe abzurufen, basierend auf dem von Ihnen angegebenen Pfad. 
  +  **Funktionsnamen wählen**: Sie können direkt aus den Funktionen auswählen, die in Ihrem Konto und Ihrer Region verfügbar sind. 
+ **Nutzlast**: Sie können wählen, ob Sie die Statuseingabe, ein JSON-Objekt oder keine Nutzlast verwenden möchten, um sie als Nutzlast an Ihre Lambda-Funktion zu übergeben. Wenn Sie JSON wählen, können Sie sowohl statische Werte als auch Werte einbeziehen, die aus der Statuseingabe ausgewählt wurden.
+ (Optional) In einigen Bundesstaaten gibt es die Option „Auf **Abschluss der Aufgabe warten**“ oder „Auf **Rückruf warten**“. Sofern verfügbar, können Sie eines der folgenden [Serviceintegrationsmuster](connect-to-resource.md) wählen: 
  + **Keine Option ausgewählt**: Step Functions verwendet das [Request Response (Antwort anfordern)](connect-to-resource.md#connect-default) Integrationsmuster. Step Functions wartet auf eine HTTP-Antwort und wechselt dann zum nächsten Status. Step Functions wartet nicht darauf, dass ein Job abgeschlossen ist. Wenn keine Optionen verfügbar sind, verwendet der Staat dieses Muster. 
  + **Warten Sie, bis die Aufgabe abgeschlossen** ist: Step Functions verwendet das [Ausführen einer Aufgabe (.sync)](connect-to-resource.md#connect-sync) Integrationsmuster.
  + Auf **Rückruf warten**: Step Functions verwendet das [Warten Sie auf einen Rückruf mit Task Token](connect-to-resource.md#connect-wait-token) Integrationsmuster.
+ (Optional) Um auf Ressourcen zuzugreifen, die AWS-Konten in Ihren Workflows unterschiedlich konfiguriert sind, bietet Step Functions [kontenübergreifenden Zugriff](concepts-access-cross-acct-resources.md). **Die IAM-Rolle für kontoübergreifenden Zugriff bietet Optionen** für:
  + Geben **Sie den ARN für die IAM-Rolle** an: Geben Sie die IAM-Rolle an, die die entsprechenden Ressourcenzugriffsberechtigungen enthält. Diese Ressourcen sind in einem Zielkonto verfügbar, AWS-Konto auf das Sie kontenübergreifende Anrufe tätigen.
  + **Rufen Sie den ARN der IAM-Rolle zur Laufzeit aus der Statuseingabe ab: Geben Sie einen Referenzpfad zu einem vorhandenen Schlüssel-Wert-Paar in der JSON-Eingabe des Bundesstaates an, das die IAM-Rolle** enthält.
+ **Im nächsten Status** können Sie den Status auswählen, in den Sie als Nächstes wechseln möchten. 
+ (Optional) Das **Kommentarfeld** hat keinen Einfluss auf den Workflow, aber Sie können es verwenden, um Ihren Workflow mit Anmerkungen zu versehen.

In einigen Bundesstaaten werden zusätzliche generische Konfigurationsoptionen verfügbar sein. Beispielsweise enthält die Amazon `RunTask` ECS-State-Konfiguration ein `API Parameters` Feld, das mit Platzhalterwerten gefüllt ist. Für diese Bundesstaaten können Sie die Platzhalterwerte durch Konfigurationen ersetzen, die Ihren Anforderungen entsprechen.

**Um einen Status zu löschen**

Sie können die Rücktaste drücken, mit der rechten Maustaste klicken und **Status löschen** wählen oder in der [Entwurfs-Werkzeugleiste](workflow-studio.md#wfs-interface-design-mode) **Löschen** wählen.

## Führen Sie Ihren Workflow aus
<a name="workflow-studio-components-create-run"></a>

Wenn Ihr Workflow einsatzbereit ist, können Sie ihn ausführen und seine Ausführung von der [Step Functions Functions-Konsole aus verfolgen](https://console.aws.amazon.com/states/home).

**Um einen Workflow in Workflow Studio auszuführen**

1. Wählen Sie im **Design** -, **Code** - oder **Konfigurationsmodus** die Option **Ausführen.**

   Das Dialogfeld „**Ausführung starten**“ wird auf einer neuen Registerkarte geöffnet.

1. Gehen **Sie im Dialogfeld Ausführung starten** wie folgt vor:

   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 Beschriftungen, 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. (Optional) Geben Sie im **Eingabefeld Eingabewerte** im JSON-Format ein, um Ihren Workflow auszuführen.

   1. Wählen Sie **Start execution (Ausführung starten)** aus.

   1. Die Step Functions Functions-Konsole leitet Sie zu einer Seite weiter, die mit Ihrer Ausführungs-ID betitelt ist, die als Seite mit den *Ausführungsdetails* bezeichnet wird. Sie können die Ausführungsergebnisse im Verlauf und nach Abschluss des Workflows überprüfen.

      Um die Ausführungsergebnisse zu überprüfen, wählen Sie in der **Diagrammansicht** einzelne Status und anschließend die einzelnen Registerkarten im [Einzelheiten zu den Schritten](concepts-view-execution-details.md#exec-details-intf-step-details) Bereich aus, um die Details der einzelnen Status, einschließlich Eingabe, Ausgabe und Definition, anzuzeigen. Einzelheiten zu den Ausführungsinformationen, die Sie auf der Seite mit den *Ausführungsdetails* einsehen können, finden Sie unter[Überblick über die Ausführungsdetails](concepts-view-execution-details.md#exec-details-interface-overview).

## Bearbeiten Sie Ihren Workflow
<a name="workflow-studio-components-create-edit"></a>

Sie können einen vorhandenen Workflow visuell im [Entwurfsmodus](workflow-studio.md#wfs-interface-design-mode) Workflow Studio bearbeiten. 

Wählen Sie in der [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home) auf der Seite **State Machines** den Workflow aus, den Sie bearbeiten möchten. Der Workflow wird im **Entwurfsmodus** von Workflow Studio geöffnet.

Sie können die Workflow-Definition auch in bearbeiten[Code-Modus](workflow-studio.md#wfs-interface-code-mode). Wählen Sie die **Code-Schaltfläche**, um die Workflow-Definition in Workflow Studio anzuzeigen oder zu bearbeiten.

**Anmerkung**  
Wenn Sie Fehler in Ihrem Workflow sehen, müssen Sie diese im **Entwurfsmodus** beheben. Sie können nicht in den **Code** - oder **Konfigurationsmodus** wechseln, wenn in Ihrem Workflow Fehler auftreten.

Wenn Sie Änderungen an Ihrem Workflow speichern, haben Sie die Möglichkeit, auch eine neue **Version** zu veröffentlichen. Bei Versionen können Sie wählen, ob Sie die Originalversion oder alternative Versionen Ihres Workflows ausführen möchten. Weitere Informationen zur Verwaltung von Workflows mit Versionen finden Sie unter [State-Machine-Versionen in Step Functions Functions-Workflows](concepts-state-machine-version.md)

## Exportieren Sie Ihren Workflow
<a name="workflow-studio-components-create-export"></a>

Sie können die Definition Ihres Workflows [Sprache der Amazonas-Staaten](concepts-amazon-states-language.md) (ASL) und Ihr Workflow-Diagramm exportieren:

1. Wählen Sie Ihren Workflow in der [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home) aus.

1. Wählen Sie auf der *Detailseite des State Machines* die Option **Bearbeiten** aus.

1. Wählen Sie die Dropdownschaltfläche „**Aktionen**“ und führen Sie dann eine oder beide der folgenden Aktionen aus:
   + Um das Workflow-Diagramm in eine SVG- oder PNG-Datei zu **exportieren, wählen Sie unter Diagramm exportieren** das gewünschte Format aus.
   + Um die Workflow-Definition als JSON- oder YAML-Datei zu exportieren, wählen Sie unter **Exportdefinition** das gewünschte Format aus.

## Erstellen eines Workflow-Prototyps mit Platzhaltern
<a name="workflow-studio-components-create-prototype"></a>

Sie können Workflow Studio oder [Workflow Studio](use-wfs-in-app-composer.md) verwenden, um Prototypen neuer Workflows Infrastructure Composer zu erstellen, die *Platzhalterressourcen enthalten, die als Ressourcen* bezeichnet werden, die noch nicht existieren.

So erstellen Sie einen Workflow-Prototyp:

1. Melden Sie sich bei der [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/) an.

1. Wählen Sie **Create State Machine (Zustandsautomaten erstellen)**.

1. Wählen Sie „**Aus leerem Feld erstellen“**.

1. Geben Sie Ihrem Zustandsmaschine einen Namen und wählen Sie dann **Weiter**, um Ihren Zustandsmaschine in Workflow Studio zu bearbeiten.

1. Der [Entwurfsmodus](workflow-studio.md#wfs-interface-design-mode) von Workflow Studio wird geöffnet. Entwerfen Sie Ihren Workflow in Workflow Studio. Um Platzhalter-Ressourcen einzubeziehen:

   1. **Wählen Sie den Bundesstaat aus, für den Sie eine Platzhalterressource hinzufügen möchten, und gehen Sie dann unter Konfiguration wie folgt vor:**
      + Wählen Sie für Lambda Invoke-Status die Option **Funktionsname** und dann **Funktionsname eingeben** aus. Sie können auch einen benutzerdefinierten Namen für Ihre Funktion eingeben.
      + Wählen Sie für den Status „Nachricht senden“ von Amazon SQS die Option „**Warteschlangen-URL**“ und anschließend „**Warteschlangen-URL eingeben**“. Geben Sie eine Platzhalter-URL für die Warteschlange ein.
      + Wählen Sie für Amazon SNS Publish States unter **Thema** einen Themen-ARN aus.
      + Für alle anderen Staaten, die unter **Aktionen** aufgeführt sind, können Sie die Standardkonfiguration verwenden.
**Anmerkung**  
Wenn Sie Fehler in Ihrem Arbeitsablauf feststellen, müssen Sie diese im **Entwurfsmodus** beheben. Sie können nicht in den **Code** - oder **Konfigurationsmodus** wechseln, wenn in Ihrem Workflow Fehler auftreten.

   1. **(Optional) Um die automatisch generierte ASL-Definition Ihres Workflows anzuzeigen, wählen Sie Definition.**

   1. (Optional) Um die Workflow-Definition in Workflow Studio zu aktualisieren, wählen Sie die **Codeschaltfläche**.
**Anmerkung**  
Wenn Sie Fehler in Ihrer Workflow-Definition sehen, müssen Sie diese im **Codemodus** beheben. Sie können nicht in den **Entwurfs** - oder **Konfigurationsmodus** wechseln, wenn in Ihrer Workflow-Definition Fehler auftreten.

1. (Optional) Um den Namen des Zustandsmaschinen zu bearbeiten, wählen Sie das Bearbeitungssymbol neben dem Standardnamen des Zustandsmaschinen von **MyStateMachine**und geben Sie im Feld Name des **Zustandsmaschinen einen Namen** ein.

   Sie können auch zum wechseln, [Konfigurationsmodus](workflow-studio.md#wfs-interface-config-mode) um den Standardnamen des Zustandsmaschinen zu bearbeiten.

1. Geben Sie Ihre Workflow-Einstellungen an, z. B. den Zustandsmaschinentyp und seine Ausführungsrolle.

1. Wählen Sie **Erstellen** aus.

Sie haben jetzt einen neuen Workflow mit Platzhalterressourcen erstellt, die für Prototypen verwendet werden können. Sie können Ihre Workflow-Definition und das Workflow-Diagramm [exportieren](#workflow-studio-components-create-export).
+ Um Ihre Workflow-Definition als JSON- oder YAML-Datei zu exportieren, wählen Sie im **Design** - oder **Codemodus** die **Drop-down-Schaltfläche Aktionen**. Wählen Sie dann unter **Definition exportieren** das Format aus, das Sie exportieren möchten. Sie können diese exportierte Definition als Ausgangspunkt für die lokale Entwicklung mit dem verwenden [AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/building-stepfunctions.html).
+ Um Ihr Workflow-Diagramm in eine SVG- oder PNG-Datei zu exportieren, wählen Sie im **Design** - oder **Codemodus** die Dropdownschaltfläche **Aktionen** aus. Wählen Sie dann unter **Exportdefinition** das gewünschte Format aus.

# Konfiguration von Zuständen, Eingaben und Ausgaben mit Workflow Studio in Step Functions
<a name="workflow-studio-process"></a>

**Status verwalten und Daten transformieren**  
Erfahren Sie mehr über das [Übergeben von Daten zwischen Zuständen mithilfe von Variablen](workflow-variables.md) und das [Transformieren von Daten mit JSONata](transforming-data.md).

Jeder Staat trifft eine Entscheidung oder führt eine Aktion auf der Grundlage von Eingaben aus, die er erhält. In den meisten Fällen leitet er dann die Ausgabe an andere Staaten weiter. **In Workflow Studio können Sie auf den Registerkarten Eingabe und Ausgabe des Bedienfelds konfigurieren, wie ein Status seine Eingabe- und **Ausgabedaten** filtert und manipuliert.** [Inspektor-Panel](workflow-studio.md#workflow-studio-components-formdefinition) Verwenden Sie die **Informationslinks**, um bei der Konfiguration von Eingaben und Ausgaben auf die kontextuelle Hilfe zuzugreifen. 

![\[Illustrativer Screenshot mit Statuseingaben und -ausgängen und dem Informationshilfebereich\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/wfs_input_output_01.png)


Ausführliche Informationen darüber, wie Step Functions Eingabe und Ausgabe verarbeitet, finden Sie unter[Eingabe und Ausgabe in Step Functions verarbeiten](concepts-input-output-filtering.md). 

## Konfigurieren Sie die Eingabe für einen Status
<a name="workflow-studio-process-input"></a>

Jeder Status erhält Eingaben aus dem vorherigen Status als JSON. Wenn Sie die Eingabe filtern möchten, können Sie den `InputPath` Filter auf der Registerkarte **Eingabe** im [Inspektor-Panel](workflow-studio.md#workflow-studio-components-formdefinition) Bereich verwenden. Das `InputPath` ist eine Zeichenfolge, die mit beginnt `$` und einen bestimmten JSON-Knoten identifiziert. Diese werden als [Referenzpfade](amazon-states-language-paths.md) bezeichnet und folgen der JsonPath Syntax. 

Um die Eingabe zu filtern:
+ Wählen Sie **Eingabe filtern mit InputPath**.
+ Geben Sie einen [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)für den `InputPath` Filter gültigen Wert ein. Beispiel, **\$1.data**.

Ihr `InputPath` Filter wird zu Ihrem Workflow hinzugefügt.

**Example Beispiel 1: Verwenden Sie den InputPath Filter in Workflow Studio**  
Angenommen, die Eingabe für Ihren Status enthält die folgenden JSON-Daten.  

```
{
  "comment": "Example for InputPath",
  "dataset1": {
    "val1": 1,
    "val2": 2,
    "val3": 3
  },
  "dataset2": {
    "val1": "a",
    "val2": "b",
    "val3": "c"
  }
}
```
Um den `InputPath` Filter anzuwenden, wählen Sie **Eingabe filtern mit InputPath** und geben Sie dann einen entsprechenden Referenzpfad ein. Wenn Sie eingeben**\$1.dataset2.val1**, wird der folgende JSON-Code als Eingabe an den Status übergeben.  

```
{"a"}
```
Ein Referenzpfad kann auch eine Auswahl von Werten enthalten. Wenn es sich bei den Daten, auf die Sie verweisen, um Daten handelt `{ "a": [1, 2, 3, 4] }` und Sie den Referenzpfad `$.a[0:2]` als `InputPath` Filter anwenden, ist das folgende Ergebnis.  

```
[ 1, 2 ]
```

[Status des parallelen Workflows](state-parallel.md)[Workflow-Status zuordnen](state-map.md), und [Workflow-Status übergeben](state-pass.md) Flow-Status verfügen über eine zusätzliche Eingabefilteroption, die auf der jeweiligen `Parameters` Registerkarte **Eingabe** aufgerufen wird. Dieser Filter wird nach dem InputPath Filter wirksam und kann verwendet werden, um ein benutzerdefiniertes JSON-Objekt zu erstellen, das aus einem oder mehreren Schlüssel-Wert-Paaren besteht. Die Werte der einzelnen Paare können entweder statische Werte sein, sie können aus der Eingabe ausgewählt werden, oder sie können [Zugreifen auf Ausführungsdaten aus dem Context-Objekt in Step Functions](input-output-contextobject.md) mit einem Pfad aus dem ausgewählt werden. 

**Anmerkung**  
Um anzugeben, dass ein Parameter einen Referenzpfad verwendet, um auf einen JSON-Knoten in der Eingabe zu verweisen, muss der Parametername mit enden`.$`.

**Example Beispiel 2: Erstellen Sie eine benutzerdefinierte JSON-Eingabe für den Parallel-Status**  
Angenommen, die folgenden JSON-Daten sind die Eingabe für einen Parallelstatus.  

```
{
  "comment": "Example for Parameters",
  "product": {
    "details": {
      "color": "blue",
      "size": "small",
      "material": "cotton"
    },
    "availability": "in stock",
    "sku": "2317",
    "cost": "$23"
  }
}
```

Um einen Teil dieser Eingabe auszuwählen und zusätzliche Schlüssel-Wert-Paare mit einem statischen Wert zu übergeben, können Sie im Feld **Parameter** auf der Registerkarte **Eingabe** des Status **Parallel** Folgendes angeben.

```
{
 "comment": "Selecting what I care about.",
 "MyDetails": {
    "size.$": "$.product.details.size",
    "exists.$": "$.product.availability",
    "StaticValue": "foo"
    }
 }
```

Die folgenden JSON-Daten werden das Ergebnis sein.

```
{
  "comment": "Selecting what I care about.",
  "MyDetails": {
    "size": "small",
    "exists": "in stock",
    "StaticValue": "foo"
  }
}
```

## Konfigurieren Sie die Ausgabe eines Zustands
<a name="workflow-studio-process-output"></a>

Jeder Status erzeugt eine JSON-Ausgabe, die gefiltert werden kann, bevor sie an den nächsten Status übergeben wird. Es sind mehrere Filter verfügbar, und jeder wirkt sich auf unterschiedliche Weise auf die Ausgabe aus. Die für jeden Status verfügbaren Ausgabefilter sind auf der Registerkarte „**Ausgabe**“ im **Inspektorfenster** aufgeführt. Für [Workflow-Status der Aufgabe](state-task.md) Bundesstaaten werden alle von Ihnen ausgewählten Ausgabefilter in der folgenden Reihenfolge verarbeitet: 

1.  `ResultSelector`: Verwenden Sie diesen Filter, um das Ergebnis des Status zu manipulieren. Sie können ein neues JSON-Objekt mit Teilen des Ergebnisses erstellen. 

1.  `Zustandsausgabe mithilfe von ResultPath In-Step-Funktionen angeben`: Verwenden Sie diesen Filter, um eine Kombination aus der Statuseingabe und dem Aufgabenergebnis auszuwählen, die an die Ausgabe übergeben werden soll. 

1.  `Filtern der Statusausgabe mit OutputPath`: Verwenden Sie diesen Filter, um die JSON-Ausgabe zu filtern und auszuwählen, welche Informationen aus dem Ergebnis an den nächsten Status übergeben werden. 

### Benutze ResultSelector
<a name="workflow-studio-process-output-resultselector"></a>

`ResultSelector`ist ein optionaler Ausgabefilter für die folgenden Staaten:
+  [Workflow-Status der Aufgabe](state-task.md)Staaten, bei denen es sich ausschließlich um Staaten handelt, die auf der Registerkarte **Aktionen** von aufgeführt sind[Staaten (Browser)](workflow-studio.md#workflow-studio-components-states). 
+  [Workflow-Status zuordnen](state-map.md)Staaten, auf der Registerkarte **Flow** des States-Browsers. 
+  [Status des parallelen Workflows](state-parallel.md)Staaten, auf der Registerkarte **Flow** des States-Browsers. 

`ResultSelector`kann verwendet werden, um ein benutzerdefiniertes JSON-Objekt zu erstellen, das aus einem oder mehreren Schlüssel-Wert-Paaren besteht. Die Werte jedes Paares können entweder statische Werte sein oder aus dem Ergebnis des Zustands mit einem Pfad ausgewählt werden. 

**Anmerkung**  
Um anzugeben, dass ein Parameter einen Pfad verwendet, um auf einen JSON-Knoten im Ergebnis zu verweisen, muss der Parametername mit enden`.$`.

**Example Beispiel für die Verwendung eines ResultSelector Filters**  
In diesem Beispiel verwenden Sie, `ResultSelector` um die Antwort des Amazon CreateCluster EMR-API-Aufrufs für einen Amazon `CreateCluster` EMR-Status zu manipulieren. Das Folgende ist das Ergebnis des Amazon `CreateCluster` EMR-API-Aufrufs.  

```
{
  "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"
  }
}
```
**Um einen Teil dieser Informationen auszuwählen und ein zusätzliches Schlüssel-Wert-Paar mit einem statischen Wert zu übergeben, geben Sie Folgendes in das **ResultSelector**Feld auf der Registerkarte Ausgabe des Bundesstaates ein.**  

```
{
 "result": "found",
 "ClusterId.$": "$.output.ClusterId", 
 "ResourceType.$": "$.resourceType"
 }
```
Die Verwendung `ResultSelector` führt zu dem folgenden Ergebnis.  

```
{
 "result": "found",
 "ClusterId": "AKIAIOSFODNN7EXAMPLE",
 "ResourceType": "elasticmapreduce"
}
```

### Benutzen ResultPath
<a name="workflow-studio-process-output-resultpath"></a>

Die Ausgabe eines Zustands kann eine Kopie seiner Eingabe, des von ihm erzeugten Ergebnisses oder eine Kombination aus Eingabe und Ergebnis sein. Verwenden Sie `ResultPath`, um zu steuern, welche Kombination daraus an die Statusausgabe weitergeleitet wird. Weitere Anwendungsfälle von finden `ResultPath` Sie unter[Zustandsausgabe mithilfe von ResultPath In-Step-Funktionen angeben](input-output-resultpath.md).

`ResultPath`ist ein optionaler Ausgabefilter für die folgenden Zustände:
+  [Workflow-Status der Aufgabe](state-task.md)Staaten, das sind alles Staaten, die auf der Registerkarte „**Aktionen**“ des Status-Browsers aufgeführt sind. 
+  [Workflow-Status zuordnen](state-map.md)Staaten, auf der Registerkarte **Flow** des States-Browsers. 
+  [Status des parallelen Workflows](state-parallel.md)Staaten, auf der Registerkarte **Flow** des States-Browsers. 
+  [Workflow-Status übergeben](state-pass.md)Staaten, auf der Registerkarte **Flow** des States-Browsers. 

`ResultPath`kann verwendet werden, um das Ergebnis zur ursprünglichen Statuseingabe hinzuzufügen. Der angegebene Pfad gibt an, wo das Ergebnis hinzugefügt werden soll.

**Example Beispiel für die Verwendung eines ResultPath Filters**  
Nehmen wir an, das Folgende ist die Eingabe für einen Task-Status.  

```
{
  "details": "Default example",
  "who": "AWS Step Functions"
}
```
Das Ergebnis des Task-Status ist das Folgende.  

```
Hello, AWS Step Functions
```
Sie können dieses Ergebnis zur Eingabe des Status hinzufügen, indem Sie einen [Referenzpfad](amazon-states-language-paths.md) anwenden `ResultPath` und eingeben, der angibt, wo das Ergebnis hinzugefügt werden soll, z. B.`$.taskresult`:  
Damit `ResultPath` ist das Folgende das JSON, das als Ausgabe des Status übergeben wird.  

```
{
  "details": "Default example",
  "who": "AWS Step Functions",
  "taskresult": "Hello, AWS Step Functions!"
}
```

### Benutze OutputPath
<a name="workflow-studio-process-output-resultselector"></a>

Mit dem `OutputPath` Filter können Sie unerwünschte Informationen herausfiltern und nur den Teil von JSON übergeben, den Sie benötigen. Das `OutputPath` ist eine Zeichenfolge, die mit beginnt `$` und Knoten innerhalb von JSON-Text identifiziert.

**Example Beispiel für die Verwendung eines OutputPath Filters**  
Stellen Sie sich vor, ein Lambda Invoke-API-Aufruf gibt zusätzlich zum Ergebnis der Lambda-Funktion Metadaten zurück.  

```
{
  "ExecutedVersion": "$LATEST",
  "Payload": {
     "foo": "bar",
     "colors": [
          "red",
          "blue",
          "green"    
     ],
     "car": {
          "year": 2008,
          "make": "Toyota",
          "model": "Matrix"
     }
   },
"SdkHttpMetadata": {
  "AllHttpHeaders": {
    "X-Amz-Executed-Version": ["$LATEST"]
...
```
Sie können es verwenden`OutputPath`, um die zusätzlichen Metadaten herauszufiltern. Standardmäßig lautet der Wert des **OutputPath**Filters für Lambda Invoke-Zustände, die mit dem Workflow Studio erstellt wurden. `$.Payload` Dieser Standardwert entfernt die zusätzlichen Metadaten und gibt eine Ausgabe zurück, die der direkten Ausführung der Lambda-Funktion entspricht.  
Das Beispiel für das Ergebnis der Lambda Invoke-Aufgabe und der Wert von `$.Payload` für den **Ausgabefilter** übergeben die folgenden JSON-Daten als Ausgabe.  

```
{
 "foo": "bar",
 "colors": [
      "red",
      "blue",
      "green"    
 ],
 "car": {
      "year": 2008,
      "make": "Toyota",
      "model": "Matrix"
 }
}
```
Der `OutputPath` Filter ist der letzte Ausgabefilter, der wirksam wird. Wenn Sie also zusätzliche Ausgabefilter wie `ResultSelector` oder verwenden`ResultPath`, sollten Sie den Standardwert von `$.Payload` für den `OutputPath` Filter entsprechend ändern. 

# Richten Sie Ausführungsrollen mit Workflow Studio in Step Functions ein
<a name="manage-state-machine-permissions"></a>

Sie können Workflow Studio verwenden, um Ausführungsrollen für Ihre Workflows einzurichten. Jede Step Functions Zustandsmaschine benötigt eine AWS Identity and Access Management (IAM) -Rolle, die der Zustandsmaschine die Berechtigung erteilt, Aktionen auf AWS-Services und Ressourcen auszuführen oder HTTPS aufzurufen APIs. Diese Rolle wird als *Ausführungsrolle* bezeichnet. 

Die Ausführungsrolle muss IAM Richtlinien für jede Aktion enthalten, z. B. Richtlinien, die es der Zustandsmaschine ermöglichen, eine AWS Lambda Funktion aufzurufen, einen AWS Batch Job auszuführen oder die Stripe-API aufzurufen. Step Functionserfordert in den folgenden Fällen, dass Sie eine Ausführungsrolle angeben:
+ Sie erstellen eine Zustandsmaschine in der Konsole AWS SDKs oder AWS CLI mithilfe der [CreateStateMachine](https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html)API.
+ Sie [testen](test-state-isolation.md) einen Status in der Konsole oder AWS CLI mithilfe der [TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html)API. AWS SDKs

**Topics**
+ [Über automatisch generierte Rollen](#wfs-auto-gen-roles)
+ [Automatisches Generieren von Rollen](#auto-generating-roles)
+ [Probleme bei der Rollengenerierung lösen](#resolve-role-gen-problem)
+ [Rolle zum Testen von HTTP-Aufgaben in Workflow Studio](#test-state-role-http)
+ [Rolle zum Testen einer optimierten Serviceintegration in Workflow Studio](#test-state-role-optimized)
+ [Rolle zum Testen einer AWS SDK-Dienstintegration in Workflow Studio](#test-state-role-aws-sdk)
+ [Rolle zum Testen von Ablaufzuständen in Workflow Studio](#test-state-role-flow)

## Über automatisch generierte Rollen
<a name="wfs-auto-gen-roles"></a>

Wenn Sie in der Step Functions Konsole eine Zustandsmaschine erstellen, kann [Workflow Studio](workflow-studio.md) automatisch eine Ausführungsrolle für Sie erstellen, die die erforderlichen IAM Richtlinien enthält. Workflow Studio analysiert Ihre State-Machine-Definition und generiert Richtlinien mit den geringsten Rechten, die zur Ausführung Ihres Workflows erforderlich sind.

Workflow Studio kann IAM Richtlinien für Folgendes generieren:
+ [HTTP-Aufgaben](call-https-apis.md), die HTTPS aufrufen APIs.
+ Aufgabenstatus, die andere AWS-Services mithilfe [optimierter Integrationen](integrate-optimized.md) aufrufen, z. B. [LambdaInvoke [DynamoDB GetItem](connect-batch.md)](connect-lambda.md), oder. [AWS Glue StartJobRun](connect-glue.md)
+ [Aufgabenstatus, die verschachtelte Workflows ausführen.](connect-stepfunctions.md)
+ [Status verteilter Karten](state-map-distributed.md), einschließlich [Richtlinien](iam-policies-eg-dist-map.md) zum Starten untergeordneter Workflow-Ausführungen, zum Auflisten von Amazon S3 Buckets und zum Lesen oder Schreiben von S3-Objekten.
+ [X-Ray](concepts-xray-tracing.md)Ablaufverfolgung. Jede Rolle, die in Workflow Studio automatisch generiert wird, enthält eine [Richtlinie](concepts-xray-tracing.md#xray-iam), die dem Zustandsmaschine Berechtigungen zum Senden von Traces erteilt. X-Ray
+ [Verwendung von CloudWatch Logs zur Protokollierung des Ausführungsverlaufs in Step Functions](cw-logs.md)wenn die Protokollierung auf der Zustandsmaschine aktiviert ist.

Workflow Studio kann AWS-Services mithilfe von [AWS SDK-Integrationen](supported-services-awssdk.md) keine IAM Richtlinien für Task-Status generieren, die andere aufrufen.

## Automatisches Generieren von Rollen
<a name="auto-generating-roles"></a>

1. Öffnen Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home), wählen Sie im Menü **State Machines** und dann **Create State Machine** aus.

   Sie können auch eine bestehende Zustandsmaschine aktualisieren. Lesen Sie Schritt 4, wenn Sie eine Zustandsmaschine aktualisieren.

1. Wählen Sie Aus **leerem Feld erstellen aus**.

1. Geben Sie Ihrem Zustandsmaschine einen Namen und wählen Sie dann **Weiter**, um Ihren Zustandsmaschine in Workflow Studio zu bearbeiten.

1. Wählen Sie den Tab **Config**.

1. Scrollen Sie nach unten zum Abschnitt „**Berechtigungen**“ und gehen Sie wie folgt vor:

   1. Stellen Sie sicher, dass Sie für die **Ausführungsrolle** die Standardauswahl **Neue Rolle erstellen** beibehalten.

      Workflow Studio generiert automatisch alle erforderlichen IAM Richtlinien für jeden gültigen Status in Ihrer Zustandsmaschinen-Definition. Es zeigt ein Banner mit der Nachricht an: **Eine Ausführungsrolle wird mit vollen Rechten erstellt.**  
![\[Illustrativer Screenshot der Registerkarte „Config“ mit Vorschau der automatisch generierten Berechtigungen.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/wfs-full-permissions-role.png)
**Tipp**  
Um die Berechtigungen zu überprüfen, die Workflow Studio automatisch für Ihren Zustandsmaschine generiert, wählen Sie **Automatisch generierte Berechtigungen überprüfen** aus.
**Anmerkung**  
Wenn Sie die von Step Functions erstellte IAM-Rolle löschen, kann Step Functions sie später nicht mehr neu erstellen. Ebenso kann Step Functions ihre ursprünglichen Einstellungen später nicht wiederherstellen, wenn Sie die Rolle ändern (z. B. indem Sie Step Functions aus den Principals in der IAM-Richtlinie entfernen). 

      Wenn Workflow Studio nicht alle erforderlichen IAM Richtlinien generieren kann, wird ein Banner mit der Meldung **Berechtigungen für bestimmte Aktionen können nicht automatisch generiert werden angezeigt. Eine IAM Rolle wird nur mit Teilberechtigungen erstellt.** Informationen zum Hinzufügen der fehlenden Berechtigungen finden Sie unter[Probleme bei der Rollengenerierung lösen](#resolve-role-gen-problem).

   1. Wählen Sie **Erstellen**, wenn Sie eine Zustandsmaschine erstellen. Wählen Sie andernfalls **Speichern** aus.

   1. Wählen Sie im daraufhin angezeigten Dialogfeld die Option **Bestätigen** aus.

      Workflow Studio speichert Ihren Zustandsmaschine und erstellt die neue Ausführungsrolle.

## Probleme bei der Rollengenerierung lösen
<a name="resolve-role-gen-problem"></a>

In den folgenden Fällen kann Workflow Studio nicht automatisch eine Ausführungsrolle mit allen erforderlichen Berechtigungen generieren:
+ In Ihrer Zustandsmaschine sind Fehler aufgetreten. Stellen Sie sicher, dass Sie alle Validierungsfehler in Workflow Studio behoben haben. Stellen Sie außerdem sicher, dass Sie alle serverseitigen Fehler beheben, die beim Speichern auftreten.
+ Ihr Zustandsmaschine enthält Aufgaben, die AWS SDK-Integrationen verwenden. Workflow Studio kann in diesem Fall keine IAM Richtlinien [automatisch generieren](#auto-generating-roles). Workflow Studio zeigt ein Banner mit der Nachricht an. **Berechtigungen für bestimmte Aktionen können nicht automatisch generiert werden. Eine IAM Rolle wird nur mit Teilberechtigungen erstellt.** Wählen Sie in der Tabelle **Automatisch generierte Berechtigungen überprüfen** den Inhalt unter **Status** aus, um weitere Informationen zu den Richtlinien zu erhalten, die Ihrer Ausführungsrolle fehlen. Workflow Studio kann immer noch eine Ausführungsrolle generieren, aber diese Rolle enthält nicht IAM Richtlinien für alle Aktionen. Mithilfe der Links unter den **Links zur Dokumentation** können Sie Ihre eigenen Richtlinien schreiben und sie der Rolle hinzufügen, nachdem sie generiert wurde. Diese Links sind auch nach dem Speichern der Zustandsmaschine verfügbar.

## Rolle zum Testen von HTTP-Aufgaben in Workflow Studio
<a name="test-state-role-http"></a>

[Zum Testen](call-https-apis.md#http-task-test) eines HTTP-Aufgabenstatus ist eine Ausführungsrolle erforderlich. Wenn Sie keine Rolle mit ausreichenden Berechtigungen haben, verwenden Sie eine der folgenden Optionen, um eine Rolle zu erstellen:
+ **Automatische Generierung einer Rolle mit Workflow Studio (empfohlen)** — Dies ist die sichere Option. Schließen Sie das Dialogfeld **Teststatus** und folgen Sie den Anweisungen unter[Automatisches Generieren von Rollen](#auto-generating-roles). Dazu müssen Sie zuerst Ihren Zustandsmaschine erstellen oder aktualisieren und dann zu Workflow Studio zurückkehren, um Ihren Status zu testen.
+ **Verwenden Sie eine Rolle mit Administratorzugriff** — Wenn Sie berechtigt sind, eine Rolle mit Vollzugriff auf alle Dienste und Ressourcen zu erstellen AWS, können Sie diese Rolle verwenden, um jede Art von Status in Ihrem Workflow zu testen. Zu diesem Zweck können Sie eine Step Functions Servicerolle erstellen und ihr die [AdministratorAccess Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator) in der IAM Konsole hinzufügen [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

## Rolle zum Testen einer optimierten Serviceintegration in Workflow Studio
<a name="test-state-role-optimized"></a>

Für Aufgabenstatus, die [optimierte Serviceintegrationen](integrate-optimized.md) aufrufen, ist eine Ausführungsrolle erforderlich. Wenn Sie keine Rolle mit ausreichenden Berechtigungen haben, verwenden Sie eine der folgenden Optionen, um eine Rolle zu erstellen:
+ **Automatische Generierung einer Rolle mit Workflow Studio (empfohlen)** — Dies ist die sichere Option. Schließen Sie das Dialogfeld **Teststatus** und folgen Sie den Anweisungen unter[Automatisches Generieren von Rollen](#auto-generating-roles). Dazu müssen Sie zuerst Ihren Zustandsmaschine erstellen oder aktualisieren und dann zu Workflow Studio zurückkehren, um Ihren Status zu testen.
+ **Verwenden Sie eine Rolle mit Administratorzugriff** — Wenn Sie berechtigt sind, eine Rolle mit Vollzugriff auf alle Dienste und Ressourcen zu erstellen AWS, können Sie diese Rolle verwenden, um jede Art von Status in Ihrem Workflow zu testen. Zu diesem Zweck können Sie eine Step Functions Servicerolle erstellen und ihr die [AdministratorAccess Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator) in der IAM Konsole hinzufügen [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

## Rolle zum Testen einer AWS SDK-Dienstintegration in Workflow Studio
<a name="test-state-role-aws-sdk"></a>

Für Aufgabenstatus, die [AWS SDK-Integrationen](supported-services-awssdk.md) aufrufen, ist eine Ausführungsrolle erforderlich. Wenn Sie keine Rolle mit ausreichenden Berechtigungen haben, verwenden Sie eine der folgenden Optionen, um eine Rolle zu erstellen:
+ **Automatische Generierung einer Rolle mit Workflow Studio (empfohlen)** — Dies ist die sichere Option. Schließen Sie das Dialogfeld **Teststatus** und folgen Sie den Anweisungen unter[Automatisches Generieren von Rollen](#auto-generating-roles). Dazu müssen Sie zuerst Ihren Zustandsmaschine erstellen oder aktualisieren und dann zu Workflow Studio zurückkehren, um Ihren Status zu testen. Gehen Sie wie folgt vor:

  1. Schließen Sie das Dialogfeld **Status testen**

  1. Wählen Sie die Registerkarte **Config**, um den Konfigurationsmodus anzuzeigen.

  1. Scrollen Sie nach unten zum Abschnitt „**Berechtigungen**“.

  1. Workflow Studio zeigt ein Banner mit der Nachricht an. **Berechtigungen für bestimmte Aktionen können nicht automatisch generiert werden. Eine IAM Rolle wird nur mit Teilberechtigungen erstellt.** Wählen Sie **Automatisch generierte Berechtigungen überprüfen** aus.

  1. In der Tabelle **„Automatisch generierte Berechtigungen überprüfen**“ wird eine Zeile mit der Aktion angezeigt, die dem Aufgabenstatus entspricht, den Sie testen möchten. Unter den Links zur **Dokumentation finden Sie Links**, um Ihre eigenen IAM Richtlinien in eine benutzerdefinierte Rolle zu schreiben.
+ **Verwenden Sie eine Rolle mit Administratorzugriff** — Wenn Sie berechtigt sind, eine Rolle mit Vollzugriff auf alle Dienste und Ressourcen zu erstellen AWS, können Sie diese Rolle verwenden, um jeden Status in Ihrem Workflow zu testen. Zu diesem Zweck können Sie eine Step Functions Servicerolle erstellen und ihr die [AdministratorAccess Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator) in der IAM Konsole hinzufügen [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

## Rolle zum Testen von Ablaufzuständen in Workflow Studio
<a name="test-state-role-flow"></a>

Sie benötigen eine Ausführungsrolle, um Flussstatus in Workflow Studio zu testen. Ablaufstatus sind die Zustände, die den Ausführungsablauf steuern[Workflow-Status „Auswahl“](state-choice.md), wie[Status des parallelen Workflows](state-parallel.md),[Workflow-Status zuordnen](state-map.md),[Workflow-Status übergeben](state-pass.md),[Workflow-Status warten](state-wait.md),[Workflow-Status erfolgreich](state-succeed.md), oder[Workflow-Status „Fehlgeschlagen“](state-fail.md). Die [TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html)API funktioniert nicht mit Zuordnungs- oder Parallel-Status. Verwenden Sie eine der folgenden Optionen, um eine Rolle zum Testen eines Flow-Status zu erstellen:
+ **Verwenden Sie eine beliebige Rolle in Ihrem AWS-Konto (empfohlen)** — Flow-Status erfordern keine spezifischen IAM Richtlinien, da sie keine AWS Aktionen oder Ressourcen aufrufen. Daher kannst du jede IAM Rolle in deinem verwenden AWS-Konto. 

  1. Wählen Sie im Dialogfeld **Teststatus** eine beliebige Rolle aus der Dropdownliste **Ausführungsrolle** aus.

  1. Wenn in der Dropdownliste keine Rollen angezeigt werden, gehen Sie wie folgt vor:

     1. Wählen Sie in der IAM Konsole [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)**Rollen** aus.

     1. Wählen Sie eine Rolle aus der Liste aus und kopieren Sie ihren ARN von der Seite mit den Rollendetails. Sie müssen diesen ARN im Dialogfeld **Teststatus angeben**.

     1. Wählen Sie im Dialogfeld **Teststatus** in der Dropdownliste ****Ausführungsrolle** die Option Einen Rollen-ARN eingeben** aus.

     1. Fügen Sie den ARN in die **Rolle ARN** ein.
+ **Verwenden Sie eine Rolle mit Administratorzugriff** — Wenn Sie berechtigt sind, eine Rolle mit Vollzugriff auf alle Dienste und Ressourcen zu erstellen AWS, können Sie diese Rolle verwenden, um jeden Status in Ihrem Workflow zu testen. Zu diesem Zweck können Sie eine Step Functions Servicerolle erstellen und ihr die [AdministratorAccess Richtlinie](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_job-functions.html#jf_administrator) in der IAM Konsole hinzufügen [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).

# Konfigurieren Sie die Fehlerbehandlung mit Workflow Studio in Step Functions
<a name="workflow-studio-process-error"></a>

**Status verwalten und Daten transformieren**  
Erfahren Sie mehr über das [Übergeben von Daten zwischen Zuständen mithilfe von Variablen](workflow-variables.md) und das [Transformieren von Daten mit JSONata](transforming-data.md).

Sie können die Fehlerbehandlung im visuellen Editor von Workflow Studio konfigurieren. Wenn ein Status einen Fehler meldet, führt Step Functions standardmäßig dazu, dass die Workflow-Ausführung vollständig fehlschlägt. Für Aktionen und einige Ablaufstatus können Sie konfigurieren, wie Step Functions mit Fehlern umgeht. 

Auch wenn Sie die Fehlerbehandlung konfiguriert haben, können einige Fehler dennoch dazu führen, dass die Ausführung eines Workflows fehlschlägt. Weitere Informationen finden Sie unter [Umgang mit Fehlern in Step Functions Functions-Workflows](concepts-error-handling.md). Konfigurieren Sie in Workflow Studio die Fehlerbehandlung auf der Registerkarte **Fehlerbehandlung** von[Inspektor-Panel](workflow-studio.md#workflow-studio-components-formdefinition). 

## Wiederholung bei Fehlern
<a name="workflow-studio-process-error-retry"></a>

Sie können dem Aktionsstatus und dem [Status des parallelen Workflows](state-parallel.md) Flow-Status eine oder mehrere Regeln hinzufügen, um die Aufgabe erneut zu versuchen, wenn ein Fehler auftritt. Diese Regeln werden *Retrier* genannt. Um einen Retrier hinzuzufügen, wählen Sie das Bearbeitungssymbol im Feld **Retrier \$11** und konfigurieren Sie dann seine Optionen:
+ (Optional) Fügen Sie im Feld **Kommentar** Ihren Kommentar hinzu. Es hat keinen Einfluss auf den Workflow, kann aber verwendet werden, um Ihren Workflow zu kommentieren. 
+ Platzieren Sie den Cursor in das Feld **Fehler** und wählen Sie einen Fehler aus, durch den der Abruf ausgelöst wird, oder geben Sie einen benutzerdefinierten Fehlernamen ein. Sie können mehrere Fehler auswählen oder hinzufügen.
+ (Optional) Legen Sie ein **Intervall** fest. Dies ist die Zeit in Sekunden, bevor Step Functions seinen ersten Wiederholungsversuch durchführt. Es folgen weitere Wiederholungen in Intervallen, die Sie mit **Max. Anzahl der Versuche** und **Backoff-Rate** konfigurieren können.
+ **(Optional) Legen Sie „Max. Versuche“ fest.** Dies ist die maximale Anzahl von Wiederholungsversuchen, bevor Step Functions dazu führt, dass die Ausführung fehlschlägt.
+ (Optional) Stellen Sie die **Backoff-Rate** ein. Dies ist ein Multiplikator, der bestimmt, um wie viel sich das Wiederholungsintervall bei jedem Versuch verlängert.

**Anmerkung**  
Nicht alle Optionen zur Fehlerbehandlung sind für alle Bundesstaaten verfügbar. Bei Lambda Invoke ist standardmäßig ein Retrier konfiguriert.

## Fehler abfangen
<a name="workflow-studio-process-error-catch"></a>

Sie können den Aktionszuständen und den [Workflow-Status zuordnen](state-map.md) Ablaufstatus eine oder mehrere Regeln hinzufügen, um einen Fehler abzufangen. [Status des parallelen Workflows](state-parallel.md) Diese Regeln werden *Catcher* genannt. Um einen Catcher hinzuzufügen, wählen Sie **Neuen Catcher hinzufügen** und konfigurieren Sie dann seine Optionen:
+ (Optional) Fügen Sie im Feld **Kommentar** Ihren Kommentar hinzu. Es hat keinen Einfluss auf den Workflow, kann aber verwendet werden, um Ihren Workflow zu kommentieren. 
+ Platzieren Sie den Cursor in das Feld **Fehler** und wählen Sie einen Fehler aus, durch den der Catcher ausgelöst wird, oder geben Sie einen benutzerdefinierten Fehlernamen ein. Sie können mehrere Fehler auswählen oder hinzufügen.
+ Wählen Sie im Feld **Fallback-Status** einen [Fallback-Status](concepts-error-handling.md#error-handling-fallback-states) aus. Dies ist der Status, in den der Workflow als Nächstes wechselt, nachdem ein Fehler erkannt wurde.
+ (Optional) Fügen Sie in dem **ResultPath**Feld einen `ResultPath` Filter hinzu, um den Fehler zur ursprünglichen Statuseingabe hinzuzufügen. Der [`ResultPath`](input-output-resultpath.md)muss gültig sein [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/). Dies wird in den Fallback-Status gesendet.

## Timeouts
<a name="workflow-studio-process-error-timeout"></a>

Sie können ein Timeout für Aktionsstatus konfigurieren, um die maximale Anzahl von Sekunden festzulegen, für die Ihr Status ausgeführt werden kann, bevor er fehlschlägt. Verwenden Sie Timeouts, um zu verhindern, dass Ausführungen hängenbleiben. Um ein Timeout zu konfigurieren, geben Sie die Anzahl der Sekunden ein, die Ihr Bundesstaat warten soll, bevor die Ausführung fehlschlägt. Weitere Informationen zu Timeouts finden Sie unter `TimeoutSeconds` im [Workflow-Status der Aufgabe](state-task.md) Status.

## HeartbeatSeconds
<a name="workflow-studio-process-error-heartbeat"></a>

Sie können eine *Heartbeat-Benachrichtigung* oder eine regelmäßige Benachrichtigung konfigurieren, die von Ihrer Aufgabe gesendet wird. Wenn Sie ein Taktintervall festlegen und Ihr Bundesstaat in den konfigurierten Intervallen keine Heartbeat-Benachrichtigungen sendet, wird die Aufgabe als fehlgeschlagen markiert. Um einen Heartbeat zu konfigurieren, legen Sie eine positive Ganzzahl ungleich Null für Sekunden fest. Weitere Informationen finden Sie unter `HeartBeatSeconds` in [Workflow-Status der Aufgabe](state-task.md) state. 

# Verwenden von Workflow Studio Infrastructure Composer zur Erstellung von Step Functions Functions-Workflows
<a name="use-wfs-in-app-composer"></a>

Workflow Studio ist verfügbar inInfrastructure Composer, um Sie beim Entwerfen und Erstellen Ihrer Workflows zu unterstützen. Workflow Studio in Infrastructure Composer bietet eine visuelle IaC-Umgebung (Infrastructure as Code), mit der Sie Workflows auf einfache Weise in Ihre serverlosen Anwendungen integrieren können, die mit IaC-Tools wie Vorlagen erstellt wurden. CloudFormation 

AWS Infrastructure Composerist ein Visual Builder, der Sie bei der Entwicklung AWS SAM und Erstellung von AWS CloudFormation Vorlagen mithilfe einer einfachen grafischen Oberfläche unterstützt. Mit entwerfen Sie eine AnwendungsarchitekturInfrastructure Composer, indem Sie sie auf einer visuellen Leinwand ziehen, gruppieren und verbinden AWS-Services . Infrastructure Composererstellt dann aus Ihrem Design eine IaC-Vorlage, die Sie verwenden können, um Ihre Anwendung mit der AWS SAM Befehlszeilenschnittstelle (AWS SAMCLI) oder CloudFormation bereitzustellen. Weitere Informationen über Infrastructure Composer finden Sie unter [Was ist Infrastructure Composer](https://docs.aws.amazon.com/application-composer/latest/dg/what-is-composer.html).

Wenn Sie Workflow Studio in verwendenInfrastructure Composer, verbindet Infrastructure Composer die einzelnen Workflow-Schritte mit AWS Ressourcen und generiert die Ressourcenkonfigurationen in einer AWS SAM Vorlage. Infrastructure Composerfügt außerdem die IAM Berechtigungen hinzu, die für die Ausführung Ihres Workflows erforderlich sind. Mit Workflow Studio in Infrastructure Composer können Sie Prototypen Ihrer Anwendungen erstellen und sie in produktionsreife Anwendungen umwandeln.

Wenn Sie Workflow Studio in verwendenInfrastructure Composer, können Sie zwischen der Infrastructure Composer Arbeitsfläche und Workflow Studio hin und her wechseln.

**Topics**
+ [Verwenden von Workflow Studio in Infrastructure Composer](#procedure-use-wfs-in-app-composer)
+ [Dynamisches Verweisen auf Ressourcen mithilfe von CloudFormation Definitionsersetzungen](#use-cfn-sub-edit-state-machine-resource)
+ [Connect Aufgaben zur Serviceintegration mit erweiterten Komponentenkarten](#connect-service-integrations-enhanced-cards)
+ [Importieren Sie bestehende Projekte und synchronisieren Sie sie lokal](#import-projects-local-sync)
+ [Exportieren Sie Step Functions Functions-Workflows direkt in AWS Infrastructure Composer](#export-wsf-projects-into-app-composer)
+ [Nicht verfügbare Funktionen von Workflow Studio in AWS Infrastructure Composer](#wfs-features-unavailable-app-composer)

## Verwenden Sie Workflow Studio inInfrastructure Composer, um einen serverlosen Workflow zu erstellen
<a name="procedure-use-wfs-in-app-composer"></a>

1. Öffnen Sie die [Infrastructure Composer-Konsole](https://console.aws.amazon.com/composer/home) und wählen Sie **Projekt erstellen**, um ein Projekt zu erstellen.

1. Geben Sie im Suchfeld in der **Ressourcenpalette** **state machine** ein.

1. Ziehen Sie die **Step FunctionsState Machine-Ressource** auf die Arbeitsfläche. 

1. Wählen Sie **In Workflow Studio bearbeiten**, um Ihre State Machine-Ressource zu bearbeiten.

   Die folgende Animation zeigt, wie Sie zum Workflow Studio wechseln können, um Ihre State-Machine-Definition zu bearbeiten.  
![\[Eine Animation, die veranschaulicht, wie Sie Workflow Studio in verwenden könnenInfrastructure Composer.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/use-wfs-in-app-composer.gif)

   Die Integration mit Workflow Studio zur Bearbeitung von Zustandsmaschinen, in denen Ressourcen erstellt wurden, Infrastructure Composer ist nur für [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)Ressourcen verfügbar. Diese Integration ist nicht für Vorlagen verfügbar, die die [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)Ressource verwenden.

## Verweisen Sie dynamisch auf Ressourcen mithilfe von CloudFormation Definitionsersetzungen in Workflow Studio
<a name="use-cfn-sub-edit-state-machine-resource"></a>

In Workflow Studio können Sie Definitionsersetzungen in Ihrer CloudFormation Workflow-Definition verwenden, um dynamisch auf Ressourcen zu verweisen, die Sie in Ihrer IaC-Vorlage definiert haben. Sie können Ihrer Workflow-Definition mithilfe der `${dollar_sign_brace}` Notation Platzhalterersetzungen hinzufügen, die bei der Stapelerstellung durch tatsächliche Werte ersetzt werden. CloudFormation Weitere Informationen zu Definitionsersetzungen finden Sie unter. [DefinitionSubstitutions in Vorlagen AWS SAM](concepts-sam-sfn.md#sam-definition-substitution-eg)

Die folgende Animation zeigt, wie Sie Platzhalterersetzungen für die Ressourcen in Ihrer State-Machine-Definition hinzufügen können.

![\[Die Animation zeigt, wie Sie Platzhalterersetzungen für Ressourcen in Ihrer Zustandsmaschine hinzufügen.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/use-def-sub-wfs-app-composer.gif)


## Connect Aufgaben zur Serviceintegration mit erweiterten Komponentenkarten
<a name="connect-service-integrations-enhanced-cards"></a>

Sie können die Aufgaben, die [optimierte Serviceintegrationen](integrate-optimized.md) aufrufen, mit [erweiterten Komponentenkarten](https://docs.aws.amazon.com/application-composer/latest/dg/reference-cards.html#reference-cards-enhanced-components) in Infrastructure Composer Canvas verbinden. Dadurch werden automatisch alle Platzhalterersetzungen zugeordnet, die durch die `${dollar_sign_brace}` Notation in Ihrer Workflow-Definition und der `DefinitionSubstitution` Eigenschaft für Ihre Ressource angegeben sind. `StateMachine` Außerdem werden die entsprechenden AWS SAM Richtlinien für die Zustandsmaschine hinzugefügt.

Wenn Sie Aufgaben zur optimierten Serviceintegration [Standardkomponentenkarten](https://docs.aws.amazon.com/application-composer/latest/dg/using-composer-cards.html#using-composer-cards-component-intro) zuordnen, wird die Verbindungslinie nicht auf der Infrastructure Composer Arbeitsfläche angezeigt.

Die folgende Animation zeigt, wie Sie eine optimierte Aufgabe mit einer erweiterten Komponentenkarte verbinden und die Änderungen im [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) anzeigen können.

![\[Die Animation zeigt, wie Aufgaben miteinander verknüpft und Serviceintegrationen optimiert werden.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/make-connections-wfs-app-composer.gif)


Sie können [AWS SDK-Integrationen](supported-services-awssdk.md) in Ihrem Task-Status nicht mit erweiterten Komponentenkarten oder optimierten Serviceintegrationen mit Standardkomponentenkarten verbinden. Für diese Aufgaben können Sie die Ersetzungen im Bereich „**Ressourceneigenschaften**“ auf der Infrastructure Composer Arbeitsfläche zuordnen und Richtlinien zur Vorlage hinzufügen. AWS SAM

**Tipp**  
**Alternativ können Sie auch Platzhalterersetzungen für Ihren Zustandsmaschine unter **Definitionsersetzungen** im Bereich Ressourceneigenschaften zuordnen.** Wenn Sie dies tun, müssen Sie die erforderlichen Berechtigungen für AWS-Service Ihre Task-State-Aufrufe in der Rolle State-Machine-Ausführung hinzufügen. Informationen zu den Berechtigungen, die Ihre Ausführungsrolle möglicherweise benötigt, finden Sie unter[Richten Sie Ausführungsrollen mit Workflow Studio in Step Functions ein](manage-state-machine-permissions.md).

Die folgende Animation zeigt, wie Sie die Zuordnung der Platzhalterersetzung im Bereich „**Ressourceneigenschaften**“ manuell aktualisieren können.

![\[Die Animation zeigt, wie die Zuordnung von Platzhalterersetzungen im Bereich mit den Ressourceneigenschaften aktualisiert wird.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/manual-update-placeholder-mapping.gif)


## Importieren Sie bestehende Projekte und synchronisieren Sie sie lokal
<a name="import-projects-local-sync"></a>

Sie können bestehende CloudFormation AWS SAM Projekte öffnen, um sie Infrastructure Composer zum besseren Verständnis zu visualisieren und ihre Entwürfe zu ändern. Mit Infrastructure Composer der [lokalen Synchronisierungsfunktion](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html) können Sie Ihre Vorlagen- und Codedateien automatisch synchronisieren und auf Ihrem lokalen Build-Computer speichern. Die Verwendung des lokalen Synchronisierungsmodus kann Ihre bestehenden Entwicklungsabläufe ergänzen. Stellen Sie sicher, dass Ihr Browser die [File System Access API](https://docs.aws.amazon.com/application-composer/latest/dg/reference-fsa.html) unterstützt, die es Webanwendungen ermöglicht, Dateien in Ihrem lokalen Dateisystem zu lesen, zu schreiben und zu speichern. Wir empfehlen, entweder Google Chrome oder Microsoft Edge zu verwenden.

## Exportieren Sie Step Functions Functions-Workflows direkt in AWS Infrastructure Composer
<a name="export-wsf-projects-into-app-composer"></a>

Die AWS Step Functions Konsole bietet die Möglichkeit, einen gespeicherten State-Machine-Workflow als Vorlage zu exportieren, die von als erweiterte IaC-Ressource erkannt wirdInfrastructure Composer. Diese Funktion erstellt eine IaC-Vorlage als AWS SAM Schema und leitet Sie zu. Infrastructure Composer Weitere Informationen finden Sie unter [Exportieren Sie Ihren Workflow in IaC-Vorlagen](exporting-iac-templates.md).

## Nicht verfügbare Funktionen von Workflow Studio in AWS Infrastructure Composer
<a name="wfs-features-unavailable-app-composer"></a>

Wenn Sie Workflow Studio in verwendenInfrastructure Composer, sind einige der Funktionen von Workflow Studio nicht verfügbar. Darüber hinaus unterstützt der Abschnitt **API-Parameter**, der [Inspektor-Panel](workflow-studio.md#workflow-studio-components-formdefinition) im Bereich verfügbar ist, CloudFormation Definitionsersetzungen. Sie können die Substitutionen [Code-Modus](workflow-studio.md#wfs-interface-code-mode) mithilfe der `${dollar_sign_brace}` Notation hinzufügen. Weitere Informationen zu dieser Notation finden Sie unter[DefinitionSubstitutions in Vorlagen AWS SAM](concepts-sam-sfn.md#sam-definition-substitution-eg).

In der folgenden Liste werden die Funktionen von Workflow Studio beschrieben, die nicht verfügbar sind, wenn Sie Workflow Studio in verwendenInfrastructure Composer:
+ [Starter-Vorlagen](starter-templates.md) — Starter-Vorlagen sind ready-to-run Beispielprojekte, mit denen die Workflow-Prototypen und -Definitionen automatisch erstellt werden. Diese Vorlagen stellen alle zugehörigen AWS Ressourcen bereit, die Ihr Projekt für Sie AWS-Konto benötigt.
+ [Konfigurationsmodus](workflow-studio.md#wfs-interface-config-mode) — In diesem Modus können Sie die Konfiguration Ihrer Zustandsmaschinen verwalten. Sie können Ihre State-Machine-Konfigurationen in Ihren IaC-Vorlagen aktualisieren oder den Bereich mit den **Ressourceneigenschaften** Infrastructure Composer auf der Leinwand verwenden. Informationen zum Aktualisieren von Konfigurationen im Bereich mit den **Ressourceneigenschaften** finden Sie unter[Connect Aufgaben zur Serviceintegration mit erweiterten Komponentenkarten](#connect-service-integrations-enhanced-cards).
+ [TestState](test-state-isolation.md)-API
+ Option zum Importieren oder Exportieren von Workflow-Definitionen über die Dropdownschaltfläche „**Aktionen**“ in Workflow Studio. Wählen Sie stattdessen im Infrastructure Composer **Menü** **Öffnen** > **Projektordner**. Stellen Sie sicher, dass Sie den [lokalen Synchronisierungsmodus](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html) aktiviert haben, damit Ihre Änderungen im Infrastructure Composer Canvas automatisch direkt auf Ihrem lokalen Computer gespeichert werden.
+ Schaltfläche „**Ausführen**“. Wenn Sie Workflow Studio in verwendenInfrastructure Composer, Infrastructure Composer generiert es den IaC-Code für Ihren Workflow. Daher müssen Sie zuerst die Vorlage bereitstellen. Führen Sie dann den Workflow in der Konsole oder über die aus AWS Command Line Interface(AWS CLI).

# Zum Erstellen von Step Functions Functions-Workflows verwenden AWS SAM
<a name="concepts-sam-sfn"></a>

Sie können Step Functions verwenden AWS Serverless Application Model , um Workflows zu erstellen und die Infrastruktur bereitzustellen, die Sie benötigen, einschließlich Lambda-Funktionen APIs und Ereignisse, um serverlose Anwendungen zu erstellen.

Sie können die AWS Serverless Application Model CLI auch in Verbindung mit der AWS Toolkit for Visual Studio Code als Teil einer integrierten Erfahrung verwenden, um AWS Step Functions Zustandsmaschinen zu erstellen und bereitzustellen. Sie können eine serverlose Anwendung mit AWS SAM der VS Code IDE erstellen und dann Ihre Zustandsmaschine ausbauen. Anschließend können Sie Ihre Ressourcen validieren, verpacken und bereitstellen. 

**Tipp**  
Informationen zur Bereitstellung einer serverlosen Beispielanwendung, mit der ein Step Functions Functions-Workflow gestartet wird AWS SAM, finden Sie unter [Deploy with AWS SAM](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-sam) *im AWS Step Functions Workshop*.

## Warum sollten Sie Step Functions mit verwenden AWS SAM?
<a name="concepts-sam-sfn-integration"></a>

Wenn Sie Step Functions mit verwenden AWS SAM , können Sie:
+ Beginnen Sie mit einer AWS SAM Beispielvorlage.
+ Integrieren Sie Ihren Zustandsautomaten in Ihre serverlose Anwendung.
+ Verwenden Sie die Variablenersetzung, um ARNs sie zum Zeitpunkt der Bereitstellung durch Ihre Zustandsmaschine zu ersetzen.

   AWS CloudFormationunterstützt [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), mit denen Sie dynamische Verweise in Ihrer Workflow-Definition zu einem Wert hinzufügen können, den Sie in Ihrer CloudFormation Vorlage angeben. Sie können dynamische Verweise hinzufügen, indem Sie Ihrer Workflow-Definition mithilfe der `${dollar_sign_brace}` Notation Substitutionen hinzufügen. Sie müssen diese dynamischen Verweise auch in der `DefinitionSubstitutions` Eigenschaft für die StateMachine Ressource in Ihrer CloudFormation Vorlage definieren. Diese Ersetzungen werden bei der Erstellung des CloudFormation Stacks durch tatsächliche Werte ersetzt. Weitere Informationen finden Sie unter [DefinitionSubstitutions in Vorlagen AWS SAM](#sam-definition-substitution-eg). 
+ Geben Sie die Rolle Ihres Zustandsmaschinen mithilfe von AWS SAM Richtlinienvorlagen an.
+ Initiieren Sie State-Machine-Ausführungen mit API Gateway, EventBridge Ereignissen oder nach einem Zeitplan innerhalb Ihrer AWS SAM Vorlage. 

## Step Functions Integration mit der AWS SAM Spezifikation
<a name="concepts-sam-sfn-ots2"></a>

Sie können die [AWS SAM Richtlinienvorlagen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html) verwenden, um Ihrem Zustandsmaschine Berechtigungen hinzuzufügen. Mit diesen Berechtigungen können Sie Lambda-Funktionen und andere AWS Ressourcen orchestrieren, um komplexe und robuste Workflows zu bilden. 

## Integration von Schrittfunktionen in die SAM-CLI
<a name="concepts-sam-sfn-ots3"></a>

Step Functions ist in die AWS SAM CLI integriert. Verwenden Sie diese Option, um einen Zustandsautomaten schnell in Ihre serverlose Anwendung zu entwickeln.

Probieren Sie das [Erstellen Sie eine Step Functions Functions-Zustandsmaschine mit AWS SAM](tutorial-state-machine-using-sam.md) Tutorial aus, um zu erfahren, wie Sie AWS SAM Zustandsmaschinen erstellen.

Zu den unterstützten AWS SAM CLI-Funktionen gehören: 


| CLI-Befehl | Description | 
| --- | --- | 
| sam init |  Initialisiert eine serverlose Anwendung mit einer Vorlage. AWS SAM Kann mit einer SAM-Vorlage für Schrittfunktionen verwendet werden.  | 
| sam validate | Validiert eine Vorlage. AWS SAM  | 
| sam package |  Paketiert eine AWS SAM Anwendung. Es erstellt eine ZIP-Datei mit Ihrem Code und Ihren Abhängigkeiten und lädt sie dann auf Amazon S3 hoch. Anschließend wird eine Kopie Ihrer AWS SAM -Vorlage zurückgegeben, wobei Verweise auf lokale Artefakte durch den Amazon S3-Speicherort ersetzt werden, zu dem der Befehl die Artefakte hochgeladen hat.  | 
| sam deploy | Stellt eine AWS SAM Anwendung bereit. | 
| sam publish |  Veröffentlichen Sie eine AWS SAM Anwendung auf der AWS Serverless Application Repository. Dieser Befehl verwendet ein AWS SAM Vorlagenpaket und veröffentlicht die Anwendung in der angegebenen Region.  | 

**Anmerkung**  
Wenn Sie AWS SAM local verwenden, können Sie Lambda und API Gateway lokal emulieren. Sie können Step Functions jedoch nicht lokal emulieren, indem Sie AWS SAM.

## DefinitionSubstitutions in Vorlagen AWS SAM
<a name="sam-definition-substitution-eg"></a>

Sie können Zustandsmaschinen mithilfe von CloudFormation Vorlagen mit definierenAWS SAM. Unter Verwendung von AWS SAM können Sie den Zustandsautomaten inline in der Vorlage oder in einer separaten Datei definieren. Die folgende AWS SAM Vorlage enthält eine Zustandsmaschine, die einen Aktienhandelsablauf simuliert. Diese Zustandsmaschine ruft drei Lambda Funktionen auf, um den Kurs einer Aktie zu überprüfen und festzustellen, ob die Aktie gekauft oder verkauft werden soll. Diese Transaktion wird dann in einer Amazon DynamoDB Tabelle aufgezeichnet. Die ARNs Lambda Funktionen und die DynamoDB Tabelle in der folgenden Vorlage werden mit angegeben [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
```

Der folgende Code ist die Zustandsmaschinen-Definition in der Datei`stock_trader.asl.json`, die im [Erstellen Sie eine Step Functions Functions-Zustandsmaschine mit AWS SAM](tutorial-state-machine-using-sam.md) Tutorial verwendet wird. Diese Zustandsmaschinen-Definition enthält mehrere Zustandsmaschinen, die durch die Notation `DefinitionSubstitutions` gekennzeichnet sind. `${dollar_sign_brace}` Anstatt beispielsweise einen statischen Lambda Funktions-ARN für die `Check Stock Value` Aufgabe anzugeben, `${StockCheckerFunctionArn}` wird die Substitution verwendet. Diese Substitution ist in der [DefinitionSubstitutions](#sam-template-def-substitution) Eigenschaft der Vorlage definiert. `DefinitionSubstitutions`ist eine Zuordnung von Schlüssel-Wert-Paaren für die Zustandsmaschinen-Ressource. In`DefinitionSubstitutions`, \$1 \$1StockCheckerFunctionArn\$1 wird mithilfe der systemeigenen Funktion dem ARN der `StockCheckerFunction` CloudFormation Ressource zugeordnet. [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) Wenn Sie die AWS SAM Vorlage bereitstellen, werden die `DefinitionSubstitutions` in der Vorlage enthaltenen Werte durch die tatsächlichen Werte ersetzt.

```
{
    "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
        }
    }
}
```

## Nächste Schritte
<a name="concepts-sam-sfn-next-steps"></a>

In den folgenden Ressourcen erfahren Sie mehr über die Verwendung von Step Functions: AWS SAM 
+ Schließen Sie das [Erstellen Sie eine Step Functions Functions-Zustandsmaschine mit AWS SAM](tutorial-state-machine-using-sam.md) Tutorial ab, um eine Zustandsmaschine mit zu erstellen AWS SAM.
+ Geben Sie eine [AWS::Serverless::StateMachine](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-statemachine.html)Ressource an.
+ Suchen Sie die zu verwendenden [AWS SAM -Richtlinienvorlagen](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-policy-templates.html).
+ [AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/stepfunctions.html)Mit Step Functions verwenden. 
+ Lesen Sie die [AWS SAM CLI-Referenz](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html), um mehr über die Funktionen zu erfahren, die in verfügbar sind AWS SAM.

Sie können Ihre Workflows auch in Infrastructure as Code (IaC) mithilfe von Visual Buildern wie Workflow Studio in Infrastructure Composer entwerfen und erstellen. Weitere Informationen finden Sie unter [Verwenden von Workflow Studio Infrastructure Composer zur Erstellung von Step Functions Functions-Workflows](use-wfs-in-app-composer.md).

# Verwenden CloudFormation , um einen Workflow in Step Functions zu erstellen
<a name="tutorial-lambda-state-machine-cloudformation"></a>

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
<a name="lambda-state-machine-cfn-step-1"></a>

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
<a name="lambda-state-machine-cfn-procedure-create-iam-role"></a>

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
<a name="lambda-state-machine-cfn-create-function"></a>

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
<a name="lambda-state-machine-cfn-create-role"></a>

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
<a name="lambda-state-machine-cfn-create"></a>

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
<a name="lambda-state-machine-cfn-step-2"></a>

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
<a name="to-create-the-lam-state-machine"></a>

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
<a name="lambda-state-machine-cfn-step-3"></a>

Nachdem Sie Ihre Lambda-Zustandsmaschine erstellt haben, können Sie deren Ausführung starten.

### Starten der Ausführung des Zustandsautomaten
<a name="to-start-the-state-machine-execution"></a>

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)**.

# Verwenden AWS CDK , um einen Standard-Workflow in Step Functions zu erstellen
<a name="tutorial-lambda-state-machine-cdk"></a>

Sie können das AWS Cloud Development Kit (AWS CDK) Infrastructure as Code (IAC) -Framework verwenden, um eine AWS Step Functions Zustandsmaschine zu erstellen, die eine AWS Lambda Funktion enthält.

Sie definieren die AWS Infrastruktur in einer CDK der unterstützten Sprachen. Nachdem Sie Ihre Infrastruktur definiert haben, synthetisieren Sie Ihre App zu einer CloudFormation Vorlage und stellen sie in Ihrem AWS Konto bereit.

 Mit dieser Methode definieren Sie eine Step Functions-Zustandsmaschine, die eine Lambda-Funktion enthält, und führen dann die Zustandsmaschine mithilfe der Step Functions AWS-Managementkonsole aus. 

Bevor Sie mit diesem Tutorial beginnen, müssen Sie Ihre AWS CDK Entwicklungsumgebung wie unter [Erste Schritte mit den AWS CDK — Voraussetzungen](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_prerequisites) im *AWS Cloud Development Kit (AWS CDK) Entwicklerhandbuch* beschrieben einrichten. Installieren Sie dann das AWS CDK mit dem folgenden Befehl unterAWS CLI:

```
npm install -g aws-cdk
```

Dieses Tutorial liefert das gleiche Ergebnis wie[Verwenden CloudFormation , um einen Workflow in Step Functions zu erstellen](tutorial-lambda-state-machine-cloudformation.md). In diesem Tutorial müssen Sie jedoch AWS CDK keine IAM Rollen erstellen, der AWS CDK erledigt das für Sie. Die AWS CDK Version enthält auch einen [Workflow-Status erfolgreich](state-succeed.md) Schritt, der veranschaulicht, wie Sie Ihrer Zustandsmaschine zusätzliche Schritte hinzufügen können.

**Tipp**  
Informationen zum Bereitstellen einer serverlosen Beispielanwendung, die einen Step Functions Workflow AWS CDK mit mit startet TypeScript, finden Sie unter [Deploy with AWS CDK](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-cdk) *im AWS Step Functions Workshop*.

## Schritt 1: Einrichten des Projekts AWS CDK
<a name="lambda-state-machine-cdk-step-1"></a>

1. Führen Sie in Ihrem Home-Verzeichnis oder, falls Sie es vorziehen, in einem anderen Verzeichnis den folgenden Befehl aus, um ein Verzeichnis für Ihre neue AWS CDK App zu erstellen.
**Wichtig**  
Achten Sie darauf, dem Verzeichnis einen Namen zu geben`step`. Die AWS CDK Anwendungsvorlage verwendet den Namen des Verzeichnisses, um Namen für Quelldateien und Klassen zu generieren. Wenn Sie einen anderen Namen verwenden, wird Ihre App nicht mit diesem Lernprogramm übereinstimmen.

------
#### [ TypeScript ]

   ```
   mkdir step && cd step
   ```

------
#### [ JavaScript ]

   ```
   mkdir step && cd step
   ```

------
#### [ Python ]

   ```
   mkdir step && cd step
   ```

------
#### [ Java ]

   ```
   mkdir step && cd step
   ```

------
#### [ C\$1 ]

   Stellen Sie sicher, dass Sie.NET Version 6.0 oder höher installiert haben. Weitere Informationen finden Sie unter [Unterstützte Versionen](https://dotnet.microsoft.com/en-us/download/dotnet).

   ```
   mkdir step && cd step
   ```

------

1. Initialisieren Sie die App mit dem Befehl **cdk init**. Geben Sie die gewünschte Vorlage („App“) und die gewünschte Programmiersprache an, wie in den folgenden Beispielen gezeigt.

------
#### [ TypeScript ]

   ```
   cdk init --language typescript
   ```

------
#### [ JavaScript ]

   ```
   cdk init --language javascript
   ```

------
#### [ Python ]

   ```
   cdk init --language python
   ```

   Nachdem das Projekt initialisiert wurde, aktivieren Sie die virtuelle Umgebung des Projekts und installieren Sie die AWS CDK Basisabhängigkeiten.

   ```
   source .venv/bin/activate
   python -m pip install -r requirements.txt
   ```

------
#### [ Java ]

   ```
   cdk init --language java
   ```

------
#### [ C\$1 ]

   ```
   cdk init --language csharp
   ```

------

## Schritt 2: Verwenden Sie diese OptionAWS CDK, um eine Zustandsmaschine zu erstellen
<a name="lambda-state-machine-cdk-step-2"></a>

Zunächst stellen wir die einzelnen Codeteile vor, die die Lambda Funktion und die Step Functions Zustandsmaschine definieren. Dann erklären wir, wie Sie sie in Ihrer AWS CDK App zusammenfügen. Schließlich erfahren Sie, wie Sie diese Ressourcen synthetisieren und einsetzen können.

### So erstellen Sie eine Lambda-Funktion
<a name="lambda-state-machine-cdk-create-function"></a>

Der folgende AWS CDK Code definiert die Lambda Funktion und stellt ihren Quellcode inline bereit.

------
#### [ 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)
});
```

------

Sie können in diesem kurzen Beispielcode sehen:
+ Der logische Name der Funktion,`MyLambdaFunction`.
+ Der Quellcode für die Funktion, eingebettet als Zeichenfolge in den Quellcode der AWS CDK App.
+ Andere Funktionsattribute, wie die zu verwendende Laufzeit (Node 18.x), der Einstiegspunkt der Funktion und ein Timeout.

### Erstellen eines -Zustandsautomaten
<a name="lambda-state-machine-cdk-create"></a>

Unsere Zustandsmaschine hat zwei Zustände: eine Lambda Funktionsaufgabe und einen [Workflow-Status erfolgreich](state-succeed.md) Status. Die Funktion erfordert, dass wir eine erstellen Step Functions[Workflow-Status der Aufgabe](state-task.md), die unsere Funktion aufruft. Dieser Task-Status wird als erster Schritt in der Zustandsmaschine verwendet. Der Erfolgsstatus wird der Zustandsmaschine mithilfe der `next()` Methode des Task-Status hinzugefügt. Der folgende Code ruft zuerst die angegebene Funktion auf und verwendet dann die `next()` Methode`MyLambdaTask`, um einen Erfolgsstatus mit dem Namen `GreetedWorld` zu definieren.

------
#### [ 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")))
});
```

------

### Um die App zu erstellen und bereitzustellen AWS CDK
<a name="lambda-state-machine-cdk-app"></a>

Bearbeiten Sie in Ihrem neu erstellten AWS CDK Projekt die Datei, die die Definition des Stacks enthält, sodass sie wie im folgenden Beispielcode aussieht. Sie kennen die Definitionen der Lambda Funktion und der Step Functions Zustandsmaschine aus den vorherigen Abschnitten.

1. Aktualisieren Sie den Stack wie in den folgenden Beispielen gezeigt.

------
#### [ TypeScript ]

   Aktualisieren Sie `lib/step-stack.ts` mit dem folgenden Code.

   ```
   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 ]

   Aktualisieren Sie `lib/step-stack.js` mit dem folgenden Code.

   ```
   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 ]

   Aktualisieren Sie `step/step_stack.py` mit dem folgenden Code.

   ```
   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 ]

   Aktualisieren Sie `src/main/java/com.myorg/StepStack.java` mit dem folgenden Code.

   ```
   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 ]

   Aktualisieren Sie `src/Step/StepStack.cs` mit dem folgenden Code.

   ```
   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. Speichern Sie die Quelldatei und führen Sie dann den `cdk synth` Befehl im Hauptverzeichnis der App aus.

   AWS CDKführt die App aus und synthetisiert daraus eine CloudFormation Vorlage. AWS CDKzeigt dann die Vorlage an.
**Anmerkung**  
Wenn Sie Ihr AWS CDK Projekt TypeScript früher erstellt haben, kann beim Ausführen des `cdk synth` Befehls der folgende Fehler zurückgegeben werden.  

   ```
   TSError: ⨯ Unable to compile TypeScript:
   bin/step.ts:7:33 - error TS2554: Expected 2 arguments, but got 3.
   ```
Ändern Sie die `bin/step.ts` Datei wie im folgenden Beispiel gezeigt, um diesen Fehler zu beheben.  

   ```
   #!/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. Um die Lambda-Funktion und die Step Functions Functions-Zustandsmaschine für Ihr AWS Konto bereitzustellen, geben `cdk deploy` Sie Folgendes ein. Sie werden aufgefordert, die von ihm generierten IAM-Richtlinien zu genehmigen. AWS CDK 

## Schritt 3: Starten Sie eine State-Machine-Ausführung
<a name="lambda-state-machine-cdk-step-3"></a>

Nachdem Sie Ihre Zustandsmaschine erstellt haben, können Sie deren Ausführung starten.

### Starten der Ausführung des Zustandsautomaten
<a name="to-start-the-state-machine-execution"></a>

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 habenAWS CDK.

1. Wählen Sie auf der State-Machine-Seite die Option **Ausführung starten** aus.

   Das Dialogfeld **Ausführung starten** 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 Beschriftungen, 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.

   Die Ausführung Ihrer Zustandsmaschine wird gestartet und eine neue Seite mit Ihrer laufenden Ausführung wird angezeigt.

1. Die Step Functions Functions-Konsole leitet Sie zu einer Seite weiter, die mit Ihrer Ausführungs-ID betitelt ist. Diese Seite wird als Seite mit den *Ausführungsdetails* bezeichnet. Auf dieser Seite können Sie die Ausführungsergebnisse im Verlauf der Ausführung oder nach deren Abschluss überprüfen.

   Um die Ausführungsergebnisse zu überprüfen, wählen Sie in der **Diagrammansicht** einzelne Status aus und wählen Sie dann die einzelnen Registerkarten im [Einzelheiten zu den Schritten](concepts-view-execution-details.md#exec-details-intf-step-details) Bereich, um die Details der einzelnen Status, einschließlich Eingabe, Ausgabe und Definition, anzuzeigen. Einzelheiten zu den Ausführungsinformationen, die Sie auf der Seite mit den *Ausführungsdetails* einsehen können, finden Sie unter[Überblick über die Ausführungsdetails](concepts-view-execution-details.md#exec-details-interface-overview).

## Schritt 4: Bereinigen
<a name="lambda-state-machine-cdk-step-4"></a>

Nachdem Sie Ihre Zustandsmaschine getestet haben, empfehlen wir Ihnen, sowohl Ihre Zustandsmaschine als auch die zugehörige Lambda-Funktion zu entfernen, um Ressourcen in Ihrem AWS-Konto freizugeben. Führen Sie den `cdk destroy` Befehl im Hauptverzeichnis Ihrer App aus, um Ihre Zustandsmaschine zu entfernen.

## Nächste Schritte
<a name="lambda-state-machine-cdk-next-steps"></a>

Weitere Informationen zur Entwicklung von AWS Infrastrukturen mithilfe von Cookies AWS CDK finden Sie im [AWS CDKEntwicklerhandbuch](https://docs.aws.amazon.com/cdk/v2/guide/home.html).

Informationen zum Schreiben von AWS CDK-Apps in der Sprache Ihrer Wahl finden Sie unter:

------
#### [ TypeScript ]

 [Arbeiten mit AWS CDK in TypeScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html) 

------
#### [ JavaScript ]

 [Arbeitet mit AWS CDK in JavaScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-javascript.html) 

------
#### [ Python ]

 [Arbeiten mit AWS CDK in Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html) 

------
#### [ Java ]

 [Arbeiten mit AWS CDK in Java](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-java.html) 

------
#### [ C\$1 ]

 [Arbeiten mit AWS CDK in C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html) 

------

Weitere Informationen zu den in diesem Tutorial verwendeten AWS Construct Library-Modulen finden Sie in den folgenden AWS CDK API-Referenzübersichten:
+  [aws-lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html) 
+  [aws-step-Funktionen](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) 

# Verwenden AWS CDK , um einen Express-Workflow in Step Functions zu erstellen
<a name="tutorial-step-functions-rest-api-integration-cdk"></a>

In diesem Tutorial erfahren Sie, wie Sie mithilfe des AWS Cloud Development Kit (AWS CDK) Infrastructure as Code (IAC) -Frameworks eine API-Gateway-REST-API mit einer synchronen Express-State-Machine als Backend-Integration erstellen.

Sie werden das `StepFunctionsRestApi` Konstrukt verwenden, um die State Machine mit dem API Gateway zu verbinden. Das `StepFunctionsRestApi` Konstrukt richtet ein input/output Standardmapping und die API-Gateway-REST-API mit den erforderlichen Berechtigungen und einer HTTP-Methode „ANY“ ein.

 Mit AWS CDK einem Infrastructure as Code (IAC) -Framework definieren Sie die AWS Infrastruktur mithilfe einer Programmiersprache. Sie definieren eine App in einer der vom CDK unterstützten Sprachen, synthetisieren den Code in einer CloudFormation Vorlage und stellen dann die Infrastruktur für Ihr Konto bereit. AWS 

 Sie definieren CloudFormation damit eine API-Gateway-REST-API, die in Synchronous Express State Machine als Backend integriert ist, und verwenden dann die, AWS-Managementkonsole um die Ausführung zu initiieren. 

Bevor Sie mit diesem Tutorial beginnen, richten Sie Ihre AWS CDK Entwicklungsumgebung wie unter [Erste Schritte mit den Voraussetzungen beschrieben ein und installieren Sie dann die AWS CDK](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_prerequisites), AWS CDK indem Sie Folgendes eingeben:

```
npm install -g aws-cdk
```

## Schritt 1: Richten Sie Ihr AWS CDK Projekt ein
<a name="step-functions-rest-api-integration-cdk-step-1"></a>

Erstellen Sie zunächst ein Verzeichnis für Ihre neue AWS CDK App und initialisieren Sie das Projekt.

------
#### [ 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
```

Nachdem das Projekt initialisiert wurde, aktivieren Sie die virtuelle Umgebung des Projekts und installieren Sie die AWS CDK Basisabhängigkeiten.

```
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
```

------

**Anmerkung**  
Achten Sie darauf, dem Verzeichnis `stepfunctions-rest-api` einen Namen zu geben. Die AWS CDK Anwendungsvorlage verwendet den Namen des Verzeichnisses, um Namen für Quelldateien und Klassen zu generieren. Wenn Sie einen anderen Namen verwenden, wird Ihre App nicht mit diesem Lernprogramm übereinstimmen.

Installieren Sie jetzt die Construct-Bibliotheksmodule für AWS Step Functions und 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 ]

Bearbeiten Sie `pom.xml` des Projekts, um die folgenden Abhängigkeiten innerhalb des vorhandenen `<dependencies>`-Container hinzuzufügen.

```
        <dependency>
            <groupId>software.amazon.awscdk</groupId>
            <artifactId>stepfunctions</artifactId>
            <version>${cdk.version}</version>
        </dependency>
        <dependency>
            <groupId>software.amazon.awscdk</groupId>
            <artifactId>apigateway</artifactId>
            <version>${cdk.version}</version>
        </dependency>
```

Maven installiert diese Abhängigkeiten automatisch, wenn Sie Ihre App das nächste Mal erstellen. Um zu erstellen, stellen Sie `mvn compile` aus oder verwenden Sie den **Entwicklung**-Befehl Ihrer Java-IDE.

------
#### [ C\$1 ]

```
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.Stepfunctions
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.APIGateway
```

Sie können die angegebenen Pakete auch mit der Visual NuGet Studio-GUI installieren, die über **Tools** > **NuGet Package Manager > Manage NuGet Packages** **for Solution** verfügbar ist.

------

Sobald Sie die Module installiert haben, können Sie sie in Ihrer AWS CDK App verwenden, indem Sie die folgenden Pakete importieren.

------
#### [ 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 ]

Fügen Sie Folgendes zur `import` Innenseite hinzu`stepfunctions-rest-api.go`.

```
"github.com/aws/aws-cdk-go/awscdk/awsapigateway"
"github.com/aws/aws-cdk-go/awscdk/awsstepfunctions"
```

------

## Schritt 2: Verwenden Sie die AWS CDK , um eine API-Gateway-REST-API mit synchroner Express State Machine-Backend-Integration zu erstellen
<a name="step-functions-rest-api-integration-cdk-step-2"></a>

Zunächst stellen wir die einzelnen Codeteile vor, die die Synchronous Express State Machine und die API Gateway REST API definieren, und erklären dann, wie Sie sie in Ihrer AWS CDK App zusammenfügen. Anschließend erfahren Sie, wie Sie diese Ressourcen synthetisieren und einsetzen können.

**Anmerkung**  
Die State Machine, die wir hier zeigen werden, wird eine einfache State Machine mit einem `Pass` Status sein.

### Um eine Express State Machine zu erstellen
<a name="step-functions-rest-api-integration-cdk-create-state-machine"></a>

Dies ist der AWS CDK Code, der eine einfache Zustandsmaschine mit einem `Pass` Status definiert.

------
#### [ 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,
})
```

------

Sie können in diesem kurzen Snippet sehen:
+ Die angegebene Maschinendefinition`PassState`, bei der es sich um einen `Pass` Status handelt.
+ Der logische Name der State Machine,`MyStateMachine`.
+ Die Definition der Zustandsmaschine wird als State-Machine-Definition verwendet.
+ Der Zustandsmaschinentyp ist auf eingestellt`EXPRESS`, weil er `StepFunctionsRestApi` nur eine synchrone Express-Zustandsmaschine zulässt.

### So erstellen Sie die API-Gateway-REST-API mit `StepFunctionsRestApi` construct
<a name="step-functions-rest-api-integration-cdk-create-rest-api"></a>

Wir werden `StepFunctionsRestApi` Construct verwenden, um die API Gateway REST API mit den erforderlichen Berechtigungen und der input/output Standardzuordnung zu erstellen.

------
#### [ 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,
})
```

------

### Um die AWS CDK App zu erstellen und bereitzustellen
<a name="step-functions-rest-api-integration-cdk-app"></a>

Bearbeiten Sie in dem von Ihnen erstellten AWS CDK Projekt die Datei mit der Definition des Stacks so, dass sie wie im folgenden Code aussieht. Sie werden die Definitionen der Step Functions Functions-Zustandsmaschine und des API Gateway von oben erkennen.

------
#### [ TypeScript ]

Aktualisieren Sie ` lib/stepfunctions-rest-api-stack.ts` damit darauf folgendes steht.

```
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 ]

Aktualisieren Sie `lib/stepfunctions-rest-api-stack.js` damit darauf folgendes steht.

```
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 ]

Aktualisieren Sie `stepfunctions_rest_api/stepfunctions_rest_api_stack.py` damit darauf folgendes steht.

```
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 ]

Aktualisieren Sie `src/main/java/com.myorg/StepfunctionsRestApiStack.java` damit darauf folgendes steht.

```
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 ]

Aktualisieren Sie `src/StepfunctionsRestApi/StepfunctionsRestApiStack.cs` damit darauf folgendes steht.

```
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 ]

Aktualisieren Sie `stepfunctions-rest-api.go` damit darauf folgendes steht.

```
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")),
    // }
}
```

------

Speichern Sie die Quelldatei, und geben Sie `cdk synth` im Hauptverzeichnis der App heraus. Der AWS CDK führt die App aus, synthetisiert daraus eine CloudFormation Vorlage und zeigt dann die Vorlage an.

Um das Amazon API Gateway und die AWS Step Functions State Machine tatsächlich für Ihr AWS-Konto bereitzustellen, geben Sie Folgendes ein`cdk deploy`. Sie werden aufgefordert, die von ihnen generierten IAM-Richtlinien zu genehmigen. AWS CDK 

## Schritt 3: Testen Sie das API Gateway
<a name="step-functions-rest-api-integration-cdk-step-3"></a>

Nachdem Sie Ihre API-Gateway-REST-API mit Synchronous Express State Machine als Backend-Integration erstellt haben, können Sie das API Gateway testen.

### Um das bereitgestellte API Gateway mit der API Gateway-Konsole zu testen
<a name="to-test-the-deployed-api-gateway-using-console"></a>

1. Öffnen Sie die [Amazon API Gateway Gateway-Konsole](https://console.aws.amazon.com/apigateway/) und melden Sie sich an.

1. Wählen Sie Ihre REST-API mit dem Namen`StepFunctionsRestApi`.

1. Wählen Sie im Bereich **Ressourcen** die `ANY` Methode aus.

1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen. 

1. Wählen Sie für **Method (Methode)** die Option **POST** aus.

1. Kopieren **Sie für den Anforderungstext** die folgenden Anforderungsparameter.

   ```
   {
       "key": "Hello"
   }
   ```

1. Wählen Sie **Test** aus. Sie bekommen die folgenden Informationen angezeigt:
   + **Request** ist der Pfad der Ressource, die für die Methode aufgerufen wurde. 
   + **Status** ist der HTTP-Statuscode der Antwort.
   + **Latenz** ist die Zeit, die zwischen dem Empfang der Anforderung des Aufrufers und der zurückgegebenen Antwort vergeht.
   + **Antworttext** ist der Text der HTTP-Antwort.
   + **Antwort-Header** sind die Header der HTTP-Antwort.
   + **Log** zeigt die simulierten Amazon CloudWatch Logs-Einträge, die geschrieben worden wären, wenn diese Methode außerhalb der API Gateway Gateway-Konsole aufgerufen worden wäre.
**Anmerkung**  
Obwohl die CloudWatch Logs-Einträge simuliert sind, sind die Ergebnisse des Methodenaufrufs real.

Die Ausgabe des **Antworttextes** sollte etwa so aussehen:

```
"Hello"
```

**Tipp**  
Testen Sie das API Gateway mit verschiedenen Methoden und einer ungültigen Eingabe, um die Fehlerausgabe zu sehen. Möglicherweise möchten Sie die Zustandsmaschine so ändern, dass sie nach einem bestimmten Schlüssel sucht, und während des Tests den falschen Schlüssel angeben, damit die Ausführung der Zustandsmaschine fehlschlägt und eine Fehlermeldung in der Ausgabe des **Antworttextes** generiert wird.

### So testen Sie die bereitgestellte API mithilfe von cURL
<a name="to-test-the-deployed-api-gateway-using-curl"></a>

1. Öffnen Sie ein Terminal-Fenster.

1. Kopieren Sie den folgenden cURL-Befehl und fügen Sie ihn in das Terminalfenster ein. Ersetzen Sie dabei `<api-id>` mit der API-ID Ihrer API und `<region>` mit der Region, in der Ihre API bereitgestellt ist. 

   ```
   curl -X POST\
    'https://<api-id>.execute-api.<region>.amazonaws.com/prod' \
    -d '{"key":"Hello"}' \
    -H 'Content-Type: application/json'
   ```

Die Ausgabe des **Antworttextes** sollte etwa so aussehen:

```
"Hello"
```

**Tipp**  
Testen Sie das API Gateway mit verschiedenen Methoden und einer ungültigen Eingabe, um die Fehlerausgabe zu sehen. Möglicherweise möchten Sie die Zustandsmaschine so ändern, dass sie nach einem bestimmten Schlüssel sucht, und während des Tests den falschen Schlüssel angeben, damit die Ausführung der Zustandsmaschine fehlschlägt und eine Fehlermeldung in der Ausgabe des **Antworttextes** generiert wird.

## Schritt 4: Bereinigen
<a name="step-functions-rest-api-integration-cdk-step-4"></a>

Wenn Sie mit dem Testen Ihres API-Gateways fertig sind, können Sie mit dem AWS-CDK sowohl die Zustandsmaschine als auch das API Gateway herunterfahren. Geben Sie `cdk destroy` im Hauptverzeichnis Ihrer App heraus.

# Verwendung von Terraform zur Bereitstellung von Zustandsmaschinen in Step Functions
<a name="terraform-sfn"></a>

[Terraform](https://www.terraform.io/intro/) by HashiCorp ist ein Framework für die Erstellung von Anwendungen unter Verwendung von Infrastructure as Code (IaC). Mit Terraform können Sie Zustandsmaschinen erstellen und Funktionen wie die Vorschau von Infrastrukturbereitstellungen und die Erstellung wiederverwendbarer Vorlagen verwenden. Terraform-Vorlagen helfen Ihnen dabei, den Code zu verwalten und wiederzuverwenden, indem sie ihn in kleinere Abschnitte aufteilen.

Wenn Sie mit Terraform vertraut sind, können Sie den in diesem Thema beschriebenen Entwicklungszyklus als Modell für die Erstellung und Bereitstellung Ihrer Zustandsmaschinen in Terraform verfolgen. Wenn Sie mit Terraform nicht vertraut sind, empfehlen wir Ihnen, zunächst den Workshop [Einführung in Terraform zu absolvieren, um sich mit Terraform vertraut zu](https://catalog.workshops.aws/terraform101/en-US) machen. AWS

**Tipp**  
[https://catalog.workshops.aws/stepfunctions/iac/deploy-with-terraform](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-terraform)

**Topics**
+ [Voraussetzungen](#terraform-sfn-prerequisites)
+ [Entwicklungslebenszyklus mit Terraform](#terraform-sfn-dev-lifecycle)
+ [IAM-Rollen und -Richtlinien für Ihren State Machine](#terraform-sfn-iam-policy)

## Voraussetzungen
<a name="terraform-sfn-prerequisites"></a>

Bevor Sie beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen:
+ Installieren Sie Terraform auf Ihrem Computer. [Informationen zur Installation von Terraform finden Sie unter Terraform installieren.](https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)
+ Installieren Sie Step Functions Local auf Ihrem Computer. Wir empfehlen, das Docker-Image Step Functions Local zu installieren, um Step Functions Local zu verwenden. Weitere Informationen finden Sie unter [Testen von Zustandsmaschinen mit Step Functions Local (nicht unterstützt)](sfn-local.md).
+ Installieren Sie AWS SAM CLI. Informationen zur Installation finden Sie unter [Installation der AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/install-sam-cli.html) im *AWS Serverless Application Model Entwicklerhandbuch*.
+ Installieren Sie den AWS Toolkit for Visual Studio Code , um das Workflow-Diagramm Ihrer Zustandsmaschinen anzuzeigen. Informationen zur Installation finden Sie [unter Installation von AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/setup-toolkit.html) im *AWS Toolkit for Visual Studio Code Benutzerhandbuch*.

## Analysieren Sie den Lebenszyklus der Maschinenentwicklung mit Terraform
<a name="terraform-sfn-dev-lifecycle"></a>

Das folgende Verfahren erklärt, wie Sie einen State-Machine-Prototyp, den Sie mit [Workflow Studio](workflow-studio.md) in der Step Functions Functions-Konsole erstellen, als Ausgangspunkt für die lokale Entwicklung mit Terraform und dem verwenden können. [AWS Toolkit for Visual Studio Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/welcome.html)

Das vollständige Beispiel, in dem die Zustandsmaschine-Entwicklung mit Terraform erörtert und die Best Practices im Detail vorgestellt werden, finden Sie unter Bewährte Methoden [für das Schreiben von Step Functions Terraform-Projekten](https://aws.amazon.com/blogs/devops/best-practices-for-writing-step-functions-terraform-projects/).

**Um den Entwicklungszyklus einer State Machine mit Terraform zu beginnen**

1. Starten Sie ein neues Terraform-Projekt mit dem folgenden Befehl.

   ```
   terraform init
   ```

1. Öffnen Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/), um einen Prototyp für Ihre State Machine zu erstellen.

1. Gehen Sie in Workflow Studio wie folgt vor:

   1. Erstellen Sie Ihren Workflow-Prototyp.

   1. Exportieren Sie die [Amazon States Language (ASL)](concepts-amazon-states-language.md) -Definition Ihres Workflows. **Wählen Sie dazu die Dropdownliste **Import/Export** und dann JSON-Definition exportieren aus.**

1. Speichern Sie die exportierte ASL-Definition in Ihrem Projektverzeichnis.

   Sie übergeben die exportierte ASL-Definition als Eingabeparameter an die [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-Ressource, die die Funktion verwendet. [https://developer.hashicorp.com/terraform/language/functions/templatefile](https://developer.hashicorp.com/terraform/language/functions/templatefile) Diese Funktion wird innerhalb des Definitionsfeldes verwendet, das die exportierte ASL-Definition und alle Variablenersetzungen weitergibt.
**Tipp**  
Da die ASL-Definitionsdatei lange Textblöcke enthalten kann, empfehlen wir, die Inline-EOF-Methode zu vermeiden. Dadurch ist es einfacher, Parameter in Ihre Zustandsmaschinen-Definition einzufügen.

1. (Optional) Aktualisieren Sie die ASL-Definition in Ihrer IDE und visualisieren Sie Ihre Änderungen mithilfe von. AWS Toolkit for Visual Studio Code  
![\[Screenshot der ASL-Definition eines Workflows in Visual Studio Code und seiner visuellen Darstellung.\]](http://docs.aws.amazon.com/de_de/step-functions/latest/dg/images/visualize-sm-terraform-iac.png)

   [Um zu vermeiden, dass Sie Ihre Definition ständig exportieren und in Ihr Projekt umgestalten, empfehlen wir Ihnen, Aktualisierungen lokal in Ihrer IDE vorzunehmen und diese Aktualisierungen mit Git zu verfolgen.](https://git-scm.com/) 

1. Testen Sie Ihren Workflow mit [Step Functions Local](sfn-local.md).
**Tipp**  
Mithilfe von [AWS SAM CLI](sfn-local-lambda.md) Local können Sie Serviceintegrationen mit Lambda-Funktionen und API Gateway auch lokal APIs in Ihrer Zustandsmaschine testen.

1. Zeigen Sie eine Vorschau Ihrer Zustandsmaschine und anderer AWS Ressourcen an, bevor Sie die Zustandsmaschine bereitstellen. Führen Sie dazu den folgenden Befehl aus.

   ```
   terraform plan
   ```

1. Stellen Sie Ihre Zustandsmaschine mithilfe des folgenden Befehls von Ihrer lokalen Umgebung oder über [CI/CD-Pipelines](https://aws.amazon.com/blogs/developer/build-infrastructure-ci-for-terraform-code-leveraging-aws-developer-tools-and-terratest/) aus bereit.

   ```
   terraform apply
   ```

1. (Optional) Bereinigen Sie Ihre Ressourcen und löschen Sie die Zustandsmaschine mit dem folgenden Befehl.

   ```
   terraform destroy
   ```

## IAM-Rollen und -Richtlinien für Ihren State Machine
<a name="terraform-sfn-iam-policy"></a>

Verwenden Sie die [Terraform-Dienstintegrationsrichtlinien](https://registry.terraform.io/modules/terraform-aws-modules/step-functions/aws/latest#service-integration-policies), um Ihrer Zustandsmaschine die erforderlichen IAM-Berechtigungen hinzuzufügen, z. B. die Berechtigung zum Aufrufen von Lambda-Funktionen. Sie können auch explizite Rollen und Richtlinien definieren und diese Ihrer Zustandsmaschine zuordnen.

Das folgende Beispiel für eine IAM-Richtlinie gewährt Ihrer Zustandsmaschine Zugriff, um eine Lambda-Funktion mit dem Namen aufzurufen. `myFunction`

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "lambda:InvokeFunction"
      ],
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:myFunction"
    }
  ]
}
```

Wir empfehlen außerdem, die [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)Datenquelle bei der Definition von IAM-Richtlinien für Ihre Zustandsmaschinen in Terraform zu verwenden. Auf diese Weise können Sie überprüfen, ob Ihre Richtlinie falsch formatiert ist, und alle Ressourcen durch Variablen ersetzen.

Das folgende Beispiel für eine IAM-Richtlinie verwendet die `aws_iam_policy_document` Datenquelle und gewährt Ihrer Zustandsmaschine Zugriff, um eine Lambda-Funktion mit dem Namen aufzurufen. `myFunction`

```
data "aws_iam_policy_document" "state_machine_role_policy" {
  
  statement {
    effect = "Allow"

    actions = [
      "lambda:InvokeFunction"
    ]

    resources = ["${aws_lambda_function.function-1.arn}:*"]
  }
  
}
```

**Tipp**  
Weitere erweiterte AWS Architekturmuster, die mit Terraform bereitgestellt wurden, finden Sie unter Terraform-Beispiele unter [Serverless Land Workflows Collection](https://serverlessland.com/workflows?framework=Terraform).

# Exportieren Sie Ihren Workflow in IaC-Vorlagen
<a name="exporting-iac-templates"></a>

Die AWS Step Functions Konsole bietet die Möglichkeit, gespeicherte Workflows als AWS CloudFormation oder AWS SAM (SAM) -Vorlagen zu exportieren und herunterzuladen. Für AWS-Regionen diese Unterstützung bietet sie zusätzlich die Möglichkeit AWS Infrastructure Composer, Ihre Workflows nach Infrastructure Composer zu exportieren und zur Infrastructure Composer-Konsole zu navigieren, wo Sie mit der neu generierten Vorlage weiterarbeiten können.

## Optionen für die Konfiguration von Vorlagen
<a name="exporting-iac-templates-config-options"></a>

Die folgenden Optionen sind mit dieser Funktion verfügbar. Wenn Sie sich dafür entscheiden, eine IaC-Vorlagendatei zu exportieren und herunterzuladen, zeigt die Konsole die Optionen, die für Ihren gespeicherten Zustandsmaschine gelten, zur Auswahl an. Wenn Sie nach Infrastructure Composer exportieren, implementiert die Step Functions Functions-Konsole automatisch die Konfigurationen, die für Ihren State Machine gelten.
+  **Fügen Sie die von der Konsole in Ihrem Namen erstellte IAM-Rolle** hinzu — Mit dieser Option werden die Richtlinien für die Ausführungsrollen exportiert. Sie erstellt eine IAM-Rolle in der Vorlage und fügt sie der State-Machine-Ressource hinzu. Diese Option ist nur anwendbar, wenn die Zustandsmaschine über eine Ausführungsrolle verfügt, die von der Konsole erstellt wird.
+  ** CloudWatch Protokollgruppe einbeziehen** — Konstruiert eine CloudWatch Protokollgruppe in der Vorlage und hängt sie an die Zustandsmaschinen-Ressource an. Diese Option ist nur anwendbar, wenn an die Zustandsmaschine eine CloudWatch Protokollgruppe angehängt ist und die [Protokollebene](cw-logs.md#cloudwatch-log-level) *nicht* auf eingestellt ist. `OFF` 
+  **Ressourcenverweise ersetzen durch DefinitionSubstitutions** — Diese Option generiert [DefinitionSubstitutions](concepts-sam-sfn.md#sam-definition-substitution-eg)für die folgenden Komponenten: 
  + [Distributed Map](state-map-distributed.md) S3-Felder.
  + `Activity`Ressourcen. Der Export beinhaltet `Activity` Ressourcen in der CloudFormation Vorlage für jede `Run Activity` Aufgabe. Der Export ermöglicht auch die `DefinitionSubstitutions` Referenzierung der erstellten `Activity` Ressourcen.
  + Beliebig `ARN` oder `S3URI` im Feld Payload für alle Serviceintegrationen.
  + Zusätzlich zu den `S3URI` Feldern `ARN` und generiert der Export Nutzdatenfelder `DefinitionSubstitutions` für andere häufig verwendete Serviceintegrations-Payload-Felder. Die spezifischen Serviceintegrationen sind die folgenden: 
    + `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`

## Exportieren Sie die IaC-Vorlage Ihres Workflows und laden Sie sie herunter
<a name="exporting-iac-templates-files-procedure"></a>

**Um Ihren Workflow in eine IaC-Vorlagendatei zu exportieren**

1. Öffnen Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/) und wählen Sie die Zustandsmaschine aus, mit der Sie arbeiten möchten. Stellen Sie sicher, dass alle Änderungen an der Zustandsmaschine gespeichert sind, bevor Sie mit dem nächsten Schritt fortfahren.

1. Wählen Sie im Menü **Aktionen** die Option **Exportieren nach CloudFormation oder SAM-Vorlage** aus.

1. Wählen Sie im daraufhin angezeigten Dialogfeld entweder „**Typ**“ als „**SAM**“ oder „Typ“ **CloudFormation**aus.
   + Wenn Sie die **CloudFormation**Vorlage ausgewählt haben, wählen Sie als Nächstes entweder das **JSON** - oder das **YAML-Dateiformat**.
   + Wenn Sie die **SAM-Vorlage** ausgewählt haben, werden keine Formatoptionen angezeigt. Die SAM-Vorlage verwendet standardmäßig das YAML-Dateiformat.

1. Erweitern Sie **Zusätzliche Konfigurationen**. Standardmäßig sind alle Optionen ausgewählt. Überprüfen und aktualisieren Sie die Auswahl der Optionen für Ihre IaC-Vorlage. Die Optionen werden im vorherigen Abschnitt mit dem Titel [Optionen für die Konfiguration von Vorlagen](#exporting-iac-templates-config-options) ausführlich beschrieben. 

   Wenn eine Option nicht für Ihren spezifischen Workflow gilt, wird sie nicht im Dialogfeld angezeigt.

1. Wählen Sie **Herunterladen**, um Ihre generierte IaC-Vorlagendatei zu exportieren und herunterzuladen.

## Exportieren Sie Ihren Workflow direkt in AWS Infrastructure Composer
<a name="exporting-iac-templates-infra-composer-procedure"></a>

**Um Ihren Workflow zu exportieren in Infrastructure Composer**

1. Öffnen Sie die [Step Functions Functions-Konsole](https://console.aws.amazon.com/states/home?region=us-east-1#/) und wählen Sie die Zustandsmaschine aus, mit der Sie arbeiten möchten. Stellen Sie sicher, dass alle Änderungen an der Zustandsmaschine gespeichert sind, bevor Sie mit dem nächsten Schritt fortfahren.

1. Wählen Sie im Menü **Aktionen** **die Option Nach Infrastructure Composer exportieren** aus.

1. Das Dialogfeld **Nach Infrastructure Composer exportieren** wird angezeigt. Sie können den Standardnamen verwenden, der im Feld **Name des Transfer-Buckets** angezeigt wird, oder einen neuen Namen eingeben. Die Amazon-S3-Bucket-Namen müssen global eindeutig sein und den [Regeln für die Benennung von Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html) entsprechen.

1. Wählen Sie das **Projekt Bestätigen und erstellen** aus, um Ihren Workflow nach Infrastructure Composer zu exportieren.

1. Um Ihr Projekt und Ihre Workflow-Definition in Infrastructure Composer zu speichern, aktivieren Sie den [lokalen Synchronisierungsmodus](https://docs.aws.amazon.com/application-composer/latest/dg/reference-features-local-sync.html).

**Anmerkung**  
Wenn Sie die Funktion Nach **Infrastructure Composer exportieren** bereits verwendet und einen Amazon S3 S3-Bucket mit dem Standardnamen erstellt haben, kann Step Functions diesen Bucket wiederverwenden, falls er noch existiert. Akzeptieren Sie den Standard-Bucket-Namen im Dialogfeld, um den vorhandenen Bucket wiederzuverwenden.

### Konfiguration des Amazon-S3-Transfer-Buckets
<a name="export-appcomposer-bucket-info"></a>

Der Amazon S3 S3-Bucket, den Step Functions für die Übertragung Ihres Workflows erstellt, verschlüsselt Objekte automatisch mit dem Verschlüsselungsstandard AES 256. Step Functions konfiguriert den Bucket auch so, dass er die [Bucket-Besitzer-Bedingung](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-owner-condition.html) verwendet, um sicherzustellen, dass nur Sie AWS-Konto Objekte zum Bucket hinzufügen können.

Der Standard-Bucket-Name verwendet das Präfix`states-templates`, eine 10-stellige alphanumerische Zeichenfolge und das, in dem AWS-Region Sie Ihren Workflow erstellt haben:. `states-templates-amzn-s3-demo-bucket-us-east-1` Um zusätzliche Gebühren zu vermeiden, empfehlen wir Ihnen AWS-Konto, den Amazon S3 S3-Bucket zu löschen, sobald Sie den Export Ihres Workflows nach Infrastructure Composer abgeschlossen haben.

Es gelten die [Standardpreise von Amazon S3](https://aws.amazon.com/s3/pricing/).

### Erforderliche Berechtigungen
<a name="export-appcomposer-permissions"></a>

Um diese Step Functions Functions-Exportfunktion mit Infrastructure Composer verwenden zu können, benötigen Sie bestimmte Berechtigungen, um eine AWS SAM Vorlage herunterzuladen und Ihre Vorlagenkonfiguration in Amazon S3 zu schreiben.

Um eine AWS SAM Vorlage herunterzuladen, benötigen Sie die Erlaubnis, die folgenden API-Aktionen zu verwenden:
+ [Ich bin: GetPolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicy.html)
+ [ich bin: GetPolicyVersion](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetPolicyVersion.html)
+ [ich bin: GetRole](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRole.html)
+ [ich bin: GetRolePolicy](https://docs.aws.amazon.com/IAM/latest/APIReference/API_GetRolePolicy.html)
+ [ich bin: ListAttachedRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListAttachedRolePolicies.html)
+ [ich bin: ListRolePolicies](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRolePolicies.html)
+ [ich bin: ListRoles](https://docs.aws.amazon.com/IAM/latest/APIReference/API_ListRoles.html)

Damit Step Functions die Konfiguration Ihrer Funktion in Amazon S3 schreiben kann, benötigen Sie die Erlaubnis, die folgenden API-Aktionen zu verwenden:
+ [S3: PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)
+ [S 3: CreateBucket](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html)
+ [S 3: PutBucketEncryption](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html)

Wenn Sie die Konfiguration Ihrer Funktion nicht nach Infrastructure Composer exportieren können, überprüfen Sie, ob Ihr Konto über die erforderlichen Berechtigungen für diese Operationen verfügt. 