Erstellen einer API-Gateway-REST-API mit synchronem Express-Zustandsautomaten mithilfe der DateiAWS CDK - AWS Step Functions

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.

Erstellen einer API-Gateway-REST-API mit synchronem Express-Zustandsautomaten mithilfe der DateiAWS CDK

In diesem Tutorial erfahren Sie, wie Sie eine API-Gateway-REST-API mit Synchronous Express Status Machine als Backend-Integration erstellen, indem Sie die DateiAWS Cloud Development Kit (AWS CDK). Dieses Tutorial verwendet dieStepFunctionsRestApiKonstrukt, um die State Machine mit dem API Gateway zu verbinden. DieStepFunctionsRestApiconstruct richtet eine Standard-Eingabe-/Ausgabezuordnung und die API-Gateway-REST-API mit den erforderlichen Berechtigungen und einer HTTP „ANY“ -Methode ein. AWS CDK ist ein Infrastructure as Code (IAC)-Framework, mit dem Sie AWS-Infrastruktur mit einer vollwertigen Programmiersprache definieren können. Sie schreiben eine App in einer unterstützten Sprachen des CDK, die einen oder mehrere Stacks enthält, und synthetisieren sie dann in einer -DateiAWS CloudFormationVorlage und stellen Sie es auf IhremAWSKonto. Wir verwenden es, um eine API-Gateway-REST-API zu definieren, die in Synchronous Express State Machine als Backend integriert ist, und verwenden dannAWS Management Consoleum die Ausführung zu starten.

Bevor Sie mit diesem Tutorial beginnen, richten Sie Ihre AWS CDK-Entwicklungsumgebung ein wie in Erste Schritte mit den AWS CDK-Voraussetzungen beschrieben und installieren Sie dann AWS CDK durch Ausstellen von:

npm install -g aws-cdk

Schritt 1: Einrichten IhresAWS CDKProjekt

Erstellen Sie zunächst ein Verzeichnis für Ihr neuesAWS CDKund 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 Baseline-Abhängigkeiten von AWS CDK.

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

Vergewissern Sie sich, das Verzeichnis zu benennenstepfunctions-rest-api. DieAWS CDKapplication template 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 nun die Module der Konstruktionsbibliothek fürAWS Step Functionsund 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#
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 Visual Studio installieren NuGetGUI, verfügbar über-Tools>NuGet Package Manager>Verwalten NuGet Pakete zur Lösung.

Sobald Sie die Module installiert haben, können Sie sie in IhremAWS CDKApp, 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#
Amazon.CDK.AWS.StepFunctions Amazon.CDK.AWS.APIGateway
Go

Fügen Sie Folgendes zuimportinnenstepfunctions-rest-api.go.

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

Schritt 2: Verwenden derAWS CDKSo erstellen Sie eine API-Gateway-REST-API mit Synchronous Express Status Machine-Backend-Integration

Zuerst 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 IhremAWS CDKApp. Anschließend erfahren Sie, wie Sie diese Ressourcen synthetisieren und bereitstellen.

Anmerkung

Die Zustandsmaschine, die wir hier zeigen werden, wird eine einfache Zustandsmaschine mit einemPassZustand.

So erstellen Sie eine Express-State-Maschine

Das ist derAWS CDKCode, der eine einfache Zustandsmaschine mit einemPassZustand.

TypeScript
const machineDefinition = new sfn.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 stepfunctions.StateMachine(this, 'MyStateMachine', { definition: machineDefinition, stateMachineType: stepfunctions.StateMachineType.EXPRESS, });
Python
machineDefinition = 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 Maschinendefinition mit dem NamenPassState, ist einPassZustand.

  • Der logische Name der State Machine,MyStateMachine.

  • Die Maschinendefinition wird als Zustandsmaschine-Definition verwendet.

  • Der State Machine Type ist eingestellt alsEXPRESSdaStepFunctionsRestApierlaubt nur einen Synchronous-Express-Zustandsautomaten.

So erstellen Sie die API-Gateway-REST-API mitStepFunctionsRestApiKonstrukt

