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

Fokusmodus

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

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

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.

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 standardmäßiges Eingabe-/Ausgabe-Mapping 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 AWS CloudFormation Vorlage und stellen dann die Infrastruktur für Ihr Konto bereit. AWS

Sie definieren AWS CloudFormation damit eine API-Gateway-REST-API, die in Synchronous Express State Machine als Backend integriert ist, und verwenden dann die, AWS Management Console 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, AWS CDK indem Sie Folgendes eingeben:


npm install -g aws-cdk

Schritt 1: Richten Sie Ihr AWS CDK Projekt ein

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

anchor anchor anchor anchor anchor anchor


mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language typescript

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.

anchor anchor anchor anchor anchor


npm install @aws-cdk/aws-stepfunctions @aws-cdk/aws-apigateway

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

anchor anchor anchor anchor anchor anchor


@aws-cdk/aws-stepfunctions
@aws-cdk/aws-apigateway

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

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

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#


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,
})

anchor anchor anchor anchor anchor anchor


const machineDefinition = new stepfunctions.Pass(this, 'PassState', {
    result: {value:"Hello!"},
})

const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {
    definition: machineDefinition,
    stateMachineType: stepfunctions.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.

So erstellen Sie die API-Gateway-REST-API mit `StepFunctionsRestApi` construct

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

anchor anchor anchor anchor anchor anchor


const api = new apigateway.StepFunctionsRestApi(this, 
  'StepFunctionsRestApi', { stateMachine: stateMachine });

Um die App zu erstellen und bereitzustellen AWS CDK

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#

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

anchor anchor anchor anchor anchor anchor

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

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 AWS 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 eincdk deploy. Sie werden aufgefordert, die von ihnen generierten IAM-Richtlinien zu genehmigen. AWS CDK

Schritt 3: Testen Sie das API Gateway

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

Öffnen Sie die Amazon API Gateway Gateway-Konsole und melden Sie sich an.
Wählen Sie Ihre REST-API mit dem 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 Method (Methode) die Option 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 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

Öffnen Sie ein Terminal-Fenster.
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

Schritt 4: Bereinigen

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.

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

Verwenden von CDK zum Erstellen eines Standard-Workflows

Verwendung von Terraform zur Bereitstellung von Workflows

Auf dieser Seite

Wählen Sie Ihre Cookie-Einstellungen aus

Cookie-Einstellungen anpassen

Essenziell

Leistung

Funktional

Werbung

Cookie-Einstellungen konnten nicht gespeichert werden

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

Schritt 1: Richten Sie Ihr AWS CDK Projekt ein

Anmerkung

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

Anmerkung

Um eine Express State Machine zu erstellen

So erstellen Sie die API-Gateway-REST-API mit `StepFunctionsRestApi` construct

Um die App zu erstellen und bereitzustellen AWS CDK

Schritt 3: Testen Sie das API Gateway

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

Anmerkung

Tipp

So testen Sie die bereitgestellte API mithilfe von cURL

Tipp

Schritt 4: Bereinigen

Auf dieser Seite

Hat Ihnen diese Seite geholfen?

Nächstes Thema:

Vorheriges Thema:

Brauchen Sie Hilfe?

Wählen Sie Ihre Cookie-Einstellungen aus

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

Schritt 1: Richten Sie Ihr AWS CDK Projekt ein

Anmerkung

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

Anmerkung

Um eine Express State Machine zu erstellen

So erstellen Sie die API-Gateway-REST-API mit StepFunctionsRestApi construct

Um die App zu erstellen und bereitzustellen AWS CDK

Schritt 3: Testen Sie das API Gateway

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

Anmerkung

Tipp

So testen Sie die bereitgestellte API mithilfe von cURL

Tipp

Schritt 4: Bereinigen

Auf dieser Seite

Hat Ihnen diese Seite geholfen?

Nächstes Thema:

Vorheriges Thema:

Brauchen Sie Hilfe?

So erstellen Sie die API-Gateway-REST-API mit `StepFunctionsRestApi` construct