Paso 1: Configura tu AWS CDK Proyecto Paso 2: Usa el AWS CDK para crear una API puerta de enlace REST API con la integración del backend de Synchronous Express State Machine Paso 3: probar la API puerta de enlace Paso 4: Eliminación

Utilización AWS CDK para crear un flujo de trabajo exprés en Step Functions

En este tutorial, aprenderá a crear una API puerta de enlace REST API con una máquina de estados express síncrona como integración de backend, utilizando el AWS Cloud Development Kit (AWS CDK) Infraestructura como marco de código (IAC).

Utilizará la StepFunctionsRestApi construcción para conectar la máquina de estado a la API puerta de enlace. La StepFunctionsRestApi construcción configurará un mapeo de entrada/salida predeterminado y la API puerta de enlace RESTAPI, con los permisos necesarios y un método HTTP «»ANY.

Con AWS CDK es un marco de infraestructura como código (IAC), usted define AWS infraestructura mediante un lenguaje de programación. Define una aplicación en uno CDK de los lenguajes compatibles y sintetiza el código en un AWS CloudFormation plantilla y, a continuación, implementas la infraestructura en tu AWS account.

Utilizará AWS CloudFormation para definir una API puerta de enlace RESTAPI, que esté integrada con Synchronous Express State Machine como backend, utilice el AWS Management Console para iniciar la ejecución.

Antes de comenzar este tutorial, configure su AWS CDK entorno de desarrollo como se describe en Cómo empezar con el AWS CDK - Requisitos previos, luego instale el AWS CDK emitiendo:


npm install -g aws-cdk

Paso 1: Configura tu AWS CDK Proyecto

Primero, crea un directorio para tu nuevo AWS CDK aplicación e inicializa el proyecto.

nota

Asegúrese de asignarle al directorio el nombre stepfunctions-rest-api. La AWS CDK la plantilla de aplicación utiliza el nombre del directorio para generar nombres para las clases y los archivos fuente. Si utiliza otro nombre, la aplicación no coincidirá con este tutorial.

Ahora instale los módulos de la biblioteca de construcción para AWS Step Functions y Amazon API Gateway.

Una vez que haya instalado los módulos, podrá utilizarlos en su AWS CDK aplicación importando los siguientes paquetes.

Paso 2: Usa el AWS CDK para crear una API puerta de enlace REST API con la integración del backend de Synchronous Express State Machine

Primero, presentaremos los fragmentos de código individuales que definen la máquina sincrónica de estados rápidos y la API puerta de enlace RESTAPI, y luego explicaremos cómo unirlos en su AWS CDK aplicación. A continuación, verá cómo sintetizar e implementar estos recursos.

nota

La máquina de estado que mostraremos aquí será una máquina de estado simple con un estado Pass.

Para crear una máquina de estado rápida

Este es el AWS CDK código que define una máquina de estados simple con un Pass estado.

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

En este breve fragmento de código, puede ver lo siguiente:

La definición de máquina denominada PassState, que es un estado Pass.
El nombre lógico de la máquina de estado, MyStateMachine.
La definición de la máquina se utiliza como definición de la Máquina de estado.
El tipo de máquina de estado se establece como EXPRESS porque StepFunctionsRestApi solo permitirá una máquina de estado rápida síncrona.

Para crear la API puerta de enlace REST API mediante la `StepFunctionsRestApi` construcción

Usaremos la StepFunctionsRestApi construcción para crear la API puerta de enlace REST API con los permisos necesarios y el mapeo de entrada/salida predeterminado.

Para crear e implementar el AWS CDK Aplicación

En el navegador AWS CDK proyecto que creó, edite el archivo que contiene la definición de la pila para que tenga el aspecto del código siguiente. Reconocerá las definiciones de la máquina de estados Step Functions y de la API puerta de enlace desde arriba.

TypeScript

Actualice lib/stepfunctions-rest-api-stack.ts para que diga lo siguiente.


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

Actualice lib/stepfunctions-rest-api-stack.js para que diga lo siguiente.


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

Actualice stepfunctions_rest_api/stepfunctions_rest_api_stack.py para que diga lo siguiente.


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

Actualice src/main/java/com.myorg/StepfunctionsRestApiStack.java para que diga lo siguiente.


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#

Actualice src/StepfunctionsRestApi/StepfunctionsRestApiStack.cs para que diga lo siguiente.


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

Actualice stepfunctions-rest-api.go para que diga lo siguiente.


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

Guarde el archivo fuente y, a continuación, ejecute cdk synth en el directorio principal de la aplicación. La AWS CDK ejecuta la aplicación y sintetiza un AWS CloudFormation plantilla a partir de ella y, a continuación, muestra la plantilla.

Para implementar realmente Amazon API Gateway y el AWS Step Functions estado de la máquina en su AWS cuenta, emitacdk deploy. Se te pedirá que apruebes las IAM políticas del AWS CDK ha generado.

Paso 3: probar la API puerta de enlace

Después de crear su API puerta de enlace REST API con Synchronous Express State Machine como integración de backend, puede probar la API puerta de enlace.

Para probar la puerta de API enlace implementada mediante API la consola de Gateway

Abra la consola de Amazon API Gateway e inicie sesión.
Elija su REST API nombreStepFunctionsRestApi.
En el panel Recursos, elija el método ANY.
Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
En Method (Método), seleccione POST.
En Cuerpo de la solicitud, copie los siguientes parámetros de solicitud.
```
{
    "key": "Hello"
}
```
Seleccione Test (Probar). Se mostrará la siguiente información:
- Request (Solicitud) es la ruta del recurso llamada para el método.
- El estado es el código de HTTP estado de la respuesta.
- Latency (Latencia) es el tiempo entre la recepción de la solicitud del intermediario y la respuesta devuelta.
- El cuerpo de respuesta es el cuerpo de HTTP respuesta.
- Los encabezados de respuesta son los encabezados de HTTP respuesta.
- El registro muestra las entradas simuladas de Amazon CloudWatch Logs que se habrían escrito si se hubiera llamado a este método fuera de la consola API Gateway.
  
  nota
  Aunque las entradas de CloudWatch Logs son simuladas, los resultados de la llamada al método son reales.

La salida de Cuerpo de respuesta debe tener un aspecto similar al siguiente:


"Hello"

sugerencia

Pruebe el API Gateway con métodos diferentes y una entrada no válida para ver el resultado del error. Es posible que desee cambiar la máquina de estado para buscar una clave en particular y, durante las pruebas, proporcionar la clave incorrecta para que no se ejecute correctamente la máquina de estado y generar un mensaje de error en la salida de Cuerpo de respuesta.

Para probar el desplegado, API utilice c URL

Abra una ventana de terminal.
Copia el siguiente URL comando c y pégalo en la ventana de la terminal, <api-id> sustituyéndolo por tu API API ID y <region> por la región en la que API estás desplegado.
```
curl -X POST\
 'https://<api-id>.execute-api.<region>.amazonaws.com/prod' \
 -d '{"key":"Hello"}' \
 -H 'Content-Type: application/json'
```

El resultado del cuerpo de la respuesta debe tener un aspecto similar al siguiente:


"Hello"

sugerencia

Prueba el API Gateway con diferentes métodos y una entrada no válida para ver el resultado del error. Es posible que desee cambiar la máquina de estado para buscar una clave en particular y, durante las pruebas, proporcionar la clave incorrecta para que no se ejecute correctamente la máquina de estado y generar un mensaje de error en el resultado del cuerpo de la respuesta.

Paso 4: Eliminación

Cuando termines de probar tu API Gateway, puedes derribar tanto la máquina de estados como la API Gateway utilizando el AWSCDK. Ejecute cdk destroy en el directorio principal de la aplicación.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Se utiliza CDK para crear un flujo de trabajo estándar

Uso de Terraform para implementar flujos de trabajo

Utilización AWS CDK para crear un flujo de trabajo exprés en Step Functions

Paso 1: Configura tu AWS CDK Proyecto

nota

Paso 2: Usa el AWS CDK para crear una API puerta de enlace REST API con la integración del backend de Synchronous Express State Machine

nota

Para crear una máquina de estado rápida

Para crear la API puerta de enlace REST API mediante la StepFunctionsRestApi construcción

Para crear e implementar el AWS CDK Aplicación

Paso 3: probar la API puerta de enlace

Para probar la puerta de API enlace implementada mediante API la consola de Gateway

nota

sugerencia

Para probar el desplegado, API utilice c URL

sugerencia

Paso 4: Eliminación

Para crear la API puerta de enlace REST API mediante la `StepFunctionsRestApi` construcción