Schritt 1: Richten Sie Ihre ein AWS CDK project Schritt 2: Verwenden AWS CDK um eine Zustandsmaschine zu erstellen Schritt 3: Starten Sie die Ausführung einer Zustandsmaschine Schritt 4: Bereinigen Nächste Schritte

Die Verwendung von 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, um ein AWS Step Functions Zustandsmaschine, die eine enthält AWS Lambda Funktion.

Sie werden definieren AWS Infrastruktur, die eine der folgenden verwendet CDKdie unterstützten Sprachen. Nachdem Sie Ihre Infrastruktur definiert haben, synthetisieren Sie Ihre App zu einem AWS CloudFormation Vorlage und Bereitstellung auf Ihrem AWS Konto.

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

Bevor Sie mit diesem Tutorial beginnen, müssen Sie Ihr AWS CDK Entwicklungsumgebung, wie unter Erste Schritte mit dem beschrieben AWS CDK - Voraussetzungen in der AWS Cloud Development Kit (AWS CDK) Leitfaden für Entwickler. Installieren Sie dann das AWS CDK mit dem folgenden Befehl an der AWS CLI:


npm install -g aws-cdk

Dieses Tutorial liefert das gleiche Ergebnis wieDie Verwendung von AWS CloudFormation um einen Workflow in Step Functions zu erstellen. In diesem Tutorial ist jedoch AWS CDK erfordert nicht, dass Sie welche erstellen IAM Rollen; die AWS CDK macht es für dich. Das Tool AWS CDK Version enthält auch einen Workflow-Status „Erfolgreich“ Schritt, der veranschaulicht, wie Sie Ihrem State Machine zusätzliche Schritte hinzufügen können.

Tipp

Um eine serverlose Beispielanwendung bereitzustellen, die eine startet Step Functions Arbeitsablauf unter Verwendung AWS CDK mit TypeScript zu deinem AWS-Konto, siehe Modul 10 — Bereitstellen mit AWS CDKvon Der AWS Step Functions Werkstatt.

Schritt 1: Richten Sie Ihre ein AWS CDK project

Führen Sie in Ihrem Home-Verzeichnis oder einem anderen Verzeichnis, wenn Sie es vorziehen, den folgenden Befehl aus, um ein Verzeichnis für Ihr neues zu erstellen AWS CDK App.

Wichtig
Achten Sie darauf, das Verzeichnis zu benennenstep. Das Tool AWS CDK Die 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 installiert haben. NETVersion 6.0 oder höher. 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 AWS CDKdie grundlegenden Abhä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 AWS CDK um eine Zustandsmaschine zu erstellen

Zuerst präsentieren wir die einzelnen Codeteile, die das definieren Lambda Funktion und die Step Functions Zustandsmaschine. Dann erklären wir Ihnen, wie Sie sie in Ihrem zusammenstellen AWS CDK App. Schließlich erfahren Sie, wie Sie diese Ressourcen synthetisieren und einsetzen können.

Um eine zu erstellen Lambda function

Folgendes AWS CDK Code definiert die Lambda Funktion, die ihren Quellcode inline bereitstellt.

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 von 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: a Lambda Funktion, Aufgabe und Workflow-Status „Erfolgreich“ Zustand. Die Funktion erfordert, dass wir eine erstellen Step Functions Workflow-Status der Aufgabedas ruft unsere Funktion auf. 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 das zu erstellen und bereitzustellen AWS CDK App

In Ihrem neu erstellten AWS CDK Bearbeiten Sie die Datei, die die Definition des Stacks enthält, sodass sie wie der folgende Beispielcode aussieht. Sie werden die Definitionen von erkennen Lambda Funktion und die Step Functions Zustandsmaschine aus früheren 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 CDK führt die App aus und synthetisiert eine AWS CloudFormation Vorlage daraus. AWS CDK zeigt dann die Vorlage an.
Anmerkung
Wenn Sie früher TypeScript Ihre erstellt haben AWS CDK Wenn Sie das cdk synth Projekt ausführen, wird möglicherweise der folgende Fehler zurückgegeben.
```
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 auf Ihrem AWS Konto, Problemcdk deploy. Sie werden gebeten, die IAM Richtlinien zu genehmigen AWS CDK hat generiert.

Schritt 3: Starten Sie die Ausführung einer Zustandsmaschine

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, die Sie mit AWS 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.

ASCIINichtnamen und Protokollierung
Step Functions akzeptiert Namen für Zustandsmaschinen, Ausführungen, Aktivitäten und Bezeichnungen, die ASCII Nichtzeichen enthalten. Da solche Zeichen nicht mit Amazon 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 und dann die einzelnen Registerkarten im Einzelheiten zu den Schritten 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.

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. Führen Sie den cdk destroy Befehl im Hauptverzeichnis Ihrer App aus, um Ihren State Machine zu entfernen.

Nächste Schritte

Um mehr über die Entwicklung zu erfahren AWS Infrastruktur unter Verwendung AWS CDK, siehe AWS CDK Leitfaden für Entwickler.

Für Informationen zum Schreiben AWS CDK Apps in der Sprache Ihrer Wahl finden Sie unter:

Für weitere Informationen über AWS Construct Library-Module, die in diesem Tutorial verwendet werden, finden Sie im Folgenden AWS CDK APIReferenzü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

Wird verwendetCDK, um einen Express-Workflow zu erstellen