Schritt 1: Richten Sie Ihre ein AWS CDK Projekt Schritt 2: Verwenden Sie den AWS CDK um ein API Gateway REST API mit synchroner Express State Machine-Backend-Integration zu erstellen Schritt 3: Testen Sie das API Gateway Schritt 4: Bereinigen

Die Verwendung von AWS CDK um einen Express-Workflow in Step Functions zu erstellen

In diesem Tutorial erfahren Sie, wie Sie ein API Gateway REST API mit einer synchronen Express-State-Machine als Backend-Integration erstellen. Verwenden Sie dazu den AWS Cloud Development Kit (AWS CDK) Framework für Infrastruktur als Code (IAC).

Sie werden das StepFunctionsRestApi Konstrukt verwenden, um die State Machine mit dem API Gateway zu verbinden. Das StepFunctionsRestApi Konstrukt richtet ein standardmäßiges Eingabe-/Ausgabe-Mapping und das API Gateway REST API mit den erforderlichen Berechtigungen und einer HTTP „ANY“ -Methode ein.

Mit AWS CDK ist ein Infrastructure as Code (IAC) -Framework, das Sie definieren AWS Infrastruktur, die eine Programmiersprache verwendet. Sie definieren eine App in einer CDK der unterstützten Sprachen und synthetisieren den Code zu einer AWS CloudFormation Vorlage und stellen dann die Infrastruktur auf Ihrem bereit AWS Konto.

Sie werden verwenden AWS CloudFormation um ein API Gateway zu definieren RESTAPI, das in die Synchronous Express State Machine als Backend integriert ist, verwenden Sie dann AWS Management Console um die Ausführung zu initiieren.

Bevor Sie mit diesem Tutorial beginnen, richten Sie Ihr AWS CDK Entwicklungsumgebung, wie unter Erste Schritte mit dem beschrieben AWS CDK - Voraussetzungen, dann installieren Sie AWS CDK durch Ausgabe von:


npm install -g aws-cdk

Schritt 1: Richten Sie Ihre ein AWS CDK Projekt

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

Anmerkung

Achten Sie darauf, das Verzeichnis zu benennenstepfunctions-rest-api. 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.

Installieren Sie jetzt die Module der Construct-Bibliothek für AWS Step Functions und Amazon API Gateway.

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

Schritt 2: Verwenden Sie den AWS CDK um ein API Gateway REST API mit synchroner Express State Machine-Backend-Integration zu erstellen

Zuerst stellen wir die einzelnen Codeteile vor, die die Synchronous Express State Machine und das API Gateway definieren, und erklären dann RESTAPI, wie Sie sie zu Ihrem zusammenfügen AWS CDK App. Dann 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

Das ist der AWS CDK Code, der eine einfache Zustandsmaschine mit einem Pass Zustand 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#


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 MaschinendefinitionPassState, 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 eingestelltEXPRESS, weil er StepFunctionsRestApi nur eine synchrone Express-Zustandsmaschine zulässt.

Um das API Gateway REST API mithilfe `StepFunctionsRestApi` von Construct zu erstellen

Wir werden StepFunctionsRestApi Construct verwenden, um das API Gateway REST API mit den erforderlichen Berechtigungen und der standardmäßigen Eingabe-/Ausgabezuordnung zu erstellen.

Um das zu erstellen und bereitzustellen AWS CDK App

Im AWS CDK Bearbeiten Sie das von Ihnen erstellte 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 Gateways 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#

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("123456789012"),
    //  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. Das Tool AWS CDK führt die App aus und synthetisiert eine AWS CloudFormation Vorlage daraus und zeigt dann die Vorlage an.

Um das Amazon API Gateway und das AWS Step Functions Zustandsmaschine zu Ihrem AWS Konto, Problemcdk deploy. Sie werden gebeten, die IAM Richtlinien zu genehmigen AWS CDK hat generiert.

Schritt 3: Testen Sie das API Gateway

Nachdem Sie Ihr 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 Gateway-Konsole zu API testen

Öffnen Sie die Amazon API Gateway-Konsole und melden Sie sich an.
Wählen Sie Ihren REST API NamenStepFunctionsRestApi.
Wählen Sie im Bereich Ressourcen die ANY Methode aus.
Wählen Sie die Registerkarte Test. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
Wählen Sie für Methode POST aus.
Kopieren Sie für den Anforderungstext die folgenden Anforderungsparameter.
```
{
    "key": "Hello"
}
```
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 HTTP Antworttext.
- Antwort-Header sind die HTTP Antwort-Header.
- Log zeigt die simulierten Amazon CloudWatch Logs-Einträge, die geschrieben worden wären, wenn diese Methode außerhalb der API 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.

Um das Bereitgestellte API mit c zu testen URL

Öffnen Sie ein Terminal-Fenster.
Kopieren Sie den folgenden URL c-Befehl und fügen Sie ihn in das Terminalfenster ein. <api-id> Ersetzen Sie ihn durch Ihre API API ID und <region> die Region, in der Ihr installiert API 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

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

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

Wird verwendetCDK, um einen Standard-Workflow zu erstellen

Verwendung von Terraform zur Bereitstellung von Workflows

Die Verwendung von AWS CDK um einen Express-Workflow in Step Functions zu erstellen

Schritt 1: Richten Sie Ihre ein AWS CDK Projekt

Anmerkung

Schritt 2: Verwenden Sie den AWS CDK um ein API Gateway REST API mit synchroner Express State Machine-Backend-Integration zu erstellen

Anmerkung

Um eine Express State Machine zu erstellen

Um das API Gateway REST API mithilfe StepFunctionsRestApi von Construct zu erstellen

Um das zu erstellen und bereitzustellen AWS CDK App

Schritt 3: Testen Sie das API Gateway

Um das bereitgestellte API Gateway mit der Gateway-Konsole zu API testen

Anmerkung

Tipp

Um das Bereitgestellte API mit c zu testen URL

Tipp

Schritt 4: Bereinigen

Um das API Gateway REST API mithilfe `StepFunctionsRestApi` von Construct zu erstellen