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à.
# Scopri come iniziare a usare Step Functions
Con il servizio Step Functions, puoi orchestrare flussi di lavoro applicativi complessi. Per iniziare, utilizzerai Workflow Studio per creare ed eseguire un flusso di lavoro **Hello** World integrato. Esaminerai la definizione generata automaticamente [Lingua degli Stati di Amazon](concepts-amazon-states-language.md) (ASL) nel codice. Infine, avrai drag-and-drop un'integrazione di servizi per eseguire l'analisi del sentiment.
Dopo aver completato questo tutorial, saprete come utilizzare Workflow Studio per creare, configurare, eseguire e aggiornare un flusso di lavoro utilizzando le modalità **Progettazione** e **Codice**.
Durata stimata: **20-30 minuti**
## Cosa costruirai
La tua prima macchina a stati inizierà con *gli stati di flusso*. Gli stati di flusso vengono utilizzati per dirigere e controllare il flusso di lavoro. Dopo aver appreso come eseguire il flusso di lavoro, aggiungerai un'**azione** per integrare il servizio Amazon Comprehend con uno stato **Task**.
Il diagramma seguente mostra un'immagine della macchina a stati completa che costruirai. La prima volta che crei la macchina a stati Hello World, non avrai bisogno di risorse aggiuntive per funzionare. La console Step Functions creerà tutti gli stati e un ruolo IAM con un solo clic. Successivamente, quando aggiungerai l'integrazione del servizio, dovrai creare un ruolo con una politica di autorizzazione personalizzata.
![\[Rappresentazione visiva del flusso di lavoro di Hello World.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/hello-world-arch.png)
## Fase 1 - Crea la tua macchina a stati
In Step Functions, *i flussi di lavoro* sono chiamati **macchine a stati**. Useremo entrambi i termini in modo intercambiabile. I tuoi flussi di lavoro conterranno *stati* che **agiscono o controllano** **il flusso** delle tue macchine a stati.
1. Vai alla **console Step Functions.**
1. **Nella console Step Functions, scegli "**Step Functions**" dalla barra di navigazione in alto a sinistra o dalla barra di navigazione, quindi scegli Inizia:**
![\[Schermata illustrativa che mostra come iniziare con il flusso di lavoro Hello World\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/get-started-hello-world.png)
1. Tra le opzioni, scegli **Esegui Hello World**:
![\[Schermata illustrativa che mostra come scegliere il flusso di lavoro di Hello World\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/create-hello-world.png)
**Suggerimento**
Ti consigliamo di seguire la breve procedura guidata nella console per acquisire familiarità con l'interfaccia utente.
### Panoramica di Workflow Studio
Con Workflow Studio for Step Functions, puoi visualizzare drag-and-drop gli stati su una tela per creare flussi di lavoro.
È possibile aggiungere e modificare stati, configurare passaggi, trasformare i risultati e impostare la gestione degli errori. La schermata seguente mostra quattro aree importanti dell'interfaccia che utilizzerete per creare le vostre macchine a stati.
![\[Schermata illustrativa delle quattro aree importanti dell'interfaccia di Workflow Studio\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/wfs-panel-overview.png)
**Modalità**: Workflow Studio offre tre modalità operative e l'impostazione predefinita è la modalità di progettazione visiva.
+ **Design**: una modalità di modifica visiva, in cui è possibile inserire drag-and-drop gli stati nel flusso di lavoro.
+ **Codice**: una modalità che si concentra sul codice Amazon States Language, noto anche come codice ASL. Puoi modificare direttamente il codice ASL e vedere le modifiche riflesse nel design visivo.
+ **Config**: opzioni di configurazione che includono il nome e il tipo della macchina a stati (Standard o Express), il ruolo assegnato durante l'esecuzione del flusso di lavoro, la registrazione, il tracciamento, il controllo delle versioni, la crittografia e i tag.
Il **browser States** contiene le seguenti tre schede:
+ **Azioni**: un elenco delle azioni AWS APIs che puoi drag-and-drop inserire nel tuo flusso di lavoro. Ogni azione rappresenta uno stato del flusso di lavoro di Task.
+ **Flusso**: stati del flusso per controllare l'ordine delle fasi del flusso di lavoro.
+ **Modelli**: ready-to-use elementi costitutivi riutilizzabili, come l'elaborazione iterativa dei dati in un bucket Amazon S3.
La **tela e il grafico del flusso** di lavoro consentono di drag-and-drop visualizzare gli stati del grafico del flusso di lavoro, modificare l'ordine degli stati e selezionare gli stati da configurare e testare.
Il **pannello Inspector** consente di visualizzare e modificare le proprietà di qualsiasi stato selezionato nell'area di disegno. È possibile attivare l'interruttore *Definizione* per mostrare il codice per lo stato attualmente selezionato.
### Panoramica della macchina a stati
Il flusso di lavoro Hello World inizia con uno **stato Pass** *che trasmette* l'input all'output, senza eseguire alcuna operazione. Gli stati Pass possono essere utilizzati per generare un output JSON statico o trasformare l'input JSON prima di passare i dati allo stato successivo. Gli stati di passaggio sono utili per la costruzione e il debug di macchine a stati.
Lo stato successivo, uno **stato Choice**, utilizza i dati in ingresso `IsHelloWorldExample` per scegliere il ramo successivo del flusso di lavoro. Se la prima regola corrisponde, il flusso di lavoro viene sospeso in uno **stato di attesa**, quindi esegue due attività in uno **stato Parallelo**, prima di passare a un checkpoint e alla conclusione corretta del flusso di lavoro. Quando non vi è alcuna corrispondenza, il flusso di lavoro passa per impostazione predefinita **allo stato Fail** prima di arrestare la macchina a stati.
Gli stati di attesa possono essere utili quando si desidera ritardare l'esecuzione di ulteriori operazioni. Forse il flusso di lavoro aspetterà 30 secondi dopo l'immissione dell'ordine, in modo che il cliente abbia il tempo di notare e correggere un indirizzo di spedizione errato.
Gli stati paralleli possono eseguire più processi sui dati. Forse il flusso di lavoro stamperà un ticket d'ordine, aggiornerà l'inventario e aumenterà contemporaneamente un rapporto giornaliero sulle vendite.
![\[Immagine illustrativa del flusso di lavoro introduttivo di Hello World\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/workflow-1-hello-world.png)
### Visualizza il codice del flusso di lavoro (ASL)
La tua prima macchina a stati è in effetti piuttosto dettagliata, quindi approfondisci esaminando il codice.
Le macchine a stati sono definite utilizzando [Amazon States Language (ASL)](https://states-language.net/), una specifica open source che descrive un linguaggio basato su JSON per descrivere le macchine a stati in modo dichiarativo.
**Per visualizzare l'intera definizione di macchina a stati**
1. Scegli il pulsante **\$1\$1 Code** per visualizzare il codice ASL.
1. Visualizza il codice a sinistra e confrontalo con il grafico della macchina statale a destra.
1. Seleziona alcuni stati sulla tela da esaminare. Ad esempio, scegli lo **stato Choice**.
![\[Immagine illustrativa della visualizzazione del codice\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/hello-code-view.png)
Hai notato come viene evidenziata la definizione dello stato nella vista del codice?
**Per visualizzare il codice nell'Inspector**
1. Torna alla modalità **Progettazione**.
1. Espandi il **pannello Inspector** a destra.
1. Seleziona lo **stato della scelta** dal grafico del flusso di lavoro sul Canvas.
1. Nel pannello **Inspector**, scegliete l'interruttore **Definizione**.
Provate a scegliere altri stati. Guarda come viene visualizzato ed evidenziato il codice ASL per ogni stato selezionato?
### (In realtà) Crea la macchina a stati
**Attenzione: assegna subito un nome alla tua macchina a stati\$1**
**Non è possibile rinominare** una macchina a stati dopo averla creata. Scegliete un nome **prima** di salvare la macchina a stati.
Fino ad ora, hai lavorato su una bozza della tua macchina a stati. Nessuna risorsa è stata ancora creata.
**Per rinominare e creare la tua macchina a stati**
1. Scegli la **modalità Config.**
1. Per il nome della macchina a stati, immettere `MyFirstStateMachine`
1. Per le autorizzazioni, accettate l'impostazione predefinita *Crea un nuovo ruolo*.
1. Scegli il pulsante **Crea** per creare **effettivamente** la tua macchina a stati.
Dovresti vedere le notifiche che indicano che la tua macchina a stati e un nuovo ruolo IAM sono stati creati.
Ti verrà automaticamente presentata la possibilità di avviare la macchina a stati. Lo farai nel passaggio successivo\$1
![\[Immagine illustrativa del flusso di lavoro introduttivo di Hello World\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/workflow-created.png)
**Creazione del flusso di lavoro completata\$1**
Step Functions ha creato il tuo flusso di lavoro e il tuo ruolo IAM. Ora sei pronto per avviare la tua macchina a stati.
## Passaggio 2: avvia la tua macchina a stati
Dopo aver creato la macchina a stati, puoi avviare il flusso di lavoro.
I flussi di lavoro accettano facoltativamente **input** che possono essere utilizzati nello stato, inviati a servizi integrati e passati allo stato successivo.
La macchina a stati **Hello World** è autonoma e non necessita di input.
![\[Immagine illustrativa di come iniziare\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/start_283486381.jpg)
**Per avviare la macchina a stati**
1. Immettete `hello001` il nome dell'esecuzione.
1. Lascia *vuoto* il campo di immissione.
1. Scegli il pulsante **Avvia esecuzione**.
![\[Immagine illustrativa per l'avvio di un flusso di lavoro.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/hello001.png)
### Esamina i dettagli dell'esecuzione
Subito dopo l'avvio, dovresti vedere che i primi due stati hanno **avuto successo**.
Dopo una breve attesa, verranno eseguite le altre transizioni di stato per completare il flusso di lavoro.
Ti stai chiedendo come si *trova **lo stato di Choice** (Is Hello World Example*)? ) ha deciso di passare allo stato **Wait for X Seconds**?
1. Suggerimento: il primo passaggio della macchina a stati contiene i dati necessari per la decisione della filiale
1. Nella **Graph View**, è possibile monitorare i progressi durante l'esecuzione ed esplorare i dettagli per ogni stato.
1. Selezionate il primo **stato Pass** (denominato *Set Variables and State Output*), quindi esaminate la scheda **Input/Output**.
Dovresti vedere che **lo State input** è vuoto, ma **State output** contiene JSON che imposta il valore di to. `IsHelloWorldExample` `true`
![\[Esecuzione 001\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/hello001-graph-view.png)
Passa dalla **vista Grafico** alla **vista Tabella per visualizzare** un elenco di stati per nome, tipo e stato.
![\[Esecuzione: 001, visualizzazione della tabella\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/hello001-table.png)
**Suggerimento**
Prendi nota dei campi **Durata** e **Cronologia** nella schermata precedente. A colpo d'occhio, puoi vedere quali stati richiedono più tempo rispetto ad altri.
Ci sono altre due visualizzazioni da esplorare in questa pagina dei dettagli delle esecuzioni: **visualizzazione degli eventi e visualizzazione** **dello stato**.
La **visualizzazione degli eventi** è una visualizzazione granulare dettagliata del flusso da uno stato all'altro.
Espandi la prima **PassStateEntered**e **PassStateExited**gli eventi nella tabella **Visualizzazione** eventi per vedere come lo stato non riceve alcun input, assegna una variabile chiamata `CheckpointCount` valore zero e produce l'output visualizzato in precedenza.
![\[Visualizzazione degli eventi Execution 001\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/hello001-event-view.png)
Infine, hai la **vista dello stato** che è simile alla **vista Tabella**. Nella tabella di **visualizzazione dello stato**, puoi espandere selettivamente **gli stati** per visualizzare solo gli ingressi e le uscite per ogni stato:
![\[Visualizzazione dello stato di esecuzione: 001\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/hello001-state-view.png)
**Complimenti\$1 Hai avviato la tua prima macchina a stati Step Functions\$1**
L'utilizzo di uno stato Pass per aggiungere **dati statici** a un flusso di lavoro è uno schema comune, soprattutto per la risoluzione dei problemi.
Nella fase successiva, aggiornerai il flusso di lavoro in modo da poter impostare *dinamicamente* l'input della tua macchina a stati.
## Fase 3 - Elaborazione dell'input esterno
L'impostazione del valore di `IsHelloWorldExample` su un valore costante all'interno del flusso di lavoro non è realistica. Dovresti aspettarti che la tua macchina a stati risponda a dati di input diversi.
In questo passaggio, ti mostreremo come utilizzare i dati JSON esterni come input per il tuo flusso di lavoro:
![\[Elabora l'input esterno\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/process-external-input.png)
### Rimuovi l'input codificato
Innanzitutto, sostituisci il valore codificato nell'**output** dello stato del primo passaggio.
1. Modifica la tua macchina a stati Hello World selezionando il pulsante **Modifica macchina a stati** situato in alto a destra nella pagina.
1. Seleziona il primo **stato Pass** dopo **Start** (denominato *Set Variables and State Output*), quindi seleziona la scheda **Output**.
1. Sostituisci l'**output** con il seguente codice JSON:
```
{
"IsHelloWorldExample": "{% $states.input.hello_world %}",
"ExecutionWaitTimeInSeconds": "{% $states.input.wait %}"
}
```
1. Salva la macchina a stati.
L'output dello stato aggiornato estrarrà i dati di input dalla variabile riservata **[\$1states](transforming-data.md#transforming-reserved-variable-states)** utilizzando un' JSONata espressione. Questi valori verranno passati allo stato successivo come output per diventare l'input per lo stato successivo.
### Esegui il flusso di lavoro aggiornato, con i dati di input
Quindi, esegui il flusso di lavoro e fornisci dati di input esterni come JSON.
1. Scegli il pulsante **Esegui** per eseguire il flusso di lavoro.
1. Per il **nome**, usa l'ID generato casualmente.
1. Usa il seguente codice JSON per il campo di input:
```
{
"wait" : 20,
"hello_world": true
}
```
1. Scegli il pulsante **Avvia esecuzione**.
L'esecuzione della macchina a stati dovrebbe attendere molto più a lungo (20 secondi), ma alla fine dovrebbe avere successo utilizzando l'input fornito.
Nella vista Grafico, esaminate l'**input/output** per il primo Pass State. Notate come l'input che avete fornito è stato convertito in output. Inoltre, dai un'occhiata all'**input e all'output dell'esecuzione** nella parte superiore della pagina dei dettagli dell'esecuzione. Entrambe le posizioni mostrano l'input che hai usato per avviare l'esecuzione.
**Suggerimento**
**Cosa ti aspetti se esegui una nuova esecuzione con *hello\$1world impostato su false*?** Eseguire una prova
### Rivedi le esecuzioni del flusso di lavoro
Ora che hai eseguito il flusso di lavoro alcune volte, rivedi i dettagli di esecuzione per esaminare le esecuzioni del flusso di lavoro.
**Per esaminare i dettagli dell'esecuzione**
1. Scegli **le macchine a stati** dalla barra di navigazione o dal menu a sinistra.
1. Scegli la tua macchina a stati.
Nella scheda **Esecuzioni**, dovresti vedere un elenco di esecuzioni, simile alla seguente schermata:
![\[Schermata illustrativa che mostra un elenco di esempio di esecuzioni di hello workflow.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/hello-executions.png)
Un'ultima nota: i nomi di esecuzione del flusso di lavoro devono essere univoci e **non possono** essere riutilizzati. Sebbene in questo tutorial abbiamo suggerito un nome breve (`hello001`), consigliamo di utilizzare una convenzione di denominazione che sarà sempre unica per i carichi di lavoro di produzione.
**Suggerimento**
**Complimenti\$1** Hai modificato il flusso di lavoro per elaborare *input esterni* che possono variare ogni volta che esegui il flusso di lavoro.
## Fase 4 - Integrazione di un servizio
Le macchine a stati Step Functions possono richiamare oltre 220 AWS servizi utilizzando [integrazioni AWS SDK](https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html). AWSi servizi forniscono oltre 10.000 potenziali azioni API per le vostre macchine a stati.
In questa fase, integrerai un task Amazon Comprehend per l'**analisi del sentiment** per elaborare l'input della tua macchina a stati.
Le integrazioni di servizi utilizzano uno dei tre modelli di integrazione dei *servizi*:
1. **Richiedi una risposta** (impostazione predefinita): attendi la risposta HTTP, quindi passa *immediatamente* allo stato successivo.
1. **Esegui un Job** (*.sync*): attendi il completamento di un processo prima di passare alla fase successiva.
1. **Attendi il callback** *(. waitForTaskToken*): sospende un flusso di lavoro fino a quando un processo esterno non restituisce un token di attività.
![\[Schermata illustrativa raffigurante l'integrazione di un servizio.\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/AdobeStock_513621530_integration_1000.jpg)
Per la prima integrazione, utilizzerai il modello di integrazione **Request Response** (predefinito).
### Come funzionano le integrazioni?
Uno *stato Task* rappresenta una singola unità di lavoro eseguita da una macchina a stati. Tutte le operazioni nella macchina a stati vengono eseguite mediante task.
Un'attività in genere esegue il lavoro trasferendo input alle azioni API di altri servizi, che quindi eseguono il proprio lavoro. È possibile specificare il rendimento di un'attività utilizzando una serie di campi tra cui:`Credentials`,`Retry`, `Catch``TimeoutSeconds`, e altro ancora. Puoi trovare ulteriori informazioni su Tasks in[Stato del flusso di lavoro delle attività](state-task.md).
Per utilizzare le integrazioni AWS SDK, devi specificare il **nome del servizio** e l'**API** da chiamare. Alcune integrazioni richiedono anche parametri.
Puoi utilizzare Amazon States Language per specificare un'azione AWS API nel campo **Risorsa** di uno stato dell'attività. Facoltativamente, puoi aggiungere un tipo di integrazione del servizio al nome del servizio.
Per specificare un'azione API, utilizzerai il seguente modello di nome della risorsa:
```
arn:aws:states:::aws-sdk:serviceName:apiAction.[serviceIntegrationPattern]
```
**Nome del parametro (case)**
Nota che le azioni API saranno *CamelCase* (iniziale minuscola), *ParameterNames*ma saranno Pascal (iniziale maiuscola).
**Esempi di nomi di risorse**
+ `arn:aws:states:::aws-sdk:ec2:describeInstances`restituirà i risultati della chiamata all'API Amazon EC2 DescribeInstances.
+ `arn:aws:states:::aws-sdk:s3:listBuckets`restituirà i risultati della chiamata all'API ListBuckets di Amazon S3.
+ `arn:aws:states:::aws-sdk:sfn:startExecution`avvierà l'esecuzione di una macchina a stati Step Functions annidata e restituirà i risultati di quel flusso di lavoro.
Quando Step Functions chiama un altro servizio utilizzando lo `Task` stato, lo schema predefinito è [Request Response](https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default). Con il pattern di integrazione **Request Response**, Step Functions chiama un servizio, riceve una risposta e passa ***immediatamente*** allo stato successivo.
![\[Integrazione del rilevamento del sentiment\]](http://docs.aws.amazon.com/it_it/step-functions/latest/dg/images/integrate_sentiment_592194331.png)
### Fase 4.1 - Aggiungere lo stato di analisi del sentimento
1. **Modifica** la tua macchina a **MyFirstStateMachine**stati.
1. Nel pannello **Azioni** del **browser Stati**, cercate`DetectSentiment`.
1. Trascina e rilascia **Comprehend DetectSentiment** sul ramo **Default** dello stato **Choice**.
1. Seleziona ed elimina lo stato **Fail**.
1. Dalla **scheda Flow** del **browser States**, trascina lo stato **Success** dopo **DetectSentiment**.
### Fase 4.2 - Configurare lo stato di analisi del sentiment
1. Selezionate il passaggio **Comprehend** per configurarlo nel pannello Inspector.
1. Seleziona la scheda **Argomenti e output**, quindi sostituisci **gli argomenti** con il seguente codice JSON:
```
{
"LanguageCode": "en",
"Text": "{% %}"
}
```
1. Posiziona il cursore **tra i** segni di percentuale: `{% %}` e digita: `$`
1. Usa il **completamento automatico** nell'editor per scegliere`states`,
quindi digita `.` e scegli`context`,
quindi digita `.` e scegli`Execution`,
quindi digita `.` e scegli`Input`,
infine, digitate `.feedback_comment` per recuperare l'input iniziale dall'**oggetto contestuale**.
**Dopo aver scelto queste opzioni di completamento automatico, dovresti avere il seguente JSON per gli argomenti dei tuoi stati:**
```
{
"LanguageCode": "en",
"Text": "{% $states.context.Execution.Input.feedback_comment %}"
}
```
**Utilizzo del completamento automatico dell'editor**
Con il completamento automatico dell'editor, puoi esplorare le tue opzioni.
Il completamento automatico elencherà le tue variabili, la variabile riservata **[\$1states](transforming-data.md#transforming-reserved-variable-states)** che contiene l'oggetto context e le funzioni disponibili con le relative definizioni\$1
### Fase 4.3 - Configurare una politica di identità
Prima di poter eseguire il flusso di lavoro, è necessario creare un **ruolo** e una **policy** per consentire alla macchina a stati di eseguire chiamate API al servizio esterno.
**Per creare un ruolo IAM per Step Functions**
1. Vai alla console IAM in una nuova scheda e seleziona **Ruoli**.
1. Scegli **Create a new role** (Crea un nuovo ruolo).
1. Per il **tipo di entità affidabile** scegli*AWSService*.
1. Per **Use case** scegli*Step Functions*.
1. Per **Aggiungi autorizzazioni**, scegli **Avanti** per accettare la politica predefinita. Aggiungerai una policy per Comprehend dopo aver creato il ruolo.
1. In **Nome**, inserisci *HelloWorldWorkflowRole*.
1. Scegli **Crea ruolo**.
**Per aggiungere una policy a **HelloWorldWorkflowRole**per Amazon Comprehend**
1. Seleziona e modifica il **HelloWorldWorkflowRole**ruolo.
1. Scegli **Aggiungi autorizzazione**, quindi **Crea politica in linea**.
1. Seleziona **Comprehend** per il servizio.
1. **In **Leggi** scegli **DetectSentiment**, quindi Avanti**
1. Per **il nome della politica***DetectSentimentPolicy*, inserisci, quindi **Crea politica**.
Se esamini la politica, vedrai che consente a tutte le risorse di intraprendere l'**azione**`"comprehend:DetectSentiment"`.
**Per collegare il ruolo IAM alla macchina a stati Step Functions**
1. Torna a modificare la tua macchina a stati e seleziona la **scheda Config.**
1. Dal menu a discesa **Ruolo di esecuzione**, scegli. *HelloWorldWorkflowRole*
1. Salva la tua macchina a stati.
### Passaggio 4.4 - Esegui la tua macchina a stati
Inizia a eseguire la tua macchina a stati con il seguente codice JSON come input:
```
{
"hello_world": false,
"wait": 42,
"feedback_comment" : "This getting started with Step Functions workshop is a challenge!"
}
```
#### Risoluzione di un errore di autorizzazione...
Senza la politica corretta, riceverai un **errore di autorizzazione** simile al seguente:
```
User: arn:aws:sts::account-id:assumed-role/StepFunctions-MyStateMachine-role is not authorized
to perform: comprehend:DetectSentiment because no identity-based policy allows the comprehend:DetectSentiment
action (Service: Comprehend, Status Code: 400, Request ID: a1b2c3d4-5678-90ab-cdef-EXAMPLE11111)
```
Il messaggio di errore precedente indica che la macchina a stati non è autorizzata a utilizzare il servizio esterno. Torna indietro di un passaggio e assicurati di aver configurato una politica di identità.
**Metti in pratica ciò che hai imparato\$1**
Prima di immergerti in flussi di lavoro più complessi, metti in pratica ciò che hai imparato con le seguenti attività:
+ Rivedi il **DetectSentiment**passaggio. Dai un'occhiata alle input/output varie visualizzazioni per vedere i risultati del rilevamento del sentiment.
+ Trova la **durata** dello DetectSentiment stato nella visualizzazione della tabella.
+ Modifica il commento nell'**input JSON**, quindi riesegui la macchina a stati.
Per ulteriori informazioni sui risultati dell'analisi del sentiment, consulta [Amazon Comprehend](https://docs.aws.amazon.com/comprehend/latest/dg/how-sentiment.html) - Sentiment.
Un modo di pensare all'integrazione con Request Response è che la risposta in genere rappresenta solo un *riconoscimento* della richiesta. *Tuttavia, in alcune integrazioni, come l'analisi del sentiment, il riconoscimento rappresenta in realtà il completamento dell'attività.*
L'apprendimento fondamentale è che `Task` lo stato **non aspetta** il job sottostante nelle integrazioni Request Response. Per attendere una risposta, dovrai esplorare il modello di integrazione del servizio *Run a Job (.sync)*.
**Complimenti\$1**
Hai creato la tua prima macchina a stati e integrato un'attività di analisi del sentiment utilizzando il pattern **Request Response**.
**Apprezziamo il tuo feedback\$1**
Se hai trovato utile questo tutorial introduttivo o hai suggerimenti per migliorarlo, faccelo sapere utilizzando le opzioni di feedback disponibili in questa pagina.
## Eseguire la pulizia delle risorse
Segui i passaggi seguenti per ripulire le risorse che hai creato:
1. Vai alla pagina [Step Functions](https://console.aws.amazon.com/states/home) nella AWS console.
1. Seleziona **Macchine a stati** dal riquadro di navigazione a sinistra.
1. Seleziona **MyFirstStateMachine**
1. Per eliminare i ruoli IAM
1 - Segui il link relativo al **ruolo IAM** per accedere alla pagina del ruolo IAM in una nuova scheda. Elimina il ruolo correlato personalizzato.
2 - In IAM Roles, cerca il ruolo generato automaticamente contenente*MyFirstStateMachine*. Eliminare il ruolo generato automaticamente.
1. Torna alla scheda della console Step Functions e seleziona il menu a discesa **Azioni**, quindi seleziona **Elimina** per eliminare la macchina a stati.
La tua macchina a stati e il ruolo correlato dovrebbero ora essere eliminati con successo.