Schritt 1: Einrichten des Projekts AWS CDK Schritt 2: Verwenden Sie diese OptionAWS CDK, um eine Zustandsmaschine zu erstellen Schritt 3: Starten Sie eine State-Machine-Ausführung Schritt 4: Bereinigen Nächste Schritte

Verwenden AWS CDK , um einen Standard-Workflow in Step Functions zu erstellen

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 AWS 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 Management Console aus.

Bevor Sie mit diesem Tutorial beginnen, müssen Sie Ihre AWS CDK Entwicklungsumgebung wie unter Erste Schritte mit den AWS CDK — Voraussetzungen 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 wieVerwenden AWS CloudFormation , um einen Workflow in Step Functions zu erstellen. 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“ 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 im AWS Step Functions Workshop.

Schritt 1: Einrichten des Projekts AWS CDK

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 gebenstep. 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#
Stellen Sie sicher, dass Sie.NET Version 6.0 oder höher installiert haben. Weitere Informationen finden Sie unter Unterstützte Versionen.
```
mkdir step && cd step
```
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#
```
cdk init --language csharp
```

Schritt 2: Verwenden Sie diese OptionAWS CDK, um eine Zustandsmaschine zu erstellen

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

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#


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

Unsere Zustandsmaschine hat zwei Zustände: eine Lambda Funktionsaufgabe und einen Workflow-Status „Erfolgreich“ Status. Die Funktion erfordert, dass wir eine erstellen Step FunctionsWorkflow-Status der Aufgabe, 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() MethodeMyLambdaTask, um einen Erfolgsstatus mit dem Namen GreetedWorld zu definieren.

Um die App zu erstellen und bereitzustellen AWS CDK

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.

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#

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

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 AWS 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();
```
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

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

Starten der Ausführung des Zustandsautomaten

Öffnen Sie die Step Functions Functions-Konsole und wählen Sie den Namen der Zustandsmaschine aus, mit der Sie erstellt habenAWS CDK.
Wählen Sie auf der State-Machine-Seite die Option Ausführung starten aus.

Das Dialogfeld Ausführung starten wird angezeigt.
(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 mit Amazon nicht funktionieren, empfehlen wir CloudWatch, nur ASCII-Zeichen zu verwenden, damit Sie die Messwerte verfolgen können. CloudWatch
Wählen Sie Start Execution aus.

Die Ausführung Ihrer Zustandsmaschine wird gestartet und eine neue Seite mit Ihrer laufenden Ausführung wird angezeigt.
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 oder nach Abschluss der Ausführung ü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 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.

Schritt 4: Bereinigen

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

Weitere Informationen zur Entwicklung von AWS Infrastrukturen mithilfe von Cookies AWS CDK finden Sie im AWS CDKEntwicklerhandbuch.

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

Weitere Informationen zu den in diesem Tutorial verwendeten AWS Construct Library-Modulen finden Sie in den folgenden AWS CDK API-Referenzübersichten:

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Erstellen Sie eine Zustandsmaschine mit CloudFormation

Verwenden von CDK zum Erstellen eines Express-Workflows