Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Découvrez comment démarrer avec Step Functions
Avec le service Step Functions, vous pouvez orchestrer des flux de travail applicatifs complexes. Pour commencer, vous allez utiliser Workflow Studio pour créer et exécuter un flux de travail **Hello World** intégré. Vous allez passer en revue la définition générée automatiquement [Amazon States Language](concepts-amazon-states-language.md) (ASL) dans le code. Enfin, vous allez intégrer drag-and-drop un service pour effectuer une analyse des sentiments.
Après avoir terminé ce didacticiel, vous saurez comment utiliser Workflow Studio pour créer, configurer, exécuter et mettre à jour un flux de travail en utilisant à la fois les modes **Design** et **Code**.
Durée estimée : **20-30 minutes**
## Ce que vous allez construire
Votre première machine à états démarrera avec les *états de flux*. Les états de flux sont utilisés pour diriger et contrôler votre flux de travail. Une fois que vous aurez appris à exécuter le flux de travail, vous ajouterez une **action** pour intégrer le service Amazon Comprehend à un état de **tâche**.
Le schéma suivant montre un visuel de la machine à états complète que vous allez construire. Lorsque vous créez la machine d'état Hello World pour la première fois, elle n'aura pas besoin de ressources supplémentaires pour fonctionner. La console Step Functions créera tous les états et un rôle IAM en un seul clic. Plus tard, lorsque vous ajouterez l'intégration de services, vous devrez créer un rôle avec une politique d'autorisation personnalisée.
![\[Représentation visuelle du flux de travail Hello World.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/hello-world-arch.png)
## Étape 1 - Créez votre machine à états
Dans Step Functions, *les flux de travail* sont appelés **machines à états**. Nous utiliserons les deux termes de manière interchangeable. Vos flux de travail contiendront des *états* qui **prennent des mesures** ou **contrôlent le flux** de vos machines à états.
1. Accédez à la **console Step Functions.**
1. Dans la console Step Functions, choisissez « **Step Functions** » dans le menu de navigation en haut à gauche, ou choisissez le fil d'Ariane, puis choisissez **Get** started :
![\[Capture d'écran illustrant comment démarrer avec le flux de travail Hello World\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/get-started-hello-world.png)
1. Dans les options, choisissez **Run Hello World** :
![\[Capture d'écran illustrant comment choisir le flux de travail Hello World\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/create-hello-world.png)
**Astuce**
Nous vous recommandons de suivre la courte procédure intégrée à la console pour vous familiariser avec l'interface utilisateur.
### Présentation de Workflow Studio
Avec Workflow Studio for Step Functions, vous pouvez afficher des drag-and-drop états visuels sur un canevas pour créer des flux de travail.
Vous pouvez ajouter et modifier des états, configurer des étapes, transformer les résultats et configurer la gestion des erreurs. La capture d'écran suivante montre quatre zones importantes de l'interface que vous utiliserez pour créer vos machines d'état.
![\[Capture d'écran illustrative des quatre zones importantes de l'interface Workflow Studio\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/wfs-panel-overview.png)
**Modes** - Workflow Studio propose trois modes de fonctionnement et utilise par défaut le mode de conception visuelle.
+ **Design** : mode d'édition visuelle, dans lequel vous pouvez intégrer drag-and-drop des états à votre flux de travail.
+ **Code** : mode centré sur le code Amazon States Language, également appelé code ASL. Vous pouvez modifier le code ASL directement et voir les modifications reflétées dans le design visuel.
+ **Config** : options de configuration, notamment le nom et le type de la machine d'état (Standard ou Express), le rôle attribué lors de l'exécution du flux de travail, la journalisation, le suivi, le versionnement, le chiffrement et les balises.
Le **navigateur States** contient les trois onglets suivants :
+ **Actions** : liste des actions AWS APIs que vous pouvez drag-and-drop intégrer à votre flux de travail. Chaque action représente un état du flux de travail des tâches.
+ **Flux** : états de flux permettant de contrôler l'ordre des étapes de votre flux de travail.
+ **Modèles** : éléments de base réutilisables ready-to-use, tels que le traitement itératif des données dans un compartiment Amazon S3.
Le **canevas et le graphe de flux** de travail vous permettent d'afficher drag-and-drop les états sur votre graphique de flux de travail, de modifier l'ordre des états et de sélectionner les états à configurer et à tester.
**Le panneau Inspector** permet d'afficher et de modifier les propriétés de n'importe quel état sélectionné sur le canevas. Vous pouvez activer le bouton *Définition* pour afficher le code correspondant à l'état actuellement sélectionné.
### Vue d'ensemble de la machine à états
Le flux de travail Hello World commence par un **état Pass** qui *transmet* son entrée à sa sortie, sans effectuer de travail. Les états de passe peuvent être utilisés pour générer une sortie JSON statique ou transformer une entrée JSON avant de passer les données à l'état suivant. Les états de passe sont utiles lors de la construction et du débogage de machines à états.
L'état suivant, un **état Choice**, utilise les données saisies `IsHelloWorldExample` pour choisir la branche suivante du flux de travail. Si la première règle correspond, le flux de travail s'arrête dans un **état d'attente**, puis exécute deux tâches dans un **état parallèle**, avant de passer à un point de contrôle et de terminer le flux de travail avec succès. En l'absence de correspondance, le flux de travail passe par défaut à l'**état Fail avant d'**arrêter la machine à états.
Les états d'attente peuvent être utiles lorsque vous souhaitez attendre avant d'effectuer davantage de travail. Votre flux de travail attendra peut-être 30 secondes après la saisie d'une commande, afin que votre client ait le temps de remarquer et de corriger une adresse de livraison incorrecte.
Les états parallèles peuvent exécuter plusieurs processus sur vos données. Peut-être que le flux de travail imprimera un bon de commande, mettra à jour l'inventaire et augmentera simultanément un rapport de vente quotidien.
![\[Image illustrant le processus de démarrage de Hello World\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/workflow-1-hello-world.png)
### Afficher le code du flux de travail (ASL)
Votre première machine à états est en fait assez détaillée, alors poursuivez votre exploration en consultant le code.
Les machines à [états sont définies à l'aide d'Amazon States Language (ASL)](https://states-language.net/), une spécification open source qui décrit un langage basé sur le langage JSON pour décrire les machines à états de manière déclarative.
**Pour afficher la définition complète de la machine à états**
1. Cliquez sur le bouton **\$1\$1 Code** pour afficher le code ASL.
1. Consultez le code sur la gauche et comparez-le avec le graphique de la machine à états sur la droite.
1. Sélectionnez certains états à examiner sur le canevas. Par exemple, sélectionnez l'**état Choice**.
![\[Image illustrative de la vue du code\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/hello-code-view.png)
Avez-vous remarqué que la définition de l'État est mise en évidence dans la vue du code ?
**Pour afficher le code dans l'Inspector**
1. Revenez en mode **Design**.
1. Développez le **panneau Inspector** sur la droite.
1. Sélectionnez l'**état Choice dans** le graphique du flux de travail sur le canevas.
1. Dans le panneau **Inspector**, sélectionnez le bouton **Définition**.
Essayez de choisir d'autres états. Vous voyez comment le code ASL de chaque État que vous sélectionnez est affiché et surligné ?
### (En fait) Créez la machine à états
**Avertissement : donnez un nom à votre machine d'état dès maintenant \$1**
Vous **ne pouvez pas renommer** une machine à états après l'avoir créée. Choisissez un nom **avant** de sauvegarder votre machine d'état.
Jusqu'à présent, vous avez travaillé sur une ébauche de votre machine d'État. Aucune ressource n'a encore été créée.
**Pour renommer et créer votre machine à états**
1. Choisissez le **mode Config**.
1. Pour le nom de la machine à états, entrez `MyFirstStateMachine`
1. Pour les autorisations, acceptez la valeur par défaut « *Créer un nouveau rôle* ».
1. Cliquez sur le bouton **Créer** pour créer **réellement** votre machine à états.
Vous devriez recevoir des notifications indiquant que votre machine d'état et un nouveau rôle IAM ont été créés.
Vous aurez automatiquement la possibilité de démarrer la machine à états. C'est ce que vous ferez à l'étape suivante \$1
![\[Image illustrant le processus de démarrage de Hello World\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/workflow-created.png)
**Création du flux de travail terminée \$1**
Step Functions a créé votre flux de travail et votre rôle IAM. Maintenant, vous êtes prêt à démarrer votre machine d'État.
## Étape 2 - Démarrez votre machine à états
Une fois que votre machine d'état a été créée, vous pouvez démarrer votre flux de travail.
Les flux de travail utilisent éventuellement des **entrées** qui peuvent être utilisées dans l'état, envoyées aux services intégrés et transmises à l'état suivant.
La machine à états **Hello World** est autonome et ne nécessite aucune saisie.
![\[Image illustrative du démarrage\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/start_283486381.jpg)
**Pour démarrer la machine à états**
1. Entrez `hello001` le nom de l'exécution.
1. Laissez le champ de saisie *vide*.
1. Cliquez sur le bouton **Démarrer l'exécution**.
![\[Image illustrative pour démarrer un flux de travail.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/hello001.png)
### Passez en revue les détails de l'exécution
Immédiatement après le démarrage, vous devriez voir que les deux premiers états sont **réussis**.
Après une courte attente, les autres transitions d'état seront exécutées pour terminer le flux de travail.
Vous demandez-vous comment fonctionne l'**état Choice** (Is *Hello World Example) ?* ) a décidé de passer à l'état **Wait for X Seconds** ?
1. Conseil : la première étape de la machine à états contient les données nécessaires à la décision de la succursale
1. Dans la **vue graphique**, vous pouvez suivre la progression pendant l'exécution et explorer les détails de chaque état.
1. Sélectionnez le premier **état Passage** (nommé *Set Variables and State Output*), puis passez en revue l'onglet **Entrée/Sortie**.
Vous devriez voir que **l'entrée State** est vide, mais que la **sortie State** contient du JSON qui définit la valeur de `IsHelloWorldExample` to`true`.
![\[Exécution 001\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/hello001-graph-view.png)
Passez de la **vue graphique** à la **vue Tableau** pour voir une liste des états par nom, type et statut.
![\[Vue du tableau Execution 001\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/hello001-table.png)
**Astuce**
Prenez note des champs **Durée** et **Chronologie** de la capture d'écran précédente. En un coup d'œil, vous pouvez voir quels États prennent plus de temps que d'autres.
Vous pouvez explorer deux autres vues sur cette page de détails des exécutions : la vue des **événements et la vue** de **l'état**.
La **vue Evénements** est une vue détaillée détaillée du flux d'un état à l'autre.
Développez le premier **PassStateEntered**et les **PassStateExited****événements du tableau d'affichage** des événements pour voir comment l'état n'accepte aucune entrée, assigne une variable appelée `CheckpointCount` valeur zéro et produit le résultat que vous avez vu précédemment.
![\[Vue des événements Execution 001\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/hello001-event-view.png)
Enfin, vous avez la **vue State** qui est similaire à la **vue Table**. Dans le tableau **d'affichage** des états, vous pouvez développer **les états** de manière sélective pour afficher uniquement les entrées et sorties de chaque état :
![\[Vue de l'état d'exécution 001\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/hello001-state-view.png)
**Félicitations \$1 Vous avez lancé votre première machine d'état Step Functions \$1**
L'utilisation d'un état Pass pour ajouter **des données statiques** dans un flux de travail est une pratique courante, en particulier pour le dépannage.
À l'étape suivante, vous allez mettre à jour le flux de travail afin de pouvoir définir de *manière dynamique* les entrées de votre machine à états.
## Étape 3 - Traiter les entrées externes
Il n'est pas réaliste de `IsHelloWorldExample` définir la valeur de sur une valeur constante dans le flux de travail. Vous devez vous attendre à ce que votre machine à états réponde à des données d'entrée variables.
Dans cette étape, nous allons vous montrer comment les données JSON externes peuvent être utilisées comme entrée dans votre flux de travail :
![\[Entrée externe du processus\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/process-external-input.png)
### Supprimer l'entrée codée en dur
Tout d'abord, remplacez la valeur codée en dur dans l'état de **sortie** du premier passage.
1. Modifiez votre machine à états Hello World en sélectionnant le bouton **Modifier la machine à états** situé en haut à droite de la page.
1. Sélectionnez le premier **état Pass** après **Start** (nommé *Set Variables and State Output*), puis sélectionnez l'onglet **Output**.
1. Remplacez la **sortie** par le code JSON suivant :
```
{
"IsHelloWorldExample": "{% $states.input.hello_world %}",
"ExecutionWaitTimeInSeconds": "{% $states.input.wait %}"
}
```
1. Enregistrez la machine d'état.
La sortie d'état mise à jour extraira les données d'entrée de la variable réservée **[\$1states](transforming-data.md#transforming-reserved-variable-states)** à l'aide d'une JSONata expression. Ces valeurs seront transmises à l'état suivant en sortie pour devenir l'entrée de l'état suivant.
### Exécuter le flux de travail mis à jour, avec les données d'entrée
Ensuite, exécutez le flux de travail et fournissez des données d'entrée externes au format JSON.
1. Cliquez sur le bouton **Exécuter** pour exécuter le flux de travail.
1. Pour le **nom**, utilisez l'identifiant généré de manière aléatoire.
1. Utilisez le code JSON suivant pour le champ de saisie :
```
{
"wait" : 20,
"hello_world": true
}
```
1. Cliquez sur le bouton **Démarrer l'exécution**.
L'exécution de votre machine à états devrait attendre beaucoup plus longtemps (20 secondes), mais elle devrait finalement réussir en utilisant les entrées que vous avez fournies.
Dans la vue graphique, passez en revue les **entrées/sorties** du premier état de passe. Remarquez comment les entrées que vous avez fournies ont été converties en sorties. Jetez également un œil aux **entrées et sorties d'exécution** en haut de la page des détails de l'exécution. Les deux emplacements affichent l'entrée que vous avez utilisée pour démarrer l'exécution.
**Astuce**
**À quoi vous attendez-vous si vous exécutez une nouvelle exécution avec *hello\$1world défini sur false* ?** À vous d'essayer \$1
### Vérifiez les exécutions des flux de travail
Maintenant que vous avez exécuté votre flux de travail à quelques reprises, passez en revue les détails d'exécution pour passer en revue les exécutions de votre flux de travail.
**Pour consulter les détails de l'exécution**
1. Choisissez **State machines** dans le fil de navigation ou dans le menu de gauche.
1. Choisissez votre machine à états.
Dans l'onglet **Exécutions**, vous devriez voir une liste d'exécutions, similaire à la capture d'écran suivante :
![\[Capture d'écran illustrative présentant une liste d'exemples d'exécutions de Hello Workflow.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/hello-executions.png)
Une dernière remarque : les noms d'exécution des flux de travail doivent être uniques et **ne peuvent pas** être réutilisés. Bien que nous ayons suggéré un nom court (`hello001`) dans ce didacticiel, nous vous recommandons d'utiliser une convention de dénomination qui sera toujours unique pour vos charges de travail de production.
**Astuce**
**Félicitations \$1** Vous avez modifié votre flux de travail pour traiter les *entrées externes* qui peuvent varier à chaque fois que vous exécutez votre flux de travail.
## Étape 4 - Intégrer un service
Les machines d'état Step Functions peuvent appeler plus de 220 AWS services à l'aide des [intégrations du AWS SDK](https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html). AWSles services fournissent plus de 10 000 actions d'API potentielles pour vos machines d'état.
Au cours de cette étape, vous allez intégrer une tâche Amazon Comprehend pour l'**analyse des sentiments** afin de traiter les entrées de votre machine à états.
Les intégrations de services utilisent l'un des trois *modèles d'intégration de services suivants* :
1. **Demander une réponse** (par défaut) : attendez la réponse HTTP, puis passez *immédiatement* à l'état suivant.
1. **Exécuter une tâche** (*.sync*) : attendez qu'une tâche soit terminée avant de passer à l'étape suivante.
1. **Attendez le rappel** *(. waitForTaskJeton*) : interrompt un flux de travail jusqu'à ce qu'un jeton de tâche soit renvoyé par un processus externe.
![\[Capture d'écran illustrant une intégration de services.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/AdobeStock_513621530_integration_1000.jpg)
Pour votre première intégration, vous utiliserez le modèle d'intégration **Request Response** (par défaut).
### Comment fonctionnent les intégrations ?
Un *état de tâche* représente une unité de travail unique exécutée par une machine à états. Tout le travail au sein de votre machine d'état est effectué par des tâches.
Une tâche exécute généralement un travail en transmettant des données aux actions d'API d'autres services qui exécutent ensuite leur propre travail. Vous pouvez définir le mode d'exécution d'une tâche en utilisant un certain nombre de champs, notamment :`Credentials`,`Retry`,`Catch`,`TimeoutSeconds`, et plus encore. Vous pouvez en savoir plus sur les tâches dans[État du flux de travail des tâches](state-task.md).
Pour utiliser les intégrations du AWS SDK, vous devez spécifier le **nom du service** et l'**API à appeler**. Certaines intégrations nécessitent également des paramètres.
Vous pouvez utiliser Amazon States Language pour spécifier une action d'AWSAPI dans le champ **Resource** d'un état de tâche. Vous pouvez éventuellement ajouter un type d'intégration de service au nom du service.
Pour spécifier une action d'API, vous allez utiliser le modèle de nom de ressource suivant :
```
arn:aws:states:::aws-sdk:serviceName:apiAction.[serviceIntegrationPattern]
```
**Nom du paramètre (case)**
Notez que les actions de l'API seront en *CamelCase* (initiale en minuscule), *ParameterNames*mais en Pascal (initiale en majuscules).
**Exemples de noms de ressources**
+ `arn:aws:states:::aws-sdk:ec2:describeInstances`renverra les résultats de l'appel de l'API Amazon EC2 DescribeInstances.
+ `arn:aws:states:::aws-sdk:s3:listBuckets`renverra les résultats de l'appel de l'API Amazon S3 ListBuckets.
+ `arn:aws:states:::aws-sdk:sfn:startExecution`lancera l'exécution d'une machine d'état Step Functions imbriquée et renverra les résultats de ce flux de travail.
Lorsque Step Functions appelle un autre service en utilisant `Task` cet état, le modèle par défaut est [Request Response](https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default). Avec le modèle d'intégration **Request Response**, Step Functions appelle un service, reçoit une réponse et passe ***immédiatement*** à l'état suivant.
![\[Intégration de la détection des sentiments\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/integrate_sentiment_592194331.png)
### Étape 4.1 - Ajouter un état d'analyse des sentiments
1. **Modifiez** votre machine à **MyFirstStateMachine**états.
1. Dans le panneau **Actions** du **navigateur States**, recherchez`DetectSentiment`.
1. Glissez et déposez **Comprehend DetectSentiment** sur la branche **Default** de l'état **Choice**.
1. Sélectionnez et supprimez l'état **Fail**.
1. Dans l'**onglet Flow** du **navigateur States**, faites ensuite glisser l'état **Success **DetectSentiment****.
### Étape 4.2 - Configuration de l'état de l'analyse des sentiments
1. Sélectionnez l'étape **Comprehend** pour la configurer dans le panneau Inspector.
1. Sélectionnez l'onglet **Arguments et sortie**, puis remplacez les **arguments** par le JSON suivant :
```
{
"LanguageCode": "en",
"Text": "{% %}"
}
```
1. Placez votre curseur **entre les** signes de pourcentage : `{% %}` et tapez : `$`
1. Utilisez la **saisie automatique** dans l'éditeur pour choisir`states`,
puis tapez `.` et choisissez`context`,
puis tapez `.` et choisissez`Execution`,
puis tapez `.` et choisissez`Input`,
enfin, tapez `.feedback_comment` pour récupérer l'entrée initiale de l'**objet de contexte**.
Après avoir choisi ces options de saisie automatique, vous devriez avoir le JSON suivant pour les **arguments** de vos états :
```
{
"LanguageCode": "en",
"Text": "{% $states.context.Execution.Input.feedback_comment %}"
}
```
**Utilisation de la saisie automatique de l'éditeur**
Grâce à la saisie automatique de l'éditeur, vous pouvez explorer les options qui s'offrent à vous.
La saisie automatique listera vos variables, la variable réservée **[\$1states](transforming-data.md#transforming-reserved-variable-states)** qui contient l'objet de contexte et les fonctions disponibles avec leurs définitions \$1
### Étape 4.3 - Configuration d'une politique d'identité
Avant de pouvoir exécuter le flux de travail, vous devez créer un **rôle** et une **politique** permettant à la machine d'état d'effectuer des appels d'API vers le service externe.
**Pour créer un rôle IAM pour Step Functions**
1. Accédez à la console IAM dans un nouvel onglet et sélectionnez **Rôles**.
1. Choisissez **Créer un rôle**.
1. Pour **Type d'entité de confiance**, sélectionnez*AWSService*.
1. Pour le **cas d'utilisation**, sélectionnez*Step Functions*.
1. Pour **Ajouter des autorisations**, choisissez **Suivant** pour accepter la politique par défaut. Vous ajouterez une politique pour Comprehend après avoir créé le rôle.
1. Pour **Nom**, saisissez *HelloWorldWorkflowRole*.
1. Choisissez **Créer un rôle**.
**Pour ajouter une politique au **HelloWorldWorkflowRole**pour Amazon Comprehend**
1. Sélectionnez et modifiez le **HelloWorldWorkflowRole**rôle.
1. Choisissez **Ajouter une autorisation**, puis **Créer une politique en ligne**.
1. Sélectionnez **Comprehend** pour le service.
1. Dans **Lire **DetectSentiment****, choisissez, puis **Suivant**
1. Dans **Nom de la politique***DetectSentimentPolicy*, entrez, puis **Créez une politique**.
Si vous consultez la politique, vous verrez qu'elle autorise toutes les ressources à effectuer l'**action**`"comprehend:DetectSentiment"`.
**Pour associer le rôle IAM à la machine d'état Step Functions**
1. Retournez à l'édition de votre machine d'état et sélectionnez l'onglet **Config**.
1. Dans le menu déroulant **Rôle d'exécution**, sélectionnez*HelloWorldWorkflowRole*.
1. Sauvegardez votre machine d'État.
### Étape 4.4 - Exécutez votre machine d'état
Commencez à exécuter votre machine d'état en saisissant le code JSON suivant :
```
{
"hello_world": false,
"wait": 42,
"feedback_comment" : "This getting started with Step Functions workshop is a challenge!"
}
```
#### Résolution d'une erreur d'autorisation...
Si la politique n'est pas correcte, vous recevrez une **erreur d'autorisation** similaire à ce qui suit :
```
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)
```
Le message d'erreur précédent vous indique que votre machine d'état n'est pas autorisée à utiliser le service externe. Revenez d'une étape en arrière et assurez-vous d'avoir configuré une politique d'identité.
**Mettez en pratique ce que vous avez appris \$1**
Avant de vous lancer dans des flux de travail plus complexes, mettez en pratique ce que vous avez appris en effectuant les tâches suivantes :
+ Passez en revue l'**DetectSentiment**étape. Consultez les input/output différentes vues pour voir les résultats de la détection des sentiments.
+ Trouvez la **durée** de l' DetectSentiment état dans la vue du tableau.
+ Modifiez le commentaire dans l'**entrée JSON**, puis réexécutez votre machine d'état.
Pour en savoir plus sur les résultats de l'analyse des sentiments, consultez [Amazon Comprehend -](https://docs.aws.amazon.com/comprehend/latest/dg/how-sentiment.html) Sentiment.
Une façon de penser à l'intégration des réponses aux demandes est que la réponse ne représente généralement qu'un *accusé de réception* de la demande. Cependant, dans certaines intégrations, telles que l'analyse des sentiments, l'accusé de réception représente en fait l'*achèvement* de la tâche.
L'apprentissage clé est que l'`Task`État n'**attend pas** la tâche sous-jacente dans les intégrations Request Response. Pour attendre une réponse, vous devez explorer le modèle d'intégration du service *Run a Job (.sync)*.
**Félicitations \$1**
Vous avez créé votre première machine à états et intégré une tâche d'analyse des sentiments à l'aide du modèle **Request Response**.
**Vos commentaires sont importants pour nous \$1**
Si vous avez trouvé ce didacticiel de mise en route utile ou si vous avez des suggestions pour l'améliorer, faites-le nous savoir en utilisant les options de commentaires de cette page.
## nettoyer des ressources ;
Pour nettoyer les ressources que vous avez créées, procédez comme suit :
1. Accédez à la page [Step Functions](https://console.aws.amazon.com/states/home) dans la AWS console.
1. Sélectionnez **State machines** dans le volet de navigation de gauche.
1. Cliquez sur le bouton **MyFirstStateMachine**
1. Pour supprimer les rôles IAM
1 - Suivez le lien du **rôle IAM** pour accéder à la page du rôle IAM dans un nouvel onglet. Supprimez le rôle associé personnalisé.
2 - Dans IAM Roles, recherchez le rôle généré automatiquement contenant. *MyFirstStateMachine* Supprimez le rôle généré automatiquement.
1. Retournez dans l'onglet de votre console Step Functions et sélectionnez le menu déroulant **Actions**, puis sélectionnez **Supprimer** pour supprimer la machine à états.
Votre machine d'état et le rôle associé devraient maintenant être correctement supprimés.