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.
# Itérer une boucle avec une fonction Lambda dans Step Functions
Dans ce didacticiel, vous implémentez un modèle de conception qui utilise une machine d'état et une fonction AWS Lambda pour itérer une boucle un certain nombre de fois.
Utilisez ce modèle de conception chaque fois que vous avez besoin d'effectuer le suivi du nombre de boucles dans une machine d'état. Cette implémentation peut vous aider à diviser des tâches volumineuses ou des exécutions de longue durée en fragments plus petits, ou d'arrêter une exécution après un nombre spécifique d'événements. Vous pouvez utiliser une implémentation similaire pour arrêter et redémarrer périodiquement une exécution de longue durée afin d'éviter de dépasser les quotas de service pour AWS Step Functions AWS Lambda, ou pour d'autres AWS services.
Avant de commencer, suivez le [Création d'une machine d'état Step Functions utilisant Lambda](tutorial-creating-lambda-state-machine.md) didacticiel pour vous assurer que vous êtes familiarisé avec l'utilisation conjointe de Lambda et de Step Functions.
## Étape 1 : créer une fonction Lambda pour itérer un décompte
En utilisant une fonction Lambda, vous pouvez suivre le nombre d'itérations d'une boucle dans votre machine à états. La fonction Lambda suivante reçoit les valeurs d'entrée pour `count``index`, et. `step` Puis, elle retourne ces valeurs avec un `index` mis à jour et une valeur booléenne nommée `continue`. La fonction Lambda est définie `continue` sur `true` si le `index` est inférieur à. `count`
Votre machine d'état implémente alors un état `Choice` qui exécute une certaine logique d'application si `continue` a la valeur `true`, ou s'arrête si la valeur est `false`.
### Pour créer la fonction Lambda
1. Connectez-vous à la [console Lambda](https://console.aws.amazon.com/lambda/home), puis choisissez **Create** function.
1. Sur la page **Create function**, sélectionnez **Author from scratch**.
1. Dans la section **Informations de base**, configurez votre fonction Lambda comme suit :
1. Sous **Nom de la fonction**, saisissez `Iterator`.
1. Dans le champ **Runtime**, sélectionnez **Node.js**.
1. Dans **Modifier le rôle d'exécution par défaut**, choisissez **Créer un nouveau rôle avec des autorisations Lambda de base**.
1. Choisissez **Créer une fonction**.
1. Copiez le code suivant pour la fonction Lambda dans le **code** source.
```
export const handler = function (event, context, callback) {
let index = event.iterator.index
let step = event.iterator.step
let count = event.iterator.count
index = index + step
callback(null, {
index,
step,
count,
continue: index < count
})
}
```
Le code accepte les valeurs d'entrée pour `count`, `index` et `step`. Il incrémente `index` de la valeur de `step` et retourne ces valeurs, et la valeur booléenne `continue`. La valeur de `continue` est `true` si `index` est inférieur à `count`.
1. Choisissez **Déployer**.
## Étape 2 : tester la fonction Lambda
Exécutez votre fonction Lambda avec des valeurs numériques pour la voir fonctionner. Vous pouvez fournir des valeurs d'entrée pour votre fonction Lambda qui imitent une itération.
### Pour tester votre fonction Lambda
1. Sélectionnez **Tester)**.
1. Dans la boîte de dialogue **Configurer l'événement de test**, entrez le nom de l'**événement `TestIterator` dans la zone Nom** de l'événement.
1. Remplacez les données de l'exemple par les suivantes.
```
{
"Comment": "Test my Iterator function",
"iterator": {
"count": 10,
"index": 5,
"step": 1
}
}
```
Ces valeurs simulent ce qui provient de votre machine d'état au cours d'une itération. La fonction Lambda incrémente l'indice et renvoie `continue` lorsque `true` l'indice est inférieur à. `count` Pour ce test, l'index a déjà été incrémenté à `5`. Le test sera incrémenté `index` `6` et réglé sur`continue`. `true`
1. Choisissez **Créer**.
1. Choisissez **Test** pour tester votre fonction Lambda.
Les résultats du test sont affichés dans l'onglet **Résultats de l'exécution**.
1. Cliquez sur l'onglet **Résultats de l'exécution** pour voir le résultat.
```
{
"index": 6,
"step": 1,
"count": 10,
"continue": true
}
```
**Note**
Si vous réglez `index` `9` et testez à nouveau, les `index` incréments de `10` et `continue` seront`false`.
## Étape 3 : Création d'une machine d'état
**Avant de quitter la console Lambda...**
Copiez l'ARN de la fonction Lambda. Collez-le dans une note. Vous en aurez besoin à l’étape suivante.
Ensuite, vous allez créer une machine à états avec les états suivants :
+ `ConfigureCount`— Définit les valeurs par défaut pour `count``index`, et`step`.
+ `Iterator`— Fait référence à la fonction Lambda que vous avez créée précédemment, en transmettant les valeurs configurées dans. `ConfigureCount`
+ `IsCountReached`— Un état de choix qui continue la boucle ou passe à `Done` l'état, en fonction de la valeur renvoyée par votre `Iterator` fonction.
+ `ExampleWork`— Un talon pour les travaux à effectuer. Dans cet exemple, le flux de travail possède un `Pass` état, mais dans une solution réelle, vous utiliseriez probablement un`Task`.
+ `Done`— État final de votre flux de travail.
Pour créer la machine à états dans la console, procédez comme suit :
1. Ouvrez la [console Step Functions](https://console.aws.amazon.com/states/home), puis choisissez **Create a state machine**.
**Important**
Votre machine d'état doit se trouver dans le même AWS compte et dans la même région que votre fonction Lambda.
1. Sélectionnez le modèle **vide**.
1. Dans le volet **Code**, collez le code JSON suivant qui définit la machine à états.
Pour plus d'informations sur le langage Amazon States, consultez [State Machine Structure](statemachine-structure.md).
```
{
"Comment": "Iterator State Machine Example",
"StartAt": "ConfigureCount",
"States": {
"ConfigureCount": {
"Type": "Pass",
"Result": {
"count": 10,
"index": 0,
"step": 1
},
"ResultPath": "$.iterator",
"Next": "Iterator"
},
"Iterator": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:Iterate",
"ResultPath": "$.iterator",
"Next": "IsCountReached"
},
"IsCountReached": {
"Type": "Choice",
"Choices": [
{
"Variable": "$.iterator.continue",
"BooleanEquals": true,
"Next": "ExampleWork"
}
],
"Default": "Done"
},
"ExampleWork": {
"Comment": "Your application logic, to run a specific number of times",
"Type": "Pass",
"Result": {
"success": true
},
"ResultPath": "$.result",
"Next": "Iterator"
},
"Done": {
"Type": "Pass",
"End": true
}
}
}
```
1. Remplacez le `Iterator Resource` champ par l'ARN de votre fonction `Iterator` Lambda que vous avez créée précédemment.
1. Sélectionnez **Config**, puis entrez un **nom** pour votre machine d'état, tel que`IterateCount`.
**Note**
Les noms des machines d'état, des exécutions et des tâches d'activité ne doivent pas dépasser 80 caractères. Ces noms doivent être uniques pour votre compte et votre AWS région, et ne doivent contenir aucun des éléments suivants :
Espace blanc
Caractères génériques () `? *`
Caractères entre crochets (`< > { } [ ]`)
Caractères spéciaux (`" # % \ ^ | ~ ` $ & , ; : /`)
Caractères de contrôle (`\\u0000`- `\\u001f` ou `\\u007f` -`\\u009f`).
Step Functions accepte les noms des machines à états, des exécutions, des activités et des étiquettes contenant des caractères non ASCII. Dans la mesure où ces caractères empêcheront Amazon CloudWatch d'enregistrer les données, nous vous recommandons de n'utiliser que des caractères ASCII afin de pouvoir suivre les métriques de Step Functions.
1. Pour **Type**, acceptez la valeur par défaut **Standard**. Pour **Autorisations**, choisissez **Créer un nouveau rôle**.
1. Choisissez **Créer**, puis **Confirmez** les créations de rôles.
## Étape 4 : Démarrage d'une nouvelle exécution
Une fois que vous avez créé votre machine d'état, vous pouvez lancer une exécution.
1. Sur la **IterateCount**page, choisissez **Démarrer l'exécution**.
1. (Facultatif) Entrez un nom d'exécution personnalisé pour remplacer le nom par défaut généré.
**Noms non ASCII et journalisation**
Step Functions accepte les noms des machines à états, des exécutions, des activités et des étiquettes contenant des caractères non ASCII. Dans la mesure où ces caractères empêcheront Amazon CloudWatch d'enregistrer les données, nous vous recommandons de n'utiliser que des caractères ASCII afin de pouvoir suivre les métriques de Step Functions.
1. Choisissez **Démarrer une exécution**.
Une nouvelle exécution de votre machine d'état commence, montrant votre exécution en cours.
![\[Graphique de la machine d'état montrant l'état de l'itérateur en bleu indiquant l'état en cours.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/tutorial-create-iterate-running.png)
L'exécution s'incrémente par étapes, en suivant le nombre à l'aide de votre fonction Lambda. Sur chaque itération, elle exécute l'exemple de travail référencé dans l'état `ExampleWork` de votre machine d'état.
Une fois que le compte atteint le nombre configuré dans l'état `ConfigureCount` de votre machine d'état, l'exécution quitte l'itération et prend fin.
![\[Graphique de la machine d'état montrant l'état de l'itérateur et l'état terminé en vert pour indiquer que les deux ont réussi.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/tutorial-create-iterate-done.png)