En savoir plus sur les activités dans Step Functions

Avec les activités Step Functions, vous pouvez configurer une tâche dans votre machine à états dans laquelle le travail réel est effectué par un travailleur extérieur à Step Functions. Par exemple, vous pouvez avoir un programme de travail exécuté sur Amazon Elastic Compute Cloud (AmazonEC2), Amazon Elastic Container Service (AmazonECS) ou même sur des appareils mobiles.

Présentation

Entrée AWS Step Functions, les activités sont un moyen d'associer du code exécuté quelque part (connu sous le nom de travailleur d'activité) à une tâche spécifique dans une machine à états. Vous pouvez créer une activité à l'aide de la console Step Functions ou en appelantCreateActivity. Cela fournit un nom de ressource Amazon (ARN) pour l'état de votre tâche. Utilisez-le ARN pour connaître l'état de la tâche en fonction du travail de votre agent d'activité.

Note

Les versions des activités ne sont pas gérées et les activités doivent être rétrocompatibles. Si vous devez apporter une modification incompatible avec les versions antérieures à une activité, créez-en une nouvelle dans Step Functions en utilisant un nom unique.

Un travailleur d'activité peut être une application exécutée sur une EC2 instance Amazon, un AWS Lambda fonction, un appareil mobile : toute application capable d'établir une HTTP connexion, hébergée n'importe où. Lorsque Step Functions atteint l'état d'une tâche d'activité, le flux de travail attend qu'un agent d'activité interroge une tâche. Un travailleur d'activité interroge Step Functions en utilisant GetActivityTask et en envoyant le ARN pour l'activité correspondante. GetActivityTaskrenvoie une réponse comprenant input (une chaîne d'JSONentrée pour la tâche) et un taskToken(un identifiant unique pour la tâche). Une fois le travail d'activité terminé, il peut fournir un rapport de réussite ou d'échec en utilisant SendTaskSuccess ou SendTaskFailure. Ces deux appels utilisent le taskToken fourni par GetActivityTask pour associer le résultat à cette tâche.

APIsLié aux tâches d'activité

Step Functions permet APIs de créer et de répertorier des activités, de demander une tâche et de gérer le flux de votre machine d'état en fonction des résultats de votre travailleur.

Les Step Functions APIs associées aux activités sont les suivantes :

• CreateActivity

• GetActivityTask

• ListActivities

• SendTaskFailure

• SendTaskHeartbeat

• SendTaskSuccess

Note

La recherche de tâches d'activité avec GetActivityTask peut provoquer une certaine latence dans les implémentations. Consultez Éviter la latence lors de l'interrogation pour des tâches d'activité.

En attente de l'achèvement d'une tâche d'activité

Configurez la durée d'attente d'un état en définissant TimeoutSeconds dans la définition de tâche. Pour garder la tâche active et en attente, envoyez régulièrement une pulsation depuis votre travail d'activité en utilisant SendTaskHeartbeat dans le délai configuré dans TimeoutSeconds. En configurant un délai d'attente prolongé et en envoyant activement un battement de cœur, une activité dans Step Functions peut attendre jusqu'à un an avant la fin de son exécution.

Par exemple, si vous avez besoin d'un flux de travail en attente du résultat d'un long processus, procédez comme suit.

1. Créez une activité dans la console ou en utilisant CreateActivity. Prenez note de l'activitéARN.

2. Référencez-le ARN dans l'état d'une tâche d'activité dans la définition et l'ensemble de votre machine à étatsTimeoutSeconds.

3. Implémentez un agent d'activité qui interroge le travail en utilisant ou GetActivityTask en référençant cette activitéARN.

4. Utilisez SendTaskHeartbeat régulièrement au cours de la durée définie dans HeartbeatSeconds dans la définition de la tâche de la machine d'état pour éviter l'expiration de la tâche.

5. Démarrer l'exécution de la machine d'état.

6. Démarrez le processus de votre travail d'activité.

L'exécution s'interrompt au niveau de l'état de tâche d'activité et attend que le travail d'activité recherche une tâche. Dès qu'un taskToken est fourni à votre travail d'activité, votre flux de travail attend que SendTaskSuccess ou SendTaskFailure indique un statut. Si l'exécution ne reçoit pas l'un ou l'autre de ces éléments ou un appel SendTaskHeartbeat avant l'heure configurée dans TimeoutSeconds, l'exécution échoue et l'historique des exécutions comportera un événement ExecutionTimedOut.

Exemple : Activity Worker dans Ruby

L'exemple de code de travail d'activité suivant implémente un modèle consommateur-producteur avec un nombre configurable de threads pour les sondeurs et les travailleurs d'activité. Les fils de discussion sont constamment longs pour interroger la tâche d'activité dans Step Functions. Lorsqu'une tâche d'activité est récupérée, elle passe par une file d'attente de blocage délimitée pour que le fil d'activité puisse la récupérer.

• Pour de plus amples informations, veuillez consulter le .AWS SDK for Ruby APIRéférence.

• Pour télécharger ce code et les ressources associées, consultez le référentiel step-functions-ruby-activity-worker sur GitHub.

Le code suivant est le point d'entrée principal de cet exemple de travailleur d'activité Ruby.

 require_relative '../lib/step_functions/activity'
 credentials = Aws::SharedCredentials.new
 region = 'us-west-2'
 activity_arn = 'ACTIVITY_ARN'
 
 activity = StepFunctions::Activity.new(
   credentials: credentials,
   region: region,
   activity_arn: activity_arn,
   workers_count: 1,
   pollers_count: 1,
   heartbeat_delay: 30
 )
 
 # Start method block contains your custom implementation to process the input 
 activity.start do |input|
   { result: :SUCCESS, echo: input['value'] }                    
 end

Vous devez préciser votre activité ARN et votre région. Le code inclut des paramètres par défaut que vous pouvez définir, tels que le nombre de threads et le délai de pulsation.

Élément	Description
require_relative	Chemin d'accès relatif à l'exemple du code du travail d'activité suivant.
region	AWS Région de votre activité
workers_count	Nombre de threads de votre travail d'activité. Pour la plupart des implémentations, entre 10 et 20 threads doivent suffire. Plus le temps de traitement de l'activité est long, plus le nombre de threads nécessaires est élevé. À titre d'estimation, multipliez le nombre d'activités de traitement par seconde par la latence du traitement d'activité du 99e percentile, en secondes.
pollers_count	Nombre de threads de vos observateurs. Entre 10 et 20 threads doivent suffire pour la plupart des implémentations.
heartbeat_delay	Délai en secondes entre les pulsations.
input	Logique d'implémentation de votre activité.

Étapes suivantes

Pour un aperçu plus détaillé de la création de machines d'état qui utilisent des programmes de travail d'activité, voir :

• Création d'une machine à états d'activité à l'aide de Step Functions