Wir verwendenStepFunctionsRestApiKonstruieren, um die API Gateway REST API mit den erforderlichen Berechtigungen und der standardmäßigen Eingabe-/Ausgabezuordnung 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#
var api = new StepFunctionsRestApi(this, "StepFunctionsRestApi", new StepFunctionsRestApiProps { StateMachine = stateMachine });
Go
awsapigateway.NewStepFunctionsRestApi(stack, jsii.String("StepFunctionsRestApi"), &awsapigateway.StepFunctionsRestApiProps { StateMachine = stateMachine, })

So erstellen Sie dieAWS CDKApp

In dem von Ihnen erstellten AWS CDK-Projekt bearbeiten Sie die Datei, die die Definition des Stapels enthält, so dass sie wie im folgenden Code aussieht. Sie erkennen die Definitionen der Step Functions Functions-Zustandsmaschine und des API Gateway von oben.

TypeScript

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

import * as cdk from '@aws-cdk/core'; import * as stepfunctions from '@awscdk/aws-stepfunctions'; import * as apigateway from '@aws-cdk/aws-apigateway'; export 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 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('@awscdk/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 stepfunctions.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 core as cdk from aws_cdk import aws_stepfunctions as sfn from aws_cdk import aws_apigateway as apigw class StepfunctionsRestApiStack(cdk.Stack): def __init__(self, scope: cdk.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 scr/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. AWS CDK führt die App aus und synthetisiert eine AWS CloudFormation-Vorlage aus ihr und zeigt dann die Vorlage an.

So stellen Sie das Amazon API Gateway und dieAWS Step FunctionsState-Machine zu Ihrem AWS-Konto, Problemcdk deploy. Sie werden aufgefordert, die IAM-Richtlinien zu genehmigen, die AWS CDK generiert hat. Die erstellten Richtlinien sehen etwa folgendermaßen aus:

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.

Anmerkung

Im Rahmen dieses Tutorials testen wir diePOSTHTTP-Methode.

So testen Sie das bereitgestellte API Gateway mit der API Gateway Gateway-Konsole

  1. Öffnen SieAmazon API Gateway Gateway-Konsoleund melden Sie sich an.

  2. Wählen Sie Ihre REST-API mit dem NamenStepFunctionsRestApi.

  3. Klicken Sie im Bereich Resources auf die Methode, die Sie testen möchten. Für die Zwecke dieses Tutorials wird dies derANY-Methode.

  4. Wählen Sie im Bereich Method Execution im Feld Client die Option TEST aus.

  5. Klicken Sie aufPOSTausMethoden-DownMenü. Geben Sie Werte in das FeldAnforderungstext. Die Konsole schließt diese Werte im Standard-Anwendungs-/JSON-Format in die Methodenanforderung ein. Für die Zwecke dieses Tutorials geben Sie Folgendes in dasAnforderungstext:

    { "key": "Hello" }
  6. 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.

    • Response Body ist der Text der HTTP-Antwort.

    • Response Headers sind die Header der HTTP-Antwort.

    • Logs (Protokolle)sind die simulierten Amazonas CloudWatch Protokolliert -Einträge, die geschrieben worden wären, wenn diese Methode außerhalb der API Gateway Gateway-Konsole aufgerufen worden wäre.

      Anmerkung

      Obwohl der CloudWatch Log-Einträge werden simuliert, die Ergebnisse des Methodenaufrufs sind echt.

DieAntworttextoutput ist in etwa wie folgt:

"Hello"
Tipp

Probieren Sie das API Gateway mit verschiedenen Methoden und einer ungültigen Eingabe aus, 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, um die State Machine-Ausführung nicht erfolgreich auszuführen, und eine Fehlermeldung in derAntworttextoutput.

So testen Sie die bereitgestellte API mithilfe von cURL

  1. Öffnen Sie ein Terminal-Fenster.

  2. 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'

DieAntworttextoutput ist in etwa wie folgt:

"Hello"
Tipp

Probieren Sie das API Gateway mit verschiedenen Methoden und einer ungültigen Eingabe aus, 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, um die State Machine-Ausführung nicht erfolgreich auszuführen, und eine Fehlermeldung in derAntworttextoutput.

Schritt 4: Bereinigen

Wenn Sie mit dem Ausprobieren Ihres API-Gateways fertig sind, können Sie sowohl den State Machine als auch das API Gateway mithilfe des AWS CDK herunterfahren. Geben Sie cdk destroy im Hauptverzeichnis Ihrer App heraus.