Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # 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 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. Console di gestione AWS Prima di iniziare questo tutorial, è necessario configurare l'ambiente di AWS CDK sviluppo come descritto in [Getting Started With the AWS CDK - Prerequisiti](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_prerequisites) 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 di[Utilizzo CloudFormation per creare un flusso di lavoro in Step Functions](tutorial-lambda-state-machine-cloudformation.md). 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](state-succeed.md) 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](https://catalog.workshops.aws/stepfunctions/iac/deploy-with-cdk) in The Workshop. AWS Step Functions * ## Fase 1: Configurazione del progetto AWS CDK 1. 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 directory`step`. 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\$1 ] Assicurati di aver installato la versione 6.0 o successiva. Per informazioni, consulta [Versioni supportate](https://dotnet.microsoft.com/en-us/download/dotnet). ``` mkdir step && cd step ``` ------ 1. 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\$1 ] ``` 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\$1 ] ``` 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: un compito Lambda funzionale e uno [Stato del flusso di lavoro Success](state-succeed.md) stato. La funzione richiede che creiamo una funzione Step Functions [Stato del flusso di lavoro delle attività](state-task.md) 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 denominata`MyLambdaTask`, quindi utilizza il `next()` metodo per definire uno stato di successo denominato. `GreetedWorld` ------ #### [ TypeScript ] ``` const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', { definition: new tasks.LambdaInvoke(this, "MyLambdaTask", { lambdaFunction: helloFunction }).next(new sfn.Succeed(this, "GreetedWorld")) }); ``` ------ #### [ JavaScript ] ``` const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', { definition: new tasks.LambdaInvoke(this, "MyLambdaTask", { lambdaFunction: helloFunction }).next(new sfn.Succeed(this, "GreetedWorld")) }); ``` ------ #### [ Python ] ``` state_machine = sfn.StateMachine( self, "MyStateMachine", definition=tasks.LambdaInvoke( self, "MyLambdaTask", lambda_function=hello_function) .next(sfn.Succeed(self, "GreetedWorld"))) ``` ------ #### [ Java ] ``` final StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine") .definition(LambdaInvoke.Builder.create(this, "MyLambdaTask") .lambdaFunction(helloFunction) .build() .next(new Succeed(this, "GreetedWorld"))) .build(); ``` ------ #### [ C\$1 ] ``` var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps { DefinitionBody = DefinitionBody.FromChainable(new LambdaInvoke(this, "MyLambdaTask", new LambdaInvokeProps { LambdaFunction = helloFunction }) .Next(new Succeed(this, "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. 1. 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\$1 ] 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"))) }); } } } ``` ------ 1. Salva il file sorgente, quindi esegui il `cdk synth` comando nella directory principale dell'app. AWS CDKesegue l'app e sintetizza un 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(); ``` 1. 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 1. Apri la [console Step Functions](https://console.aws.amazon.com/states/home) e scegli il nome della macchina a stati che hai creato utilizzandoAWS CDK. 1. Nella pagina della macchina a stati, scegli **Avvia esecuzione**. Viene visualizzata la finestra di dialogo **Avvia esecuzione**. 1. (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 impediranno ad Amazon CloudWatch di registrare i dati, consigliamo di utilizzare solo caratteri ASCII per tenere traccia delle metriche di Step Functions. 1. Selezionare **Start Execution (Avvia esecuzione)**. L'esecuzione della tua macchina a stati inizia e viene visualizzata una nuova pagina che mostra l'esecuzione in esecuzione. 1. 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](concepts-view-execution-details.md#exec-details-intf-step-details) 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*, vedere[Panoramica dei dettagli di esecuzione](concepts-view-execution-details.md#exec-details-interface-overview). ## 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. ## Fasi successive Per ulteriori informazioni sullo sviluppo AWS dell'infrastruttura utilizzandoAWS CDK, consulta la [Guida per gli AWS CDK sviluppatori](https://docs.aws.amazon.com/cdk/v2/guide/home.html). Per informazioni sulla scrittura di app AWS CDK nel tuo linguaggio preferito, consulta: ------ #### [ TypeScript ] [Lavorare con AWS CDK in TypeScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-typescript.html) ------ #### [ JavaScript ] [Lavorare con AWS CDK in JavaScript](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-javascript.html) ------ #### [ Python ] [Lavorare con AWS CDK Python](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-python.html) ------ #### [ Java ] [Lavorare con AWS CDK Java](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-java.html) ------ #### [ C\$1 ] [Lavorare con AWS CDK C\$1](https://docs.aws.amazon.com/cdk/v2/guide/work-with-cdk-csharp.html) ------ Per ulteriori informazioni sui moduli AWS Construct Library utilizzati in questo tutorial, consultate le seguenti panoramiche di riferimento sulle AWS CDK API: + [aws-lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html) + [funzioni aws-step](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions-readme.html) + [aws-stepfunctions-tasks](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_stepfunctions_tasks-readme.html)