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.
# Création d'une machine à états d'activité à l'aide de Step Functions
Ce didacticiel présente la création d'une machine d'état basée sur les activités à l'aide de Java et d' AWS Step Functions. Les activités vous permettent de contrôler le code de travail qui s'exécute ailleurs depuis votre machine d'état. Pour accéder à une présentation, consultez [En savoir plus sur les activités dans Step Functions](concepts-activities.md) dans [En savoir plus sur les machines à états dans Step Functions](concepts-statemachines.md).
Pour suivre ce didacticiel, vous aurez besoin des éléments suivants :
+ Le [kit SDK pour Java](https://aws.amazon.com/sdk-for-java/). L'exemple d'activité présenté dans ce didacticiel est une application Java qui utilise le AWS SDK pour Java pour communiquer avec AWS.
+ AWS informations d'identification dans l'environnement ou dans le fichier AWS de configuration standard. Pour plus d'informations, consultez la section [Configurer vos AWS informations d'identification](https://docs.aws.amazon.com/AWSSdkDocsJava/latest/DeveloperGuide/set-up-creds.html) dans le *guide du AWS SDK pour Java développeur*.
## Étape 1 : Créer une activité
Vous devez informer Step Functions de l'*activité* dont vous souhaitez créer le *worker* (un programme). Step Functions répond avec un Amazon Resource Name (ARN) qui établit l'identité de l'activité. Utilisez cette identité pour coordonner les informations transmises entre votre machine d'état et l'application de travail.
**Important**
Assurez-vous que votre tâche d'activité est enregistrée sur le même AWS compte que votre machine d'état.
1. Dans la [console Step Functions](https://console.aws.amazon.com/states/home), dans le volet de navigation de gauche, choisissez **Activities**.
1. Choisissez **Create activity** (Créer une activité).
1. Entrez un **nom** pour l'activité, par exemple`get-greeting`, puis choisissez **Créer une activité**.
1. Lorsque votre tâche d'activité est créée, notez son ARN, comme illustré dans l'exemple suivant.
```
arn:aws:states:region:123456789012:activity:get-greeting
```
## Étape 2 : Création d'une machine à états
Créez une machine d'état qui détermine à quel moment votre activité est appelée et à quel moment votre application de travail doit effectuer son travail principal, collecter ses résultats et les renvoyer. Pour créer la machine à états, vous allez utiliser Workflow Studio. [Éditeur de code](workflow-studio.md#wfs-interface-code-editor)
1. Dans la [console Step Functions](https://console.aws.amazon.com/states/home), dans le volet de navigation de gauche, choisissez **State machines**.
1. Sur la page **State machines**, choisissez **Create state machine**.
1. Choisissez **Créer à partir de rien**.
1. Donnez un nom à votre machine d'état, puis choisissez **Continuer** pour modifier votre machine d'état dans Workflow Studio.
1. Pour ce didacticiel, vous allez écrire la définition [Amazon States Language](concepts-amazon-states-language.md) (ASL) de votre machine à états dans l'éditeur de code. Pour ce faire, sélectionnez **Code**.
1. Supprimez le code standard existant et collez le code suivant. N'oubliez pas de remplacer l'exemple d'ARN dans le `Resource` champ par l'ARN de la tâche d'activité que vous avez créée précédemment[Étape 1 : Créer une activité](#create-activity-state-machine-step-1).
```
{
"Comment": "An example using a Task state.",
"StartAt": "getGreeting",
"Version": "1.0",
"TimeoutSeconds": 300,
"States":
{
"getGreeting": {
"Type": "Task",
"Resource": "arn:aws:states:region:123456789012:activity:get-greeting",
"End": true
}
}
}
```
Il s'agit d'une description de votre machine à états utilisant le [Amazon States Language](concepts-amazon-states-language.md) (ASL). Elle décrit un seul état `Task` nommé `getGreeting`. Pour plus d'informations, consultez [Structure de la machine d'état](statemachine-structure.md).
1. Sur le[Visualisation de graphe](workflow-studio.md#wfs-interface-code-graph-viz), assurez-vous que le graphique du flux de travail correspondant à la définition ASL que vous avez ajoutée ressemble au graphique suivant.
![\[Visualisation graphique de la machine à états avec l'état des RunActivity tâches.\]](http://docs.aws.amazon.com/fr_fr/step-functions/latest/dg/images/tutorial-create-state-machine-custom-preview.png)
1. Spécifiez un nom pour votre machine à états. Pour ce faire, cliquez sur l'icône d'édition à côté du nom de la machine à états par défaut de **MyStateMachine**. Ensuite, dans **Configuration de la machine d'état**, spécifiez un nom dans le champ **Nom de la machine d'état**.
Pour ce didacticiel, saisissez le nom **ActivityStateMachine**.
1. (Facultatif) Dans **Configuration de la machine à états**, spécifiez d'autres paramètres de flux de travail, tels que le type de machine à états et son rôle d'exécution.
Pour ce didacticiel, conservez toutes les sélections par défaut dans **les paramètres State Machine**.
Si vous avez [déjà créé un rôle IAM](procedure-create-iam-role.md) avec les autorisations appropriées pour votre machine d'état et que vous souhaitez l'utiliser, dans **Autorisations**, sélectionnez **Choisir un rôle existant**, puis sélectionnez un rôle dans la liste. Vous pouvez également sélectionner **Entrer un ARN de rôle**, puis fournir un ARN pour ce rôle IAM.
1. Dans la boîte de dialogue **Confirmer la création du rôle**, choisissez **Confirmer** pour continuer.
Vous pouvez également choisir **Afficher les paramètres des rôles** pour revenir à la **configuration de la machine State**.
**Note**
Si vous supprimez le rôle IAM créé par Step Functions, Step Functions ne pourra pas le recréer ultérieurement. De même, si vous modifiez le rôle (par exemple, en supprimant Step Functions des principes de la politique IAM), Step Functions ne pourra pas restaurer ses paramètres d'origine ultérieurement.
## Étape 3 : Implémentation d'une application de travail
Créez une *application de travail*. Une application de travail est un programme qui a en charge les opérations suivantes :
+ Polling Step Functions pour les activités utilisant l'action `GetActivityTask` API.
+ Exécution du travail de l'activité à l'aide de votre code (par exemple, la méthode `getGreeting()` dans le code ci-dessous).
+ Renvoi des résultats à l'aide des actions d'API `SendTaskSuccess`, `SendTaskFailure` et `SendTaskHeartbeat`.
**Note**
Pour obtenir un exemple plus complet d'un travail d'activité, consultez [Exemple : Activity Worker dans Ruby](concepts-activities.md#example-ruby-activity-worker). Cet exemple fournit une implémentation basée sur les bonnes pratiques, qui peut être utilisée comme référence pour l'application de travail de votre activité. Le code implémente un modèle consommateur-producteur avec un nombre configurable de threads pour les observateurs et les travaux d'activité.
### Pour implémenter l'application de travail
1. Créez un fichier nommé `GreeterActivities.java`.
1. Ajoutez-lui le code suivant.
```
import com.amazonaws.ClientConfiguration;
import com.amazonaws.auth.EnvironmentVariableCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.stepfunctions.AWSStepFunctions;
import com.amazonaws.services.stepfunctions.AWSStepFunctionsClientBuilder;
import com.amazonaws.services.stepfunctions.model.GetActivityTaskRequest;
import com.amazonaws.services.stepfunctions.model.GetActivityTaskResult;
import com.amazonaws.services.stepfunctions.model.SendTaskFailureRequest;
import com.amazonaws.services.stepfunctions.model.SendTaskSuccessRequest;
import com.amazonaws.util.json.Jackson;
import com.fasterxml.jackson.databind.JsonNode;
import java.util.concurrent.TimeUnit;
public class GreeterActivities {
public String getGreeting(String who) throws Exception {
return "{\"Hello\": \"" + who + "\"}";
}
public static void main(final String[] args) throws Exception {
GreeterActivities greeterActivities = new GreeterActivities();
ClientConfiguration clientConfiguration = new ClientConfiguration();
clientConfiguration.setSocketTimeout((int)TimeUnit.SECONDS.toMillis(70));
AWSStepFunctions client = AWSStepFunctionsClientBuilder.standard()
.withRegion(Regions.US_EAST_1)
.withCredentials(new EnvironmentVariableCredentialsProvider())
.withClientConfiguration(clientConfiguration)
.build();
while (true) {
GetActivityTaskResult getActivityTaskResult =
client.getActivityTask(
new GetActivityTaskRequest().withActivityArn(ACTIVITY_ARN));
if (getActivityTaskResult.getTaskToken() != null) {
try {
JsonNode json = Jackson.jsonNodeOf(getActivityTaskResult.getInput());
String greetingResult =
greeterActivities.getGreeting(json.get("who").textValue());
client.sendTaskSuccess(
new SendTaskSuccessRequest().withOutput(
greetingResult).withTaskToken(getActivityTaskResult.getTaskToken()));
} catch (Exception e) {
client.sendTaskFailure(new SendTaskFailureRequest().withTaskToken(
getActivityTaskResult.getTaskToken()));
}
} else {
Thread.sleep(1000);
}
}
}
}
```
**Note**
La classe `EnvironmentVariableCredentialsProvider` de cet exemple suivant suppose que les variables d'environnement `AWS_ACCESS_KEY_ID` (ou `AWS_ACCESS_KEY`) et `AWS_SECRET_KEY` (ou `AWS_SECRET_ACCESS_KEY`) sont définies. Pour plus d'informations sur la fourniture des informations d'identification requises à l'usine, consultez la section [AWSCredentialsFournisseur](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/AWSCredentialsProvider.html) dans la *référence de l'AWS SDK pour Java API* et [Configurer les AWS informations d'identification et la région pour le développement](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html) dans le *Guide du AWS SDK pour Java développeur*.
Par défaut, le AWS SDK attendra jusqu'à 50 secondes pour recevoir les données du serveur pour toute opération. `GetActivityTask` est une opération d'attente active de longue durée qui attendra la prochaine tâche disponible pendant 60 secondes au maximum. Pour éviter de recevoir une `SocketTimeoutException` erreur, réglez SocketTimeout ce paramètre sur 70 secondes.
1. Dans la liste des paramètres du `GetActivityTaskRequest().withActivityArn()` constructeur, remplacez la `ACTIVITY_ARN` valeur par l'ARN de la tâche d'activité que vous avez créée précédemment. [Étape 1 : Créer une activité](#create-activity-state-machine-step-1)
## Étape 4 : Exécutez la machine d'état
Lorsque vous lancez l'exécution de la machine à états, votre assistant interroge Step Functions pour connaître les activités, effectue son travail (en utilisant les entrées que vous fournissez) et renvoie ses résultats.
1. Sur la ***ActivityStateMachine***page, choisissez **Démarrer l'exécution**.
La boîte de dialogue **Démarrer l'exécution** s'affiche.
1. Dans la boîte de dialogue **Démarrer l'exécution**, procédez comme suit :
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. Dans le champ **Entrée**, entrez l'entrée JSON suivante pour exécuter votre flux de travail.
```
{
"who": "AWS Step Functions"
}
```
1. Choisissez **Start execution (Démarrer l'exécution)**.
1. La console Step Functions vous dirige vers une page intitulée avec votre ID d'exécution. Cette page est connue sous le nom de page *Détails de l'exécution*. Sur cette page, vous pouvez consulter les résultats de l'exécution au fur et à mesure que l'exécution progresse ou une fois celle-ci terminée.
Pour consulter les résultats de l'exécution, choisissez des états individuels dans la **vue graphique**, puis choisissez les onglets individuels du [Détails de l'étape](concepts-view-execution-details.md#exec-details-intf-step-details) volet pour afficher les détails de chaque état, y compris les entrées, les sorties et la définition respectivement. Pour plus de détails sur les informations d'exécution que vous pouvez consulter sur la page *Détails de l'exécution*, voir[Vue d'ensemble des détails d'exécution](concepts-view-execution-details.md#exec-details-interface-overview).
## Étape 5 : Exécuter et arrêter l'application de travail
Pour que l'application de travail interroge les activités de votre machine d'état, vous devez exécuter l'application de travail.
1. Sur la ligne de commande, accédez au répertoire dans lequel vous avez créé `GreeterActivities.java`.
1. Pour utiliser le AWS SDK, ajoutez le chemin complet des `third-party` répertoires `lib` et aux dépendances de votre fichier de compilation et à votre Java`CLASSPATH`. Pour plus d'informations, consultez la section [Téléchargement et extraction du SDK](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html#download-and-extract-sdk) dans le guide du *AWS SDK pour Java développeur*.
1. Compilez le fichier.
```
$ javac GreeterActivities.java
```
1. Exécutez le fichier .
```
$ java GreeterActivities
```
1. Sur la [console Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/), accédez à la page *Détails de l'exécution*.
1. Lorsque l'exécution est terminée, examinez les résultats de votre exécution.
1. Arrêtez l'application de travail.