Fase 1: Configurazione del progetto AWS CDK Passaggio 2: Utilizzare AWS CDK per creare una macchina a stati Fase 3: Avviare l'esecuzione di una macchina a stati Fase 4: eliminazione Passaggi successivi

Utilizzo AWS CDK per creare un flusso di lavoro standard in Step Functions

È possibile utilizzare il framework AWS Cloud Development Kit (AWS CDK) Infrastructure as Code (IAC) per creare una macchina a AWS Step Functions stati che contiene una AWS Lambda funzione.

Definirai l' AWS infrastruttura utilizzando uno dei CDK linguaggi supportati. Dopo aver definito l'infrastruttura, sintetizzerai l'app in un AWS CloudFormation modello e la distribuirai sul tuo account. AWS

Utilizzerai questo metodo per definire una macchina a stati Step Functions contenente una funzione Lambda, quindi eseguirai la macchina a stati utilizzando Step Functions. AWS Management Console

Prima di iniziare questo tutorial, è necessario configurare l'ambiente di AWS CDK sviluppo come descritto in Getting Started With the AWS CDK - Prerequisiti nella AWS Cloud Development Kit (AWS CDK) Developer Guide. Quindi, installalo AWS CDK con il seguente comando su: AWS CLI


npm install -g aws-cdk

Questo tutorial produce lo stesso risultato diUtilizzo AWS CloudFormation per creare un flusso di lavoro in Step Functions. Tuttavia, in questo tutorial, AWS CDK non è necessario che tu IAM crei alcun ruolo; lo AWS CDK fa per te. La AWS CDK versione include anche un Stato del flusso di lavoro Success passaggio per illustrare come aggiungere ulteriori passaggi alla macchina a stati.

Suggerimento

Per distribuire un'applicazione serverless di esempio che avvia un Step Functions flusso di lavoro utilizzando AWS CDK with TypeScript, vedi Deploy with AWS CDK in The Workshop. AWS Step Functions

Fase 1: Configurazione del progetto AWS CDK

Nella tua home directory, o in un'altra directory se preferisci, esegui il comando seguente per creare una directory per la tua nuova app. AWS CDK

Importante
Assicurati di assegnare un nome alla directorystep. Il modello di AWS CDK applicazione utilizza il nome della directory per generare nomi per i file e le classi di origine. Se utilizzi un nome diverso, l'app non corrisponderà a questo tutorial.
TypeScript
```
mkdir step && cd step
```
JavaScript
```
mkdir step && cd step
```
Python
```
mkdir step && cd step
```
Java
```
mkdir step && cd step
```
C#
Assicurati di aver installato.NET versione 6.0 o successiva. Per informazioni, consulta Versioni supportate.
```
mkdir step && cd step
```
Inizializza l'app utilizzando il comando cdk init. Specificate il modello («app») e il linguaggio di programmazione desiderati come mostrato negli esempi seguenti.
TypeScript
```
cdk init --language typescript
```
JavaScript
```
cdk init --language javascript
```
Python
```
cdk init --language python
```
Dopo l'inizializzazione del progetto, attiva l'ambiente virtuale del progetto e installa le dipendenze AWS CDK di base.
```
source .venv/bin/activate
python -m pip install -r requirements.txt
```
Java
```
cdk init --language java
```
C#
```
cdk init --language csharp
```

Passaggio 2: Utilizzare AWS CDK per creare una macchina a stati

Per prima cosa, presenteremo le singole parti di codice che definiscono la Lambda funzione e la macchina a Step Functions stati. Quindi, spiegheremo come metterli insieme nella tua AWS CDK app. Infine, vedrete come sintetizzare e distribuire queste risorse.

Per creare una funzione Lambda

Il AWS CDK codice seguente definisce la Lambda funzione, fornendo il codice sorgente in linea.

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

Puoi vedere in questo breve codice di esempio:

Il nome logico della funzione,MyLambdaFunction.
Il codice sorgente della funzione, incorporato come stringa nel codice sorgente dell'AWS CDKapp.
Altri attributi della funzione, come il runtime da utilizzare (Nodo 18.x), il punto di ingresso della funzione e un timeout.

Per creare una macchina a stati

La nostra macchina a stati ha due stati: una Lambda funzione, un'attività e uno Stato del flusso di lavoro Success stato. La funzione richiede che creiamo una funzione Step Functions Stato del flusso di lavoro delle attività che richiami la nostra funzione. Questo stato dell'attività viene utilizzato come primo passaggio nella macchina a stati. Lo stato di successo viene aggiunto alla macchina a stati utilizzando il next() metodo dello stato Task. Il codice seguente richiama innanzitutto la funzione denominataMyLambdaTask, quindi utilizza il next() metodo per definire uno stato di successo denominato. GreetedWorld

