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
Le service Step Functions vous permet d'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 glisser-déposer une intégration de 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 à l'aide des ** modes ** Conception ** 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. Après avoir appris à exécuter le flux de travail, vous allez ajouter 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 créer. Lorsque vous créez la machine d'état Hello World pour la première fois, elle n'a 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 du service, vous devrez créer un rôle avec une politique d'autorisation personnalisée.
## É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 la barre de navigation en haut à gauche, ou dans le fil de navigation, puis choisissez ** Commencer ** :
1. Dans les options, choisissez ** Run Hello World ** :
**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 pour Step Functions, vous pouvez faire glisser et déposer visuellement des états 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.
**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 glisser-déposer des états dans votre flux de travail.
+ **Code ** : mode qui se concentre 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 la conception visuelle.
+ **Configuration ** : 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, la gestion des versions, le chiffrement et les balises.
****Le navigateur States contient les trois onglets suivants :
+ **Actions ** : liste d' AWS API que vous pouvez glisser-déposer dans votre flux de travail. Chaque action représente l'é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 et prêts à l'emploi, tels que le traitement itératif des données dans un compartiment Amazon S3.
**Le diagramme ** de canevas et de flux de travail vous permet de glisser-déposer des é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 de ** l'inspecteur vous permet de visualiser et de modifier les propriétés de tout é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 création 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 en ** mode attente**, puis exécute deux tâches en mode ** 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 ** Échec ** avant d'arrêter la machine à états.
Les états d'attente peuvent être utiles lorsque vous souhaitez attendre avant d'effectuer d'autres tâches. 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 ventes quotidien.
### Afficher le code du flux de travail (ASL)
Votre première machine à états est en fait assez détaillée, alors explorez plus en détail en passant en revue 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 JSON-based langage 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 ** {} Code pour afficher le code ASL.
1. Affichez le code sur la gauche et comparez-le avec le graphique de la machine à états sur la droite.
1. Sélectionnez certains états sur le canevas pour les consulter. Par exemple, sélectionnez l'état ** Choice**.
Avez-vous remarqué comment la définition de l'État est mise en évidence dans la vue du code ?
**Pour afficher le code dans l'inspecteur **
1. Revenez en ** mode ** Design.
1. Développez le panneau ** Inspecteur ** sur la droite.
1. Sélectionnez l'état ** Choice dans le graphique ** du flux de travail sur le canevas.
1. Dans le ** panneau ** Inspecteur, cliquez sur 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
**Attention : donnez un nom à votre machine d'état dès maintenant \!**
Vous ** ne pouvez pas renommer ** une machine d'état après l'avoir créée. Choisissez un nom ** avant de sauvegarder ** votre machine d'état.
Jusqu'à présent, vous travailliez sur une ébauche de votre machine à État. Aucune ressource n'a encore été créée.
**Pour renommer et créer votre machine à états **
1. Choisissez le mode ** Configuration**.
1. Pour indiquer le nom de la machine, 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 voir des notifications indiquant que votre machine d'état et un nouveau rôle IAM ont été créés.
L'option permettant de démarrer la machine d'état vous sera automatiquement présentée. C'est ce que vous ferez à l'étape suivante \!
**Création de flux de travail terminée \!**
Step Functions a créé votre flux de travail et votre rôle IAM. Vous êtes maintenant prêt à démarrer votre machine à états.
## Étape 2 - Démarrez votre machine à états
Une fois que votre machine à états a été créée, vous pouvez démarrer votre flux de travail.
Les flux de travail prennent éventuellement des ** entrées ** qui peuvent être utilisées dans l'état, envoyées aux services intégrés et passées à l'état suivant.
La machine ** d'état ** Hello World est autonome et ne nécessite aucune saisie.
**Pour démarrer la machine d'état **
1. Entrez `hello001` le nom de l'exécution.
1. Laissez le champ de saisie * vide*.
1. Cliquez sur le ** bouton ** Lancer l'exécution.
### 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 ont ** réussi**.
Après une courte attente, les autres transitions d'état s'exécuteront pour terminer le flux de travail.
Vous vous demandez comment se * trouve 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 branche
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 de ** passe ** (nommé * Set Variables and State Output*), puis passez en revue l'**Input/Output**onglet.
Vous devriez voir que ** l'entrée State ** est vide, mais que la sortie ** State ** contient du JSON qui définit la valeur `IsHelloWorldExample` sur`true`.
Passez de la vue ** graphique ** à la vue ** Tableau ** pour afficher la liste des états par nom, type et statut.
**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.
Il existe deux autres vues à explorer sur cette page des détails des exécutions : la vue des ** événements ** et la vue de ** l'état**.
La vue des ** événements ** est une vue granulaire détaillée du flux d'un état à l'autre.
Développez le premier ** PassStateEntered ** et les ** PassStateExited ** ** événements du ** tableau Event View pour voir comment l'état ne prend aucune entrée, attribue une variable appelée `CheckpointCount` valeur zéro et produit la sortie que vous avez vue précédemment.
Enfin, vous avez la vue ** État ** qui est similaire à la vue ** Tableau**. 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 les sorties de chaque état :
**Félicitations \! Vous avez lancé votre première machine à états Step Functions \!**
L'utilisation d'un état Pass pour ajouter des données ** statiques ** dans un flux de travail est un modèle courant, en particulier pour le dépannage.
À l'étape suivante, vous allez mettre à jour le flux de travail afin de pouvoir * définir * dynamiquement l'entrée 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 à différentes données d'entrée.
Dans cette étape, nous allons vous montrer comment les données JSON externes peuvent être utilisées comme entrées dans votre flux de travail :
### Supprimer l'entrée codée en dur
Tout d'abord, remplacez la valeur codée en dur dans la ** sortie ** du premier état Pass.
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 de ** passe ** après le ** démarrage ** (nommé * Set Variables and State Output*), puis sélectionnez l'**onglet ** Output.
1. Remplacez la ** sortie ** par le 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 **](transforming-data.md#transforming-reserved-variable-states) $states réservée à l'aide d'une expression JSonata. Ces valeurs seront transmises à l'état suivant en tant que sortie pour devenir l'entrée de l'état suivant.
### Exécutez 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 ** Lancer l'exécution.
L'exécution de votre machine d'état devrait attendre beaucoup plus longtemps (20 secondes), mais elle devrait finalement réussir en utilisant l'entrée que vous avez fournie.
Dans la vue graphique, vérifiez ** Input/Output ** le premier état du pass. Remarquez comment les entrées que vous avez fournies ont été converties en sorties. Consultez également les entrées et sorties d'**exécution ** sur la page des détails de l'exécution. Les deux emplacements indiquent 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\_world * défini sur false ? ** ** À vous d'essayer \!
### 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 des exécutions, similaire à la capture d'écran suivante :
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 abrégé (`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 \!** 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 ](https://docs.aws.amazon.com/step-functions/latest/dg/supported-services-awssdk.html)AWS SDK. AWS les 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.
**Important**
L'`DetectSentiment`API Amazon Comprehend utilisée dans ce didacticiel n'est pas disponible dans tous Régions AWS. Pour terminer ce didacticiel, utilisez une région dans laquelle Amazon Comprehend est disponible, telle que USA Est (Virginie du Nord)`us-east-1`. Pour obtenir la liste complète des régions prises en charge, consultez la section Points de terminaison et quotas [ Amazon Comprehend ](https://docs.aws.amazon.com/general/latest/gr/comprehend.html) dans le.
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. **Attendre le rappel ** (*.wait ForTaskToken*) : interrompt un flux de travail jusqu'à ce qu'un jeton de tâche soit renvoyé par un processus externe.
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 effectue généralement son travail en transmettant des données d'entrée aux actions d'API d'autres services, qui effectuent ensuite leur propre travail. Vous pouvez spécifier le mode d'exécution d'une tâche à l'aide d'un certain nombre de champs`Credentials`, notamment :`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' AWS API dans le ** champ ** Ressource 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), mais * ParameterNames * en Pascal (initiale en majuscule).
**Exemples de noms de ressources **
+ `arn:aws:states:::aws-sdk:ec2:describeInstances`renverra les résultats de l'appel à l'API Amazon EC2 DescribeInstances.
+ `arn:aws:states:::aws-sdk:s3:listBuckets`renverra les résultats de l'appel à l'API Amazon S3 ListBuckets.
+ `arn:aws:states:::aws-sdk:sfn:startExecution`lancera l'exécution d'une machine à états Step Functions imbriquée et renverra les résultats de ce flux de travail.
Lorsque Step Functions appelle un autre service en utilisant l'`Task`é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). Grâce au modèle ** d'intégration ** Request Response, Step Functions appelle un service, reçoit une réponse et * ** passe ** * immédiatement à l'état suivant.
### Étape 4.1 - Ajouter un état d'analyse des sentiments
1. **Modifiez ** votre machine à ** MyFirstStateMachine ** états.
1. Dans le ** panneau ** Actions du navigateur ** États**, recherchez`DetectSentiment`.
1. Faites glisser ** Comprehend et déposez Comprehend DetectSentiment ** sur la ** branche ** par défaut de l'état ** ** Choice.
1. Sélectionnez et supprimez l'**état d'**échec.
1. **Dans l'onglet ** Flow du navigateur ** États**, faites glisser l'**état ** Success après ** DetectSentiment**.
### Étape 4.2 - Configurer l'état de l'analyse des sentiments
1. Sélectionnez l'**étape ** Comprendre pour la configurer dans le panneau Inspecteur.
1. Sélectionnez l'**onglet ** Arguments et sortie, puis remplacez les ** arguments ** par le code JSON suivant :
```
{
"LanguageCode": "en",
"Text": "{% %}"
}
```
1. Placez votre curseur ** entre ** les signes de pourcentage : `{% %}` et tapez : `$`
1. Utilisez la ** saisie semi-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 semi-automatique, vous devriez disposer du JSON suivant pour vos ** arguments ** d'état :
```
{
"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.
Auto-complete listera vos variables, la [** variable **](transforming-data.md#transforming-reserved-variable-states) $states réservée qui contient l'objet de contexte et les fonctions disponibles avec leurs définitions \!
### É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, ** choisissez{{AWS Service}}.
1. Pour le cas ** d'utilisation, ** choisissez{{Step Functions}}.
1. Pour ** Ajouter des autorisations, ** cliquez ** sur ** 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 le ** champ Nom de la politique{{DetectSentimentPolicy}}, ** saisissez, puis ** Créer une politique**.
Si vous examinez la politique, vous verrez qu'elle autorise toutes les ressources à prendre l'**action **`"comprehend:DetectSentiment"`.
**Pour associer le rôle IAM à la machine d'état Step Functions **
1. Revenez à la modification de votre machine à états et sélectionnez l'**onglet ** Configuration.
1. Dans la ** liste déroulante Rôle ** d'exécution, choisissez{{HelloWorldWorkflowRole}}.
1. Enregistrez votre machine à états.
### Étape 4.4 - Exécutez votre machine à états
Commencez à exécuter votre machine d'état avec le JSON suivant pour la saisie :
```
{
"hello_world": false,
"wait": 42,
"feedback_comment" : "This getting started with Step Functions workshop is a challenge!"
}
```
#### Résolution d'une erreur d'autorisation...
Sans la politique appropriée, vous recevrez une erreur d'**autorisation**, similaire à la suivante :
```
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 en arrière et assurez-vous d'avoir configuré une politique d'identité.
**Mettez en pratique ce que vous avez appris \! **
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 tabulaire.
+ Modifiez le commentaire dans l'entrée ** JSON**, puis relancez votre machine d'état.
Pour en savoir plus sur les résultats de l'analyse des sentiments, consultez [ Amazon Comprehend - Sentiment](https://docs.aws.amazon.com/comprehend/latest/dg/how-sentiment.html).
Une façon de penser à l'intégration de Request Response 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'enseignement 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 \!**
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 \!**
Si vous avez trouvé ce didacticiel de démarrage 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 ;
Procédez comme suit pour nettoyer les ressources que vous avez créées :
1. Accédez à la [ page ](https://console.aws.amazon.com/states/home) Step Functions de 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. Revenez à l'onglet de la console Step Functions et sélectionnez le ** menu déroulant ** Actions, puis sélectionnez ** Supprimer ** pour supprimer la machine à états.
Votre machine à états et le rôle associé devraient maintenant être supprimés avec succès.