Per creare e distribuire l'app AWS CDK

Nel AWS CDK progetto appena creato, modifica il file che contiene la definizione dello stack in modo che assomigli al seguente codice di esempio. Riconoscerai le definizioni della Lambda funzione e della macchina a Step Functions stati delle sezioni precedenti.

Aggiorna lo stack come mostrato negli esempi seguenti.

TypeScript

Aggiorna lib/step-stack.ts con il codice seguente.


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

Aggiorna lib/step-stack.js con il seguente codice.


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

Aggiorna step/step_stack.py con il seguente codice.


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

Aggiorna src/main/java/com.myorg/StepStack.java con il seguente codice.


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#

Aggiorna src/Step/StepStack.cs con il seguente codice.


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

Salva il file sorgente, quindi esegui il cdk synth comando nella directory principale dell'app.

AWS CDKesegue l'app e sintetizza un AWS CloudFormation modello a partire da essa. AWS CDKquindi visualizza il modello.
Nota
Se lo hai usato TypeScript per creare il tuo AWS CDK progetto, l'esecuzione del cdk synth comando potrebbe restituire il seguente errore.
```
TSError: ⨯ Unable to compile TypeScript:
bin/step.ts:7:33 - error TS2554: Expected 2 arguments, but got 3.
```
Modificate il bin/step.ts file come mostrato nell'esempio seguente per risolvere questo errore.
```
#!/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();
```
Per distribuire la funzione Lambda e la macchina a stati Step Functions AWS sul tuo account, emetti. cdk deploy Ti verrà chiesto di approvare le policy IAM che ha generato. AWS CDK

Fase 3: Avviare l'esecuzione di una macchina a stati

Dopo aver creato la macchina a stati, è possibile avviarne l'esecuzione.

Per avviare l'esecuzione della macchina a stati

Apri la console Step Functions e scegli il nome della macchina a stati che hai creato utilizzandoAWS CDK.
Nella pagina della macchina a stati, scegli Avvia esecuzione.

Viene visualizzata la finestra di dialogo Avvia esecuzione.
(Facoltativo) Immettete un nome di esecuzione personalizzato per sostituire il valore predefinito generato.

Nomi e log non ASCII
Step Functions accetta nomi per macchine a stati, esecuzioni, attività ed etichette che contengono caratteri non ASCII. Poiché tali caratteri non funzionano con Amazon CloudWatch, ti consigliamo di utilizzare solo caratteri ASCII per tenere traccia delle metriche. CloudWatch
Selezionare Start Execution (Avvia esecuzione).

L'esecuzione della macchina a stati inizia e viene visualizzata una nuova pagina che mostra l'esecuzione in esecuzione.
La console Step Functions ti indirizza a una pagina intitolata con il tuo ID di esecuzione. Questa pagina è nota come pagina dei dettagli di esecuzione. In questa pagina è possibile esaminare i risultati dell'esecuzione man mano che l'esecuzione procede o dopo il suo completamento.

Per esaminare i risultati dell'esecuzione, scegliete i singoli stati nella vista Grafico, quindi scegliete le singole schede Dettagli del passaggio nel riquadro per visualizzare i dettagli di ogni stato, inclusi rispettivamente input, output e definizione. Per i dettagli sulle informazioni sull'esecuzione che è possibile visualizzare nella pagina Dettagli di esecuzione, vederePanoramica dei dettagli di esecuzione.

Fase 4: eliminazione

Dopo aver testato la tua macchina a stati, ti consigliamo di rimuovere sia la macchina a stati che la relativa funzione Lambda per liberare risorse nel tuo. Account AWS Esegui il cdk destroy comando nella directory principale dell'app per rimuovere la macchina a stati.

Passaggi successivi

Per ulteriori informazioni sullo sviluppo AWS dell'infrastruttura utilizzandoAWS CDK, consulta la Guida per gli AWS CDK sviluppatori.

Per informazioni sulla scrittura di app AWS CDK nel tuo linguaggio preferito, consulta:

Per ulteriori informazioni sui moduli AWS Construct Library utilizzati in questo tutorial, consultate le seguenti panoramiche di riferimento sulle AWS CDK API:

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Crea una macchina a stati con CloudFormation

Utilizzo di CDK per creare un flusso di lavoro Express