AWS Step Functions · IAM role ARN (Voy a proporcionar el ARN de una función de IAM existente) y...

AWS Step FunctionsGuía para desarrolladores

AWS Step Functions Guía para desarrolladores

AWS Step Functions: Guía para desarrolladoresCopyright © 2018 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any mannerthat is likely to cause confusion among customers, or in any manner that disparages or discredits Amazon. All other trademarks notowned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to, or sponsored byAmazon.


Table of Contents¿Qué es AWS Step Functions? ............................................................................................................ 1

Información general de Step Functions .......................................................................................... 1Regiones admitidas ..................................................................................................................... 1

Acerca de Amazon Web Services ......................................................................................... 2Introducción ....................................................................................................................................... 3

Paso 1: Creación de una máquina de estado ................................................................................. 3Para crear la máquina de estado .......................................................................................... 3

Paso 2: Inicio de una nueva ejecución ........................................................................................... 4Para iniciar una nueva ejecución .......................................................................................... 4

Paso 3: (Opcional) Actualización de una máquina de estado ............................................................. 5Para actualizar una máquina de estado ................................................................................. 5

Pasos siguientes ........................................................................................................................ 6Tutoriales .......................................................................................................................................... 7

Opciones de desarrollo ................................................................................................................ 7Consola de Step Functions .................................................................................................. 7&SDK de AWS ................................................................................................................... 7API de servicio HTTPS ....................................................................................................... 8Entornos de desarrollo ........................................................................................................ 8Puntos de enlace ............................................................................................................... 8AWS CLI ........................................................................................................................... 8

Creación de una máquina de estado Lambda ................................................................................. 9Paso 1: Creación de un rol de IAM para Lambda .................................................................... 9Paso 2: Creación de una función de Lambda ......................................................................... 9Paso 3: Comprobación de la función de Lambda ................................................................... 10Paso 4: Creación de una máquina de estado ........................................................................ 11Paso 5: Inicio de una nueva ejecución ................................................................................. 12

Creación de una máquina de estado Lambda mediante AWS CloudFormation .................................... 13Paso 1: Configuración de la plantilla de AWS CloudFormation ................................................. 14Paso 2: Uso de la plantilla de AWS CloudFormation para crear una máquina de estado Lambda .... 17Paso 3: Inicio de la ejecución de una máquina de estado ....................................................... 20

Creación de una máquina de estado de actividades ....................................................................... 21Paso 1: Creación de una nueva actividad ............................................................................. 21Paso 2: Creación de una máquina de estado ........................................................................ 22Paso 3: Implementación de un proceso de trabajo ................................................................. 23Paso 4: Inicio de una ejecución .......................................................................................... 25Paso 5: Ejecución y detención del proceso de trabajo ............................................................ 26

Administración de las condiciones de error con una máquina de estado ............................................ 26Paso 1: Creación de un rol de IAM para Lambda .................................................................. 27Paso 2: Creación de una función de Lambda que no funciona correctamente ............................. 27Paso 3: Comprobación de la función de Lambda ................................................................... 28Paso 4: Creación de una máquina de estado con un campo Catch .......................................... 28Paso 5: Inicio de una nueva ejecución ................................................................................. 31

Iniciar la ejecución de una máquina de estado con Eventos de CloudWatch ....................................... 32Paso 1: Creación de una máquina de estado ........................................................................ 32Paso 2: Creación de un regla de Eventos de CloudWatch ....................................................... 32

Creación de una API de Step Functions mediante API Gateway ....................................................... 34Paso 1: Creación de un rol de IAM para API Gateway ............................................................ 35Paso 2: Creación de la API de API Gateway ........................................................................ 35Paso 3: Comprobación e implementación de la API de API Gateway ........................................ 37

Iteración de un bucle mediante Lambda ....................................................................................... 39Paso 1: Creación de una función de Lambda para iterar un contador ........................................ 39Paso 2: Comprobación de la función de Lambda ................................................................... 40Paso 3: Creación de una máquina de estado ........................................................................ 41Paso 4: Inicio de una nueva ejecución ................................................................................. 44

iii


Continuar como una nueva ejecución .......................................................................................... 46Requisitos previos ............................................................................................................. 48Paso 1: Creación de una función Lambda Iterate para iterar un contador ............................... 48Paso 2: Creación de una función Lambda Restart para comenzar una nueva ejecución de StepFunctions ......................................................................................................................... 50Paso 3: Creación de una máquina de estado ........................................................................ 51Paso 4: Actualización de la política de IAM .......................................................................... 53Paso 5: Comienzo de una ejecución .................................................................................... 53

Cómo funciona Step Functions ........................................................................................................... 55Estados ................................................................................................................................... 55Tareas ..................................................................................................................................... 56Tareas ..................................................................................................................................... 56

Creación de una actividad .................................................................................................. 57Creación de un proceso de trabajo ...................................................................................... 57Ejemplo de proceso de trabajo de actividad en Ruby ............................................................. 57

Transiciones ............................................................................................................................. 64Datos de la máquina de estado .................................................................................................. 64

Formato de los datos ........................................................................................................ 65Entrada y salida de la máquina de estado ............................................................................ 65Entrada y salida de estados ............................................................................................... 65

Procesamiento de entrada y salida .............................................................................................. 66Descripción de ResultPath .............................................................................................. 67Filtrado con InputPath y OutputPath .............................................................................. 72

Ejecuciones .............................................................................................................................. 74Control de errores ..................................................................................................................... 74

Nombres de error ............................................................................................................. 74Reintento después de un error ........................................................................................... 75Estados alternativos .......................................................................................................... 77Ejemplos sobre el uso de Retry y Catch .............................................................................. 78

Consistencia de lectura .............................................................................................................. 81Plantillas .................................................................................................................................. 81Proyectos de muestra ................................................................................................................ 82

Job Status Poller .............................................................................................................. 82Task Timer ...................................................................................................................... 85

Lenguaje de estados de Amazon ........................................................................................................ 88Especificación de Lenguaje de estados de Amazon de ejemplo ....................................................... 88Estructura de las máquinas de estado ......................................................................................... 89Estados ................................................................................................................................... 90

Campos de estado comunes .............................................................................................. 91Pass ............................................................................................................................... 91Tarea .............................................................................................................................. 92Choice ............................................................................................................................. 95Wait ................................................................................................................................ 98Succeed .......................................................................................................................... 99Fail ................................................................................................................................. 99Parallel .......................................................................................................................... 100

Procesamiento de entrada y salida ............................................................................................ 103Rutas ............................................................................................................................ 103Rutas de referencia ......................................................................................................... 103

Errores .................................................................................................................................. 105Representación de errores ............................................................................................... 106Reintento después de un error .......................................................................................... 106Estados alternativos ........................................................................................................ 108

prácticas recomendadas ................................................................................................................... 110Utilice tiempos de espera para evitar las ejecuciones bloqueadas ................................................... 110Utilice ARN en lugar de pasar cargas de gran tamaño .................................................................. 110Evitar alcanzar el límite de historial ............................................................................................ 111

iv


Control de excepciones de servicio en Lambda ........................................................................... 111Límites ........................................................................................................................................... 112

Límites generales .................................................................................................................... 112Límites relacionados con las cuentas ......................................................................................... 113Límites relacionados con ejecuciones de máquinas de estado ........................................................ 113Límites relacionados con las ejecuciones de tareas ...................................................................... 113Límites relacionados con las limitaciones de acciones de API ........................................................ 114Límites relacionados con las limitaciones de estados .................................................................... 115Solicitar un aumento de límite ................................................................................................... 115

Monitorización y registro ................................................................................................................... 116Monitorización de Step Functions con CloudWatch ....................................................................... 116

Métricas que registran un intervalo de tiempo ...................................................................... 117Métricas que registran un recuento .................................................................................... 117Métricas de las máquinas de estado .................................................................................. 117Consulta de métricas de Step Functions ............................................................................. 120Configuración de alarmas en Step Functions ....................................................................... 121

Registro de Step Functions con CloudTrail .................................................................................. 123Información de Step Functions en CloudTrail ....................................................................... 123Descripción de las entradas de archivos log de Step Functions .............................................. 124

Seguridad ...................................................................................................................................... 129Autenticación .......................................................................................................................... 129Creación de roles de IAM para AWS Step Functions .................................................................... 130

Creación de un rol para Step Functions .............................................................................. 130Creación de permisos granulares de IAM para usuarios no administradores ..................................... 131

Permisos de nivel de servicio ............................................................................................ 131Permisos de nivel de máquina de estado ............................................................................ 132Permisos de nivel de ejecución ......................................................................................... 132Permisos de nivel de actividad .......................................................................................... 132

Recursos relacionados de Step Functions ........................................................................................... 134Historial de revisión ......................................................................................................................... 135AWS Glossary ................................................................................................................................ 144

v

AWS Step Functions Guía para desarrolladoresInformación general de Step Functions

¿Qué es AWS Step Functions?AWS Step Functions es un servicio web que facilita la coordinación de componentes de aplicacionesy microservicios distribuidos con flujos de trabajo visuales. La creación de aplicaciones a partir decomponentes individuales que realizan cada uno una función o tarea discreta le permite escalar ymodificar las aplicaciones rápidamente. Step Functions proporciona una manera fiable de coordinar loscomponentes y procesar las funciones de su aplicación. Step Functions proporciona una consola gráficacon la que puede visualizar los componentes de su aplicación en varios pasos. Activa y monitoriza cadapaso de manera automática, y realiza reintentos cuando se producen errores, por lo que su aplicación seejecuta en orden y según lo previsto en todo momento. Step Functions registra el estado de cada paso, demanera que, cuando algo sale mal, puede diagnosticar y depurar los problemas con rapidez.

Step Functions administra las operaciones y la infraestructura subyacente para garantizar que suaplicación se encuentre disponible a cualquier escala.

Puede ejecutar sus tareas en la nube de AWS, en sus propios servidores o en cualquier sistema que tengaacceso a AWS. El acceso y uso de Step Functions se realiza con la consola de Step Functions, los SDKde AWS o un API HTTP. En esta guía se muestra cómo desarrollar, probar y solucionar problemas de supropia máquina de estado mediante estos métodos.

Información general de Step FunctionsEstos son algunas de las características principales de AWS Step Functions:

• Step Functions se basa en los conceptos de tareas (p. 56) y máquinas de estado (p. 55).• Las máquinas de estado se definen mediante el Lenguaje de estados de Amazon (p. 88) basado en

JSON.• La consola de Step Functions muestra una vista gráfica de la estructura de la máquina de estado, para

que pueda comprobar visualmente la lógica de la máquina de estado y monitorizar las ejecuciones.

Regiones admitidasActualmente, Step Functions se admite solo en las siguientes regiones:

• EE.UU. Este (Ohio)• US East (N. Virginia)• EE.UU. Oeste (Oregón)• EE.UU. Oeste (Norte de California)• Asia Pacífico (Mumbai)• Asia Pacífico (Sídney)• Asia Pacífico (Tokio)• Asia Pacífico (Seúl)• UE (Fráncfort)• UE (Irlanda)• UE (Londres)• Canadá (Central)• Asia Pacífico (Singapur)

1

https://console.aws.amazon.com/states/home?region=us-east-1#/


AWS Step Functions Guía para desarrolladoresAcerca de Amazon Web Services

• AWS GovCloud (US)

Acerca de Amazon Web ServicesAmazon Web Services (AWS) es una colección de servicios de infraestructura digitales que losdesarrolladores pueden usar cuando desarrollan sus aplicaciones. Los servicios incluyen informática,almacenamiento, base de datos y sincronización de aplicaciones (mensajería y puesta en cola). AWSutiliza un modelo de servicio de pago por uso: solo paga por los servicios que usted (o su aplicación)usa. Los nuevos usuarios de AWS disponen de una capa de uso gratuito. En esta capa, los servicios songratuitos por debajo de determinado nivel de uso. Para obtener más información sobre los costos de AWSy la capa gratuita, consulte Uso de la capa gratuita de AWS. Para obtener una cuenta de AWS, visite lapágina de inicio de AWS y seleccione Crear una cuenta gratuita.

2

https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/billing-free-tier.html

https://aws.amazon.com/

AWS Step Functions Guía para desarrolladoresPaso 1: Creación de una máquina de estado

IntroducciónEn este tutorial se presentan los aspectos básicos de AWS Step Functions. Creará una máquina de estadosencilla que se ejecutará de forma independiente mediante un estado Pass. El estado Pass representauna no-op (una instrucción sin operación).

Temas• Paso 1: Creación de una máquina de estado (p. 3)• Paso 2: Inicio de una nueva ejecución (p. 4)• Paso 3: (Opcional) Actualización de una máquina de estado (p. 5)• Pasos siguientes (p. 6)

Paso 1: Creación de una máquina de estadoStep Functions ofrece varias máquinas de estado predefinido como plantillas. Cree su primera máquina deestado utilizando la plantilla Hello Word (Hola a todos).

Para crear la máquina de estado1. Inicie sesión en la consola de Step Functions y, a continuación, seleccione Get Started.2. En la página Create a state machine (Crear una máquina de estado), seleccione Templates (Plantillas)

y elija Hello world (Hola a todos).

Step Functions rellena automáticamente el nombre de la máquina de estado. También rellena el panelCode con la descripción de la máquina de estado realizada mediante el Lenguaje de estados deAmazon.

{ "Comment": "A Hello World example of the Amazon States Language using a Pass state", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Pass", "Result": "Hello World!", "End": true } }}

Este texto JSON define un estado Pass denominado HelloWorld. Para obtener más información,consulte Estructura de las máquinas de estado (p. 89).

3. Utilice el gráfico del panel Visual Workflow para comprobar que el código de Lenguaje de estados deAmazon describe la máquina de estado correctamente.

3

https://console.aws.amazon.com/states/home

AWS Step Functions Guía para desarrolladoresPaso 2: Inicio de una nueva ejecución

Si no ve el gráfico, seleccione en el panel Visual Workflow.4. Cree o especifique un rol de IAM.

• Si desea crear un nuevo rol de IAM para Step Functions, elija Create a role for me (Crear un rol paramí) y después I acknowledge that Step Functions will create an IAM role which allows access to myLambda functions (Acepto que Step Functions cree una función de IAM con acceso a mis funcionesde Lambda).

• Si previamente creó una función de IAM para Step Functions (p. 130), seleccione I will provide anIAM role ARN (Voy a proporcionar el ARN de una función de IAM existente) y especifique el ARN dela función de IAM.

Note

Si elimina el rol de IAM que crea Step Functions, Step Functions no podrá volver a crearlomás adelante. Asimismo, si modifica el rol (por ejemplo, eliminando Step Functions de laentidad principal de la política de IAM), Step Functions no podrá restablecer su configuraciónoriginal más adelante.

5. Seleccione Create State Machine.

Paso 2: Inicio de una nueva ejecuciónDespués de crear la máquina de estado, puede iniciar una ejecución.

Para iniciar una nueva ejecución1. En la página Helloworld (Hola mundo), elija New execution (Nueva ejecución) o Start execution

(Iniciar ejecución) si ya inició antes una ejecución.

Aparece la ventana New execution.2. (Opcional) Para ayudar a identificar la ejecución, puede especificar un ID en el recuadro Enter an

execution name (Especifique un nombre de ejecución). Si no especifica ningún ID, Step Functionsgenera un ID único automáticamente.

Note

Step Functions le permite crear una máquina de estado, una ejecución y nombres deactividad que contengan caracteres no ASCII. Estos nombres no ASCII no funcionan conAmazon CloudWatch. Para asegurarse de que puede realizar un seguimiento de las métricasde CloudWatch, elija un nombre que solo use caracteres ASCII.

3. Seleccione Start execution (Iniciar ejecución).

Se inicia una nueva ejecución de la máquina de estado y aparece una nueva página que muestra laejecución en funcionamiento.

4

AWS Step Functions Guía para desarrolladoresPaso 3: (Opcional) Actualización de una máquina de estado

4. (Opcional) En la sección Execution Details (Detalles de la ejecución), elija la pestaña Info(Información) para ver el valor de Execution Status (Estado de la ejecución) y las marcas temporalesStarted (Iniciada) y Closed (Finalizada).

5. Para ver los resultados de la ejecución, elija la pestaña Output.

Paso 3: (Opcional) Actualización de una máquinade estado

Puede actualizar su máquina de estado para futuras ejecuciones.

Note

Las actualizaciones de las máquinas de estado de Step Functions presentan consistenciafinal. Todas las ejecuciones que se realicen pasados unos segundos utilizarán la definición y elroleArn actualizados. Es posible que las ejecuciones que se inicien inmediatamente despuésde actualizar una máquina de estado utilicen la definición de la máquina de estado y el roleArnanteriores.

Para actualizar una máquina de estado1. En la página Helloworld, elija Edit (Editar).

Se muestra la página Edit.2. En el panel Code, edite la descripción de la máquina de estado realizada mediante el Lenguaje de

estados de Amazon. Actualice el Result para leer Hello World has been updated!

{ "Comment": "A Hello World example of the Amazon States Language using a Pass state", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Pass", "Result": "Hello World has been updated!", "End": true } }}

3. (Opcional) Seleccione un nuevo rol de IAMen la lista IAM role for executions.

Note

También puede seleccionar Create new role para crear un nuevo rol de IAM. Para obtenermás información, consulte Creación de roles de IAM para AWS Step Functions (p. 130).

5

AWS Step Functions Guía para desarrolladoresPasos siguientes

4. Elija Save (Guardar) y, a continuación, Start execution (Iniciar ejecución).5. En la página New execution (Nueva ejecución), elija Start Execution (Iniciar ejecución).6. Para ver los resultados de la ejecución, seleccione el estado HelloWorld en Visual workflow (Flujo de

trabajo visual) y expanda la sección Output (Salida) en Step details (Detalles de paso).

Note

El texto de salida coincide con la máquina de estado recién actualizada.

Pasos siguientesAhora que ha creado una máquina de estado sencilla mediante un estado Pass, pruebe lo siguiente:

• Crear una máquina de estado de Lambda (p. 9)• Crear una máquina de estado de Lambda mediante AWS CloudFormation (p. 13)• Crear una máquina de estado de actividad (p. 21)• Gestionar las condiciones de error con una máquina de estado (p. 26)• Iniciar una máquina de estado mediante Amazon CloudWatch Events (p. 32)• Crear un API de Step Functions mediante Amazon API Gateway (p. 34)

6

AWS Step Functions Guía para desarrolladoresOpciones de desarrollo

TutorialesLos siguientes tutoriales le ayudarán a comenzar a utilizar AWS Step Functions. Para completar estostutoriales, necesitará una cuenta de AWS. Si no tiene una cuenta de AWS, vaya a http://aws.amazon.com/y elija Inicie sesión en la consola.

Temas• Opciones de desarrollo (p. 7)• Creación de una máquina de estado Lambda (p. 9)• Creación de una máquina de estado Lambda mediante AWS CloudFormation (p. 13)• Creación de una máquina de estado de actividades (p. 21)• Administración de las condiciones de error con una máquina de estado (p. 26)• Iniciar la ejecución de una máquina de estado con Eventos de CloudWatch (p. 32)• Creación de una API de Step Functions mediante API Gateway (p. 34)• Iteración de un bucle mediante Lambda (p. 39)• Continuar como una nueva ejecución (p. 46)

Opciones de desarrolloPuede implementar sus máquinas de estado de Step Functions de varias formas distintas.

Consola de Step FunctionsPuede definir una máquina de estado mediante la consola de Step Functions. Puede crear máquinas deestado complejas en la nube sin usar un entorno de desarrollo local, y utilizar Lambda para proporcionar elcódigo de sus tareas y la consola de Step Functions para definir su máquina de estado mediante Lenguajede estados de Amazon.

En el tutorial Creación de una máquina de estado de Lambda (p. 9) se utiliza esta técnica para crearuna máquina de estado sencilla, ejecutarla y ver sus resultados.

&SDK de AWSStep Functions es compatible con los SDK de Java, .NET, Ruby, PHP, Python (boto 3), JavaScript, Go y C++, lo que proporciona una forma cómoda de utilizar las acciones de la API HTTPS de Step Functions endiferentes lenguajes de programación.

Puede desarrollar máquinas de estado, actividades o iniciadores de máquinas de estado con las accionesde la API expuestas por estas bibliotecas. También puede obtener acceso a las operaciones de visibilidada través de estas bibliotecas para desarrollar sus propias herramientas de monitorización e informes deStep Functions.

Para utilizar Step Functions con otros servicios de AWS, consulte la documentación de referencia de losSDK de AWS actuales y Herramientas para Amazon Web Services.

7

https://aws.amazon.com/


http://aws.amazon.com/tools/

AWS Step Functions Guía para desarrolladoresAPI de servicio HTTPS

Note

Step Functions admite solamente un punto de enlace HTTPS.

API de servicio HTTPSStep Functions proporciona operaciones de servicio accesibles a través de solicitudes HTTPS. Puedeutilizar estas operaciones para comunicarse directamente con Step Functions y para desarrollar suspropias bibliotecas en cualquier lenguaje que pueda comunicarse con Step Functions a través de HTTPS.

Puede desarrollar máquinas de estado, procesos de trabajo o iniciadores de máquinas de estado mediantelas acciones de la API de servicio. También puede obtener acceso a las operaciones de visibilidad a travésde las acciones de la API para desarrollar sus propias herramientas de monitorización e informes. Paraobtener información detallada sobre las acciones de la API, consulte la Referencia de la API de AWS StepFunctions.

Entornos de desarrolloDebe configurar un entorno de desarrollo adecuado para el lenguaje de programación que vaya a utilizar.Por ejemplo, si va a desarrollar para Step Functions con Java, debe instalar un entorno de desarrollo deJava (como el SDK para Java) en cada una de sus estaciones de trabajo de desarrollo. Si utiliza EclipseIDE for Java Development, también debe instalar Toolkit for Eclipse. Este complemento de Eclipse añadecaracterísticas útiles para el desarrollo en AWS.

Si su lenguaje de programación requiere un entorno de tiempo de ejecución, debe configurar el entorno encada equipo en el que se ejecuten estos procesos.

Puntos de enlacePara reducir la latencia y almacenar los datos en una ubicación que cumpla sus requisitos de StepFunctions, proporcione puntos de enlace en diferentes regiones.

Cada punto de enlace de Step Functions es totalmente independiente: una máquina de estado o actividadsolo existe en la región en la que se creó. Todas las máquinas de estado y actividades que crea en unaregión no comparten datos ni atributos con las creadas en otra región. Por ejemplo, puede registrar unamáquina de estado denominada STATES-Flows-1 en dos regiones diferentes, pero las dos máquinas deestado no compartirán datos ni atributos entre sí, por lo que serán independientes una de otra.

Para ver una lista de los puntos de enlace de Step Functions, consulte Regiones y puntos de conexión:AWS Step Functions en la Referencia general de Amazon Web Services.

AWS CLIPuede tener acceso a muchas características de Step Functions desde la AWS CLI. La AWS CLIproporciona una alternativa al uso de la consola de Step Functions o, en algunos casos, a la programaciónmediante acciones de API de AWS Step Functions. Por ejemplo, puede utilizar la AWS CLI para crear unanueva máquina de estado y después mostrar las máquinas de estado.

Los comandos de Step Functions de la AWS CLI le permiten iniciar y administrar ejecuciones, sondearactividades, registrar latidos de tareas y otras operaciones. Para obtener una lista completa de loscomandos de Step Functions y las descripciones de los argumentos disponibles, así como ejemplos quemuestran su uso, consulte la AWS CLI Command Reference.

Los comandos de la AWS CLI son similares a los de Lenguaje de estados de Amazon, por lo que puedeutilizar la AWS CLI para obtener información sobre las acciones de API de Step Functions. También puedeutilizar sus conocimientos existentes sobre las API para crear un prototipo de código o realizar acciones deStep Functions desde la línea de comandos.

8

https://docs.aws.amazon.com/step-functions/latest/apireference/


https://docs.aws.amazon.com/general/latest/gr/rande.html#step-functions_region

https://docs.aws.amazon.com/general/latest/gr/rande.html#step-functions_region


AWS Step Functions Guía para desarrolladoresCreación de una máquina de estado Lambda

Creación de una máquina de estado LambdaEn este tutorial, va a crear una máquina de estado de AWS Step Functions que utiliza una función AWSLambda para implementar un estado Task. Un estado Task es una estado sencillo que realiza una solaunidad de trabajo.

Lambda es una solución ideal para implementar estados Task, porque las funciones de Lambda sonfunciones sin estado (tienen una relación de entrada y salida predecible), son fáciles de programar y norequieren la implementación de código en una instancia de servidor. Puede escribir código en la Consolade administración de AWS o en el editor de su elección; AWS se encarga de proporcionar un entornoinformático para su función y de ejecutar el código.

Temas• Paso 1: Creación de un rol de IAM para Lambda (p. 9)• Paso 2: Creación de una función de Lambda (p. 9)• Paso 3: Comprobación de la función de Lambda (p. 10)• Paso 4: Creación de una máquina de estado (p. 11)• Paso 5: Inicio de una nueva ejecución (p. 12)

Paso 1: Creación de un rol de IAM para LambdaTanto Lambda como Step Functions pueden ejecutar código y obtener acceso a recursos de AWS (porejemplo, los datos almacenados en los buckets de Amazon S3). Para mantener la seguridad, debeconceder a Lambda y Step Functions acceso a esos recursos.

Lambda, requiere que se asigne un rol de IAM cuando al crear una función de Lambda, del mismo modoque Step Functions requiere que se asigne un rol de IAM al crear una máquina de estado.

Para crear un rol para LambdaPuede utilizar la consola de IAM para crear una función vinculada a un servicio.

Para crear un rol (consola)

1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en https://console.aws.amazon.com/iam/.

2. En el panel de navegación de la consola de IAM, elija Roles. A continuación, elija Create role.3. Elija el tipo de función Servicio de AWS y, a continuación, elija Lambda.4. Elija el caso de uso Lambda. Los casos de uso son definidos por el servicio de modo tal que ya

incluyen la política de confianza exigida por el servicio mismo. A continuación, elija Next: Permissions.5. Elija una o varias políticas de permisos para asociarlas al rol. Seleccione la casilla situada junto a la

política que asigna los permisos que desea que tenga el rol y, a continuación, elija Next: Review.6. Escriba un Role name.7. (Opcional) En Role description, edite la descripción del nuevo rol vinculado al servicio.8. Revise el rol y, a continuación, seleccione Create role.

Paso 2: Creación de una función de LambdaSu función de Lambda recibe una entrada (un nombre) y devuelve un saludo que incluye el valor deentrada.

9

https://console.aws.amazon.com/iam/

https://console.aws.amazon.com/iam/

AWS Step Functions Guía para desarrolladoresPaso 3: Comprobación de la función de Lambda

Para crear la función de LambdaImportant

Asegúrese de que la función de Lambda se encuentra en la misma cuenta y región de AWS quela máquina de estado.

1. Inicie sesión en la consola de Lambda y seleccione Create a function.2. En la sección Blueprints, elija Author from scratch.3. En la sección Basic information, configure la función de Lambda:

a. En Name, ingrese HelloFunction.b. En Role, seleccione Choose an existing role.c. En Existing role, seleccione el rol de Lambda que creó anteriormente (p. 9).

Note

Si el rol de IAM que creó no aparece en la lista, es posible que necesite unos minutospara que se propague a Lambda.

d. Elija Create function.

Una vez creada la función de Lambda, anote su Nombre de recurso de Amazon (ARN) en laesquina superior derecha de la página. Por ejemplo:

arn:aws:lambda:us-east-1:123456789012:function:HelloFunction

4. Copie el siguiente código de la función de Lambda en la sección Function code (Código de función) dela página HelloFunction (Función Hola):

exports.handler = (event, context, callback) => { callback(null, "Hello, " + event.who + "!");};

Este código crea un saludo utilizando el campo who de los datos de entrada, proporcionados por elobjeto event pasado a la función. Los datos de entrada de esta función se agregarán más tarde,cuando se inicie una nueva ejecución (p. 12). El método callback devuelve el saludo creado apartir de su función.

5. Seleccione Save.

Paso 3: Comprobación de la función de LambdaPruebe la función de Lambda para verla en acción.

Para comprobar la función de Lambda1. En la lista desplegable Select a test event (Seleccionar un evento de prueba), elija Configure test

event (Configurar evento de prueba) y escriba HelloFunction para Event name (Nombre deevento).

2. Sustituya los datos de ejemplo por lo siguiente:

{ "who": "AWS Step Functions"}

10

https://console.aws.amazon.com/lambda/home


La entrada "who" se corresponde con el campo event.who de su función de Lambda y completael saludo. Utilizará los mismos datos de entrada cuando ejecute la función como una tarea de StepFunctions.

3. Seleccione Create.4. En la página HelloFunction, con Test pruebe su función de Lambda utilizando los nuevos datos.

Los resultados de la prueba se muestran en la parte superior de la página. Amplíe Details (Detalles)para ver la salida.

Paso 4: Creación de una máquina de estadoUtilice la consola de Step Functions para crear una máquina de estado con un estado Task. Agregue unareferencia a la función Lambda del estado Task. La función Lambda se invoca cuando una ejecución de lamáquina de estado alcanza el estado Task.

Para crear la máquina de estado1. Inicie sesión en la consola de Step Functions y elija Create a state machine (Crear una máquina de

estado).2. En la página Create a state machine (Crear una máquina de estado), seleccione Author from scratch

(Crear desde cero) e introduzca un Name your state machine (Nombre para la máquina de estado),por ejemplo, LambdaStateMachine.

Note

Los nombres de la máquina de estado deben tener entre 1 y 80 caracteres, deben ser únicosen la cuenta y la región, y no deben incluir ninguno de los caracteres siguientes:

• Espacios en blanco• Caracteres comodín (? *)• Caracteres de corchetes (< > { } [ ])• Caracteres especiales (: ; , \ | ^ ~ $ # % & ` ")• Caracteres de control (\\u0000 - \\u001f o \\u007f - \\u009f).


3. Cree o especifique un rol de IAM.



Note

Si elimina el rol de IAM que crea Step Functions, Step Functions no podrá volver a crearlomás adelante. Asimismo, si modifica el rol (por ejemplo, eliminando Step Functions de la

11




entidad principal de la política de IAM), Step Functions no podrá restablecer su configuraciónoriginal más adelante.

4. En el panel State machine definition (Definición de máquina de estado), agregue la siguiente definiciónde máquina de estado utilizando el ARN de la función Lambda que creó anteriormente (p. 10), porejemplo:

{ "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HelloFunction", "End": true } }}

Esta es una descripción de la máquina de estado realizada mediante el Lenguaje de estados deAmazon. Define un único estado Task llamado HelloWorld. Para obtener más información, consulteEstructura de las máquinas de estado (p. 89).

Note

También puede configurar Retry para los estados Task. Use la práctica recomendada deasegurarse de que el código de producción controle las excepciones del servicio de Lambda(Lambda.ServiceException y Lambda.SdkclientException). Para obtener másinformación, consulte:

• Control de excepciones de servicio en Lambda (p. 111).• Reintento después de un error (p. 75).


Si no ve el gráfico, seleccione en el panel Visual Workflow.6. Seleccione Create State Machine.


Para iniciar una nueva ejecución1. En la página LambdaStateMachine, seleccione Start execution (Iniciar ejecución).

12

AWS Step Functions Guía para desarrolladoresCreación de una máquina de estado

Lambda mediante AWS CloudFormation

Aparece la página New execution.2. (Opcional) Para ayudar a identificar la ejecución, puede especificar un ID en el recuadro Enter an


Note


3. En el área de entrada de ejecución, sustituya los datos de ejemplo por lo siguiente:

{ "who" : "AWS Step Functions"}

"who" es el nombre de clave que su función de Lambda utiliza para obtener el nombre de la personaa la que se saluda.

4. Seleccione Start Execution (Iniciar ejecución).


5. Para ver los resultados de la ejecución, expanda la sección Output (Salida) en la sección Executiondetails (Detalles de la ejecución).

Creación de una máquina de estado Lambdamediante AWS CloudFormation

En este tutorial se muestra cómo crear una función AWS Lambda básica e iniciar la ejecución deuna máquina de estado de forma automática. Utilizará la consola de AWS CloudFormation y unaplantilla YAML para crear la pila (roles de IAM, la función de Lambda y la máquina de estado). Acontinuación, utilizará la consola de AWS Step Functions para iniciar la ejecución de la máquina de estado.Para obtener más información, consulte Trabajo con plantillas de AWS CloudFormation y el recursoAWS::StepFunctions::StateMachine en la Guía del usuario de AWS CloudFormation.

Temas• Paso 1: Configuración de la plantilla de AWS CloudFormation (p. 14)• Paso 2: Uso de la plantilla de AWS CloudFormation para crear una máquina de estado

Lambda (p. 17)• Paso 3: Inicio de la ejecución de una máquina de estado (p. 20)

13

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html

AWS Step Functions Guía para desarrolladoresPaso 1: Configuración de la

plantilla de AWS CloudFormation

Paso 1: Configuración de la plantilla de AWSCloudFormationAntes de utilizar la plantilla YAML de ejemplo (p. 17), debe conocer sus elementos.

Para crear un rol de IAM para LambdaDefina la política de confianza asociada al rol de IAM para la función de Lambda.

YAML

LambdaExecutionRole: Type: "AWS::IAM::Role" Properties: AssumeRolePolicyDocument: Version: "2012-10-17" Statement: - Effect: Allow Principal: Service: lambda.amazonaws.com Action: "sts:AssumeRole"

JSON

"LambdaExecutionRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } }

Para crear una función de LambdaDefina las siguientes propiedades de la función de Lambda que muestra el mensaje Hello World.

Important


YAML

MyLambdaFunction: Type: "AWS::Lambda::Function" Properties: Handler: "index.handler" Role: !GetAtt [ LambdaExecutionRole, Arn ] Code: ZipFile: |

14



exports.handler = (event, context, callback) => { callback(null, "Hello World!"); }; Runtime: "nodejs4.3" Timeout: "25"

JSON

"MyLambdaFunction": { "Type": "AWS::Lambda::Function", "Properties": { "Handler": "index.handler", "Role": { "Fn::GetAtt": [ "LambdaExecutionRole", "Arn" ] }, "Code": { "ZipFile": "exports.handler = (event, context, callback) => {\n callback(null, \"Hello World!\");\n};\n" }, "Runtime": "nodejs4.3", "Timeout": "25" } },

Para crear un rol de IAM para la ejecución de la máquina deestadoDefina la política de confianza asociada al rol de IAM para la ejecución de la máquina de estado.

YAML

StatesExecutionRole: Type: "AWS::IAM::Role" Properties: AssumeRolePolicyDocument: Version: "2012-10-17" Statement: - Effect: "Allow" Principal: Service: - !Sub states.${AWS::Region}.amazonaws.com Action: "sts:AssumeRole" Path: "/" Policies: - PolicyName: StatesExecutionPolicy PolicyDocument: Version: "2012-10-17" Statement: - Effect: Allow Action: - "lambda:InvokeFunction" Resource: "*"

JSON

"StatesExecutionRole": { "Type": "AWS::IAM::Role",

15



"Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ { "Fn::Sub": "states.${AWS::Region}.amazonaws.com" } ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "StatesExecutionPolicy", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": "*" } ] } } ] } },

Para crear una máquina de estado LambdaDefina la máquina de estado Lambda.

YAML

MyStateMachine: Type: "AWS::StepFunctions::StateMachine" Properties: DefinitionString: !Sub - |- { "Comment": "A Hello World AWL example using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "${lambdaArn}", "End": true } } } - {lambdaArn: !GetAtt [ MyLambdaFunction, Arn ]}

16

AWS Step Functions Guía para desarrolladoresPaso 2: Uso de la plantilla de AWS CloudFormation

para crear una máquina de estado Lambda

RoleArn: !GetAtt [ StatesExecutionRole, Arn ]

JSON

"MyStateMachine": { "Type": "AWS::StepFunctions::StateMachine", "Properties": { "DefinitionString": { "Fn::Sub": [ "{\n \"Comment\": \"A Hello World AWL example using an AWS Lambda function\",\n \"StartAt\": \"HelloWorld\",\n \"States\": {\n \"HelloWorld\": {\n \"Type\": \"Task\",\n \"Resource\": \"${lambdaArn}\",\n \"End\": true\n }\n }\n}", { "lambdaArn": { "Fn::GetAtt": [ "MyLambdaFunction", "Arn" ] } } ] }, "RoleArn": { "Fn::GetAtt": [ "StatesExecutionRole", "Arn" ] } } }

Paso 2: Uso de la plantilla de AWS CloudFormationpara crear una máquina de estado LambdaDespués de conocer las distintas partes de la plantilla de AWS CloudFormation, puede unirlas y usar laplantilla para crear una pila de AWS CloudFormation.

Para crear la máquina de estado Lambda1. Copie los datos del siguiente ejemplo en un archivo denominado MyStateMachine.yaml para el

ejemplo de YAML o MyStateMachine.json para el de JSON.

YAML

AWSTemplateFormatVersion: "2010-09-09"Description: "An example template with an IAM role for a Lambda state machine."Resources: LambdaExecutionRole: Type: "AWS::IAM::Role" Properties: AssumeRolePolicyDocument: Version: "2012-10-17" Statement: - Effect: Allow Principal: Service: lambda.amazonaws.com Action: "sts:AssumeRole"

17



MyLambdaFunction: Type: "AWS::Lambda::Function" Properties: Handler: "index.handler" Role: !GetAtt [ LambdaExecutionRole, Arn ] Code: ZipFile: | exports.handler = (event, context, callback) => { callback(null, "Hello World!"); }; Runtime: "nodejs4.3" Timeout: "25"

StatesExecutionRole: Type: "AWS::IAM::Role" Properties: AssumeRolePolicyDocument: Version: "2012-10-17" Statement: - Effect: "Allow" Principal: Service: - !Sub states.${AWS::Region}.amazonaws.com Action: "sts:AssumeRole" Path: "/" Policies: - PolicyName: StatesExecutionPolicy PolicyDocument: Version: "2012-10-17" Statement: - Effect: Allow Action: - "lambda:InvokeFunction" Resource: "*"

MyStateMachine: Type: "AWS::StepFunctions::StateMachine" Properties: DefinitionString: !Sub - |- { "Comment": "A Hello World AWL example using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "${lambdaArn}", "End": true } } } - {lambdaArn: !GetAtt [ MyLambdaFunction, Arn ]} RoleArn: !GetAtt [ StatesExecutionRole, Arn ]

JSON

{ "AWSTemplateFormatVersion": "2010-09-09", "Description": "An example template with an IAM role for a Lambda state machine.", "Resources": { "LambdaExecutionRole": { "Type": "AWS::IAM::Role",

18



"Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" } ] } } }, "MyLambdaFunction": { "Type": "AWS::Lambda::Function", "Properties": { "Handler": "index.handler", "Role": { "Fn::GetAtt": [ "LambdaExecutionRole", "Arn" ] }, "Code": { "ZipFile": "exports.handler = (event, context, callback) => {\n callback(null, \"Hello World!\");\n};\n" }, "Runtime": "nodejs4.3", "Timeout": "25" } }, "StatesExecutionRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ { "Fn::Sub": "states.${AWS::Region}.amazonaws.com" } ] }, "Action": "sts:AssumeRole" } ] }, "Path": "/", "Policies": [ { "PolicyName": "StatesExecutionPolicy", "PolicyDocument": { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": "*"

19

AWS Step Functions Guía para desarrolladoresPaso 3: Inicio de la ejecución de una máquina de estado

} ] } } ] } }, "MyStateMachine": { "Type": "AWS::StepFunctions::StateMachine", "Properties": { "DefinitionString": { "Fn::Sub": [ "{\n \"Comment\": \"A Hello World AWL example using an AWS Lambda function\",\n \"StartAt\": \"HelloWorld\",\n \"States\": {\n \"HelloWorld\": {\n \"Type\": \"Task\",\n \"Resource\": \"${lambdaArn}\",\n \"End\": true\n }\n }\n}", { "lambdaArn": { "Fn::GetAtt": [ "MyLambdaFunction", "Arn" ] } } ] }, "RoleArn": { "Fn::GetAtt": [ "StatesExecutionRole", "Arn" ] } } } }}

2. Inicie sesión en la consola de AWS CloudFormation y elija Create Stack.3. En la página Select Template, seleccione Upload a template to Amazon S3. Elija su archivo

MyStateMachine y después elija Next.4. En la página Specify Details, para Stack name, escriba MyStateMachine y después elija Next.5. En la página Options, seleccione Next.6. En la página Review, elija I acknowledge that AWS CloudFormation might create IAM resources. y

después elija Create.

AWS CloudFormation empieza a crear la pila MyStateMachine y muestra el estadoCREATE_IN_PROGRESS. Cuando el proceso se haya completado, AWS CloudFormation mostrará elestado CREATE_COMPLETE.

7. (Opcional) Para mostrar los recursos de la pila, seleccione la pila y elija la pestaña Resources.

Paso 3: Inicio de la ejecución de una máquina deestadoDespués de crear la máquina de estado Lambda, puede iniciar una ejecución.

20

https://console.aws.amazon.com/cloudformation/home

AWS Step Functions Guía para desarrolladoresCreación de una máquina de estado de actividades

Para iniciar la ejecución de la máquina de estado1. Inicie sesión en la consola de Step Functions y elija el nombre de la máquina de estado que creó

mediante AWS CloudFormation.2. En la página MyStateMachine-ABCDEFGHIJ1K, seleccione New execution.



Note





6. Para ver los resultados de la ejecución, elija la pestaña Output.

Creación de una máquina de estado de actividadesPuede coordinar el código de tareas en su máquina de estado. En este tutorial, se explica cómo se creauna máquina de estado basada en actividades utilizando Java y AWS Step Functions.

Para completar este tutorial, necesitará lo siguiente:

• SDK para Java. La actividad que se utiliza como ejemplo en este tutorial es una aplicación de Java queutiliza AWS SDK for Java para comunicarse con AWS.

• Las credenciales de AWS del entorno o del archivo de configuración estándar de AWS. Para obtenermás información, consulte Set up Your AWS credentials en la AWS SDK for Java Developer Guide.

Temas• Paso 1: Creación de una nueva actividad (p. 21)• Paso 2: Creación de una máquina de estado (p. 22)• Paso 3: Implementación de un proceso de trabajo (p. 23)• Paso 4: Inicio de una ejecución (p. 25)• Paso 5: Ejecución y detención del proceso de trabajo (p. 26)

Paso 1: Creación de una nueva actividadTiene que conseguir que Step Functions reconozca la actividad cuyo proceso de trabajo (programa) deseacrear. Step Functions responderá con un ARN que establece una identidad para la actividad. Debe usaresta identidad para coordinar la información que se pasa entre la máquina de estado y el proceso detrabajo.

21


https://aws.amazon.com/sdk-for-java/

https://docs.aws.amazon.com/AWSSdkDocsJava/latest/DeveloperGuide/set-up-creds.html


Important

Asegúrese de que la tarea de actividad se encuentra en la misma cuenta de AWS que la máquinade estado.

Para crear la tarea de la nueva actividad1. En la consola de Step Functions, elija Activities (Actividades) en el panel de navegación izquierdo.2. Seleccione Create activity (Crear actividad).3. Escriba un valor en Activity Name (Nombre de actividad). Por ejemplo, get-greeting, y elija Create

Activity (Crear actividad).4. Cuando se cree la tarea de actividad, anote su Nombre de recurso de Amazon (ARN), por ejemplo:

arn:aws:states:us-east-1:123456789012:activity:get-greeting

Paso 2: Creación de una máquina de estadoCree una máquina de estado que determine cuándo se va a invocar la actividad y cuándo el proceso detrabajo debe realizar el trabajo principal, recopilar los resultados y devolverlos.

Para crear la máquina de estado1. En la consola de Step Functions, elija State machines (Máquinas de estado) en el panel de

navegación izquierdo.2. En la página State machines (Máquinas de estado), elija Create state machine (Crear máquina de

estado), seleccione Author from scratch (Crear de cero) y escriba un nombre en Details (Detalles) (porejemplo, ActivityStateMachine).

Note







22



AWS Step Functions Guía para desarrolladoresPaso 3: Implementación de un proceso de trabajo

Note


4. En State machine definition (Definición de máquina de estado), escriba el siguiente código e incluya elARN de la tarea de actividad que creó anteriormente (p. 22) en el campo Resource; por ejemplo:

{ "Comment": "An example using a Task state.", "StartAt": "getGreeting", "Version": "1.0", "TimeoutSeconds": 300, "States": { "getGreeting": { "Type": "Task", "Resource": "arn:aws:states:us-east-1:123456789012:activity:get-greeting", "End": true } }}

Esta es una descripción de la máquina de estado realizada mediante el Lenguaje de estados deAmazon. Define un único estado Task llamado getGreeting. Para obtener más información,consulte Estructura de las máquinas de estado (p. 89).



Se crea la máquina de estado y se muestra una página de confirmación.

Paso 3: Implementación de un proceso de trabajoCree un proceso de trabajo; es decir, un programa que sea responsable de lo siguiente:

• Sondear Step Functions en busca de actividades mediante la acción de API GetActivityTask.• Realizar el trabajo de la actividad a través del código (por ejemplo, el método getGreeting() del

código siguiente).• Devolver los resultados a través de las acciones de API SendTaskSuccess, SendTaskFailure ySendTaskHeartbeat.

23

AWS Step Functions Guía para desarrolladoresPaso 3: Implementación de un proceso de trabajo

Note

Para ver un ejemplo de un proceso de trabajo de actividad más completo, consulte Ejemplo deproceso de trabajo de actividad en Ruby (p. 57). Este ejemplo proporciona una implementaciónbasada en prácticas recomendadas que se puede utilizar como referencia para la creación deprocesos de trabajo de actividad. El código implementa un patrón consumidor-productor con unnúmero configurable de subprocesos para sondeadores y procesos de trabajo de actividad.

Para implementar el proceso de trabajo1. Cree un nuevo archivo llamado GreeterActivities.java.2. Agréguele el siguiente código:

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()));

24

AWS Step Functions Guía para desarrolladoresPaso 4: Inicio de una ejecución

} } else { Thread.sleep(1000); } } }}

Note

La clase EnvironmentVariableCredentialsProvider de este ejemplo presupone quese han establecido las variables de entorno AWS_ACCESS_KEY_ID (o AWS_ACCESS_KEY) yAWS_SECRET_KEY (o AWS_SECRET_ACCESS_KEY). Si necesita más información acerca decómo proporcionar las credenciales necesarias a la fábrica, consulte AWSCredentialsProvideren la AWS SDK for Java API Reference y Set up AWS Credentials and Region forDevelopment en la AWS SDK for Java Developer Guide.Para que Step Functions tenga tiempo suficiente para procesar la solicitud,setSocketTimeout está establecido en 70 segundos.

3. En la lista de parámetros del constructor GetActivityTaskRequest().withActivityArn(),sustituya el valor ACTIVITY_ARN por el ARN de la tarea de actividad que creóanteriormente (p. 22).

Paso 4: Inicio de una ejecuciónCuando se inicia la ejecución de la máquina de estado, el proceso de trabajo sondea Step Functions enbusca de actividades, realiza su trabajo (utilizando los datos de entrada proporcionados) y devuelve losresultados.

Para iniciar la ejecución1. En la página ActivityStateMachine, seleccione Start execution (Iniciar ejecución).



Note


3. En el área de entrada de ejecución, sustituya los datos de ejemplo por lo siguiente:

{ "who" : "AWS Step Functions"}



5. En la sección Execution Details, seleccione Info para ver el valor de Execution Status y las marcastemporales Started y Closed.

25

https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/auth/AWSCredentialsProvider.html

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html

AWS Step Functions Guía para desarrolladoresPaso 5: Ejecución y detención del proceso de trabajo

6. En la sección Execution Details (Detalles de ejecución), expanda la sección Output (Salida) para ver lasalida de su flujo de trabajo.

Paso 5: Ejecución y detención del proceso de trabajoPara que el proceso de trabajo pueda sondear la máquina de estado en busca de actividades, esnecesario ejecutarlo.

Note

Una vez que se completa la ejecución, el proceso de trabajo debe detenerse. De lo contrario,seguirá ejecutándose y buscando actividades. Si se detiene la ejecución, el proceso de trabajono tiene ningún origen de tareas y genera una excepción SocketTimeoutException en cadasondeo.

Para ejecutar y detener el proceso de trabajo1. En la línea de comandos, vaya al directorio en el que creó GreeterActivities.java.2. Si desea utilizar el SDK de AWS, agregue la ruta completa de los directorios lib y third-party a

las dependencias del archivo de compilación y a CLASSPATH de Java. Para obtener más información,consulte Downloading and Extracting the SDK en la AWS SDK for Java Developer Guide.

3. Compile el archivo:

$ javac GreeterActivities.java

4. Ejecute el archivo:

$ java GreeterActivities

5. En la consola de Step Functions, navegue a la página Execution Details.6. Cuando se complete la ejecución, seleccione Output para ver los resultados de la ejecución.7. Detenga el proceso de trabajo.

Administración de las condiciones de error con unamáquina de estado

En este tutorial, crea una máquina de estado de AWS Step Functions con un campo Catch que utilizauna función AWS Lambda para responder con lógica condicional en función del tipo de mensaje de error,un método que se denomina gestión de errores de funciones. Para obtener más información, consulteFunction Error Handling en la AWS Lambda Developer Guide.

Note

También puede crear máquinas de estado que ejecuten acciones Retry en los tiempos deespera o que usen Catch para adoptar un estado específico cuando se produce un error o seagota un tiempo de espera. Para ver ejemplos de estas técnicas de administración, consulteEjemplos sobre el uso de Retry y Catch (p. 78).

Temas• Paso 1: Creación de un rol de IAM para Lambda (p. 27)• Paso 2: Creación de una función de Lambda que no funciona correctamente (p. 27)

26

https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-install.html#download-and-extract-sdk


https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-mode-exceptions.html#nodejs-prog-model-custom-exceptions

AWS Step Functions Guía para desarrolladoresPaso 1: Creación de un rol de IAM para Lambda

• Paso 3: Comprobación de la función de Lambda (p. 28)• Paso 4: Creación de una máquina de estado con un campo Catch (p. 28)• Paso 5: Inicio de una nueva ejecución (p. 31)

Paso 1: Creación de un rol de IAM para LambdaTanto Lambda como Step Functions pueden ejecutar código y obtener acceso a recursos de AWS (porejemplo, los datos almacenados en los buckets de Amazon S3). Para mantener la seguridad, debeconceder a Lambda y Step Functions acceso a esos recursos.

Lambda, requiere que se asigne un rol de IAM cuando al crear una función de Lambda, del mismo modoque Step Functions requiere que se asigne un rol de IAM al crear una máquina de estado.

Para crear un rol para Lambda1. Inicie sesión en la consola de IAM y elija Funciones, Crear función.2. En la página Select type of trusted entity, en Servicio de AWS, seleccione Lambda en la lista y haga

clic en Siguiente: Permisos.

Note

De forma automática, el rol se proporciona con una relación de confianza que permite aLambda utilizar el rol.

3. En la página Attach permissions policy, elija Next: Review.4. En la página Revisar, escriba MyLambdaRole para Nombre de la función y después elija Crear

función.

El rol de IAM se muestra en la lista de roles.

Paso 2: Creación de una función de Lambda que nofunciona correctamenteUtilice una función de Lambda para simular una condición de error.

Important


Para crear una función de Lambda que no funcionacorrectamente1. Inicie sesión en la consola de Lambda y seleccione Create a function.2. En la sección Blueprints, escriba step-functions en el filtro y, a continuación, seleccione el

proyecto step-functions-error.3. En la sección Basic information, configure la función de Lambda:

a. En Name, ingrese FailFunction.b. En Role, seleccione Choose an existing role.c. En Existing role, seleccione el rol de Lambda que creó anteriormente (p. 27).

27

https://console.aws.amazon.com/iam/home



Note


4. El código siguiente aparece en el panel Lambda function code:

'use strict';

exports.handler = (event, context, callback) => { function CustomError(message) { this.name = 'CustomError'; this.message = message; } CustomError.prototype = new Error();

const error = new CustomError('This is a custom error!'); callback(error);};

El objeto context devuelve el mensaje de error This is a custom error!5. Elija Create function.

Una vez creada la función de Lambda, anote su Nombre de recurso de Amazon (ARN) en la esquinasuperior derecha de la página. Por ejemplo:

arn:aws:lambda:us-east-1:123456789012:function:FailFunction

Paso 3: Comprobación de la función de LambdaPruebe la función de Lambda para verla en acción.

Para comprobar la función de Lambda1. En la página FailFunction, elija Test.2. En el cuadro de diálogo Configure test event, escriba FailFunction para Event name y, a

continuación, elija Create.3. En la página FailFunction, Test su función de Lambda.

Los resultados de la prueba (el error simulado) se muestran en la parte inferior de la página.

Paso 4: Creación de una máquina de estado con uncampo CatchUtilice la consola de Step Functions para crear una máquina de estado que utilice un estado Task conun campo Catch. Agregue una referencia a la función Lambda del estado Task. Se invoca la función deLambda, que experimenta un error durante su ejecución. Step Functions reintenta la función dos vecesutilizando un retardo exponencial entre los reintentos.

Para crear la máquina de estado1. Inicie sesión en la consola de Step Functions y elija Create state machine (Crear una máquina de

estado).

28



AWS Step Functions Guía para desarrolladoresPaso 4: Creación de una máquinade estado con un campo Catch

2. En la página Create a state machine (Crear una máquina de estado), seleccione Templates (Plantillas)y elija Catch failure (Capturar errores).

3. Asigne un nombre a la máquina de estado en el campo Name your state machine, por ejemplo,CatchStateMachine.

Note







Note


5. En el panel Code, añada el ARN de la función de Lambda que creó anteriormente (p. 27) en elcampo Resource, por ejemplo:

{ "Comment": "A Catch example of the Amazon States Language using an AWS Lambda function", "StartAt": "CreateAccount", "States": { "CreateAccount": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction", "Catch": [ { "ErrorEquals": ["CustomError"], "Next": "CustomErrorFallback" }, { "ErrorEquals": ["States.TaskFailed"],

29

AWS Step Functions Guía para desarrolladoresPaso 4: Creación de una máquinade estado con un campo Catch

"Next": "ReservedTypeFallback" }, { "ErrorEquals": ["States.ALL"], "Next": "CatchAllFallback" } ], "End": true }, "CustomErrorFallback": { "Type": "Pass", "Result": "This is a fallback from a custom Lambda function exception", "End": true }, "ReservedTypeFallback": { "Type": "Pass", "Result": "This is a fallback from a reserved error code", "End": true }, "CatchAllFallback": { "Type": "Pass", "Result": "This is a fallback from any error code", "End": true } }}

Esta es una descripción de la máquina de estado mediante el Lenguaje de estados de Amazon.Define un único estado Task llamado CreateAccount. Para obtener más información, consulteEstructura de las máquinas de estado (p. 89).

Para obtener más información sobre la sintaxis del campo Retry, consulte Reintento después de unerror (p. 106).

Note

Los errores no administrados de Lambda se indican como Lambda.Unknown en la salida deerrores. Incluyen errores de falta de memoria, tiempos de espera de funciones agotados yalcanzar el límite de invocaciones de Lambda simultáneas. Puede buscar correspondenciascon Lambda.Unknown, States.ALL o States.TaskFailed para administrar estoserrores. Para obtener más información sobre los errores Handled y Unhandled de Lambda,consulte FunctionError en la AWS Lambda Developer Guide.



30

https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_ResponseSyntax



Para iniciar una nueva ejecución1. En la página CatchStateMachine, seleccione New execution.



Note




4. En la sección Execution Details (Detalles de ejecución), expanda la sección Output (Salida) para ver lasalida de su flujo de trabajo.

5. Para ver el mensaje de error personalizado, seleccione CreateAccount en Visual workflow (Flujo detrabajo visual) y expanda la sección Output (Salida).

31

AWS Step Functions Guía para desarrolladoresIniciar la ejecución de una máquina de

estado con Eventos de CloudWatch

Note

Puede conservar la entrada de estado junto con el error utilizando ResultPath. ConsulteUtilice ResultPath para incluir error y entrada en un Catch (p. 72)

Iniciar la ejecución de una máquina de estado conEventos de CloudWatch

Puede ejecutar una máquina de estado de Step Functions en respuesta a un patrón de eventos o conarreglo a una programación a través de Amazon CloudWatch Events. En este tutorial, aprenderá aconfigurar una máquina de estado como destino de una regla de Eventos de CloudWatch que inicia laejecución de la máquina cada 5 minutos.

Para obtener más información sobre la configuración de una máquina de estado de Step Functions comodestino mediante la acción de API PutTarget de Amazon CloudWatch Events, consulte Agregar unamáquina de estado de Step Functions como destino.

Temas• Paso 1: Creación de una máquina de estado (p. 32)• Paso 2: Creación de un regla de Eventos de CloudWatch (p. 32)

Paso 1: Creación de una máquina de estadoPara poder establecer un destino de Eventos de CloudWatch, debe crear una maquina de estado.

• Para crear una máquina de estado básica, utilice el tutorial Getting Started (p. 3).• Si ya tiene una maquina de estado, vaya al siguiente paso.

Paso 2: Creación de un regla de Eventos deCloudWatchDespués de crear la máquina de estado, puede crear la regla de Eventos de CloudWatch.

Para crear la regla1. Vaya a la consola de CloudWatch Events, seleccione Events y haga clic en Create Rule.

Aparece la página Step 1: Create rule.2. En la sección Event source, seleccione Schedule y escriba 5 en Fixed rate of.

32

https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutTargets.html#API_PutTargets_Example_Adds_a_Step_Functions_state_machine_as_a_target

https://docs.aws.amazon.com/AmazonCloudWatchEvents/latest/APIReference/API_PutTargets.html#API_PutTargets_Example_Adds_a_Step_Functions_state_machine_as_a_target

https://console.aws.amazon.com/cloudwatch/

AWS Step Functions Guía para desarrolladoresPaso 2: Creación de un regla de Eventos de CloudWatch

3. En la sección Targets, seleccione Add target y elija Step Functions state machine en la lista.

4. Eventos de CloudWatch pueden crear el rol de IAM necesario para que se ejecute su evento:

• Para crear un rol de IAM automáticamente, seleccione Create a new role for this specific resource.• Para utilizar un rol de IAM que haya creado antes, elija Use existing role.

5. Seleccione Configure details.

Aparece la página Step 2: Configure rule details.6. Escriba un nombre Name para su regla (por ejemplo, statemachine-event), elija Enabled para

State y, a continuación, elija Create rule.

33

AWS Step Functions Guía para desarrolladoresCreación de una API de Step

Functions mediante API Gateway

Se crea la regla y se abre la página Rules, donde aparecen todas las reglas de Eventos deCloudWatch.

Cada 5 minutos se iniciará una nueva ejecución de la máquina de estado.

Creación de una API de Step Functions medianteAPI Gateway

Puede utilizar Amazon API Gateway para asociar sus API de AWS Step Functions con métodos de unaAPI de API Gateway, de forma que, cuando se envíe una solicitud HTTPS a un método de API, APIGateway invoque sus acciones de API de Step Functions.

En este tutorial se muestra cómo crear una API que utilice un recurso y el método POST para comunicarsecon la acción de la API StartExecution. Utilizará la consola de IAM para crear un rol para API Gateway.A continuación, usará la consola de API Gateway para crear una API de API Gateway, crear un recursoy un método y asignar el método a la acción de la API StartExecution. Por último, implementará yprobará su API. Para obtener más información sobre esta acción de API, consulte StartExecution en laReferencia de la API de AWS Step Functions.

Temas• Paso 1: Creación de un rol de IAM para API Gateway (p. 35)• Paso 2: Creación de la API de API Gateway (p. 35)• Paso 3: Comprobación e implementación de la API de API Gateway (p. 37)

34

https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html

AWS Step Functions Guía para desarrolladoresPaso 1: Creación de un rol de IAM para API Gateway

Paso 1: Creación de un rol de IAM para API GatewayAntes de crear su API de API Gateway, debe conceder a API Gateway permiso para llamar a las accionesde API de Step Functions.

Para crear un rol para API Gateway1. Inicie sesión en la consola de IAM y elija Roles, Create role.2. En la página Select type of trusted entity, en AWS service, seleccione API Gateway en la lista y haga

clic en Next: Permissions.3. En la página Attached permissions policy, elija Next: Review.4. En la página Review, escriba APIGatewayToStepFunctions en Role name y después elija Create

role.

El rol de IAM se muestra en la lista de roles.5. Elija el nombre del rol y anote el valor de Role ARN, por ejemplo:

arn:aws:iam::123456789012:role/APIGatewayToStepFunctions

Para asociar una política al rol de IAM1. En la página Roles, busque el rol (APIGatewayToStepFunctions) y selecciónelo.2. En la pestaña Permissions, elija Attach Policy.3. En la página Attach Policy, busque AWSStepFunctionsFullAccess, elija la política y después elija

Attach Policy.

Paso 2: Creación de la API de API GatewayDespués de crear el rol de IAM, puede crear su API de API Gateway personalizada.

Para crear la API1. Vaya a Amazon API Gateway console y seleccione Get Started.2. En la página Create new API, elija New API.3. En la sección Settings, escriba StartExecutionAPI para API name y, a continuación, elija Create

API.

Para crear un recurso1. En la página Resources de StartExecutionAPI, elija Actions, Create Resource.2. En la página New Child Resource, escriba execution para Resource Name y después elija Create

Resource.

Para crear un método POST1. En la página /execution Methods, elija Actions, Create Method.2. En la lista, elija POST y seleccione la marca de verificación.

35


https://console.aws.amazon.com/apigateway/

AWS Step Functions Guía para desarrolladoresPaso 2: Creación de la API de API Gateway

Para configurar el métodoEn la página /execution - POST - Setup, configure el punto de integración del método.

1. En Integration Type, elija AWS Service.2. En AWS Region, elija una región de la lista.

Note

Para conocer las regiones que admite actualmente Step Functions, consulte Regionesadmitidas (p. 1).

3. En AWS Service, elija Step Functions de la lista.4. En HTTP Method, elija POST de la lista.

Note

Todas las acciones de la API de Step Functions utilizan el método POST HTTP.5. En Action Type, elija Use action name.6. En Action, escriba StartExecution.7. En Execution Role, escriba el ARN del rol de IAM que creó anteriormente (p. 35), por ejemplo:

arn:aws:iam::123456789012:role/APIGatewayToStepFunctions

36

AWS Step Functions Guía para desarrolladoresPaso 3: Comprobación e implementación

de la API de API Gateway

8. Seleccione Save.

La correspondencia visual entre API Gateway y Step Functions se muestra en la página /execution -POST - Method Execution.

Paso 3: Comprobación e implementación de la API deAPI GatewayPara probar la comunicación entre API Gateway y Step Functions1. En la página /execution - POST - Method Execution, elija Test.

37

AWS Step Functions Guía para desarrolladoresPaso 3: Comprobación e implementación

de la API de API Gateway

2. En la página /execution - POST - Method Test, copie los siguientes parámetros de solicitud enla sección Request Body usando el ARN de una máquina de estado existente (o cree una nuevamáquina de estado (p. 3)) y, a continuación, elija Test.

{ "input": "{}", "name": "MyExecution", "stateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:HelloWorld"}

Note

Para obtener más información consulte StartExecution Sintaxis de las solicitudes en laReferencia de la API de AWS Step Functions.Si no desea incluir el ARN de la máquina de estado en el cuerpo de la llamada a APIGateway, puede configurar una plantilla de asignación de cuerpo, como:

{ "input": "$util.escapeJavaScript($input.json('$'))", "stateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:HelloWorld"}

Este enfoque le permite disponer de diferentes máquinas de estado en función de las etapasde desarrollo (por ejemplo, dev, test y prod). Para lanzar una actualización, solo tiene quecambiar la variable de etapa, por ejemplo:

{ "input": "$util.escapeJavaScript($input.json('$'))", "stateMachineArn": "$util.escapeJavaScript($stageVariables.get(arn:aws:states:us-east-1:123456789012:stateMachine:HelloWorld))"}

3. La ejecución se inicia, y el ARN de ejecución y su fecha de inicio se muestran en Response Body.

{ "executionArn": "arn:aws:states:us-east-1:123456789012:execution:HelloWorld:MyExecution", "startDate": 1486768956.878}

Note

Puede ver la ejecución eligiendo su máquina de estado en la consola de AWS StepFunctions.

Para implementar su API1. En la página Resources de StartExecutionAPI, elija Actions, Deploy API.2. En el cuadro de diálogo Deploy API, seleccione [New Stage] en la lista Deployment stage, escriba

alpha en Stage name y, a continuación, elija Deploy.

38

https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html#API_StartExecution_RequestSyntax

https://console.aws.amazon.com/states/

https://console.aws.amazon.com/states/

AWS Step Functions Guía para desarrolladoresIteración de un bucle mediante Lambda

Para probar su implementación1. En la página Stages de StartExecutionAPI, expanda alpha, /, /execution, POST.2. En la página alpha - POST - /execution, anote el valor de Invoke URL, por ejemplo:

https://a1b2c3d4e5.execute-api.us-east-1.amazonaws.com/alpha/execution

3. Desde la línea de comandos, ejecute el comando curl utilizando el ARN de la máquina de estado y,a continuación, invoque la dirección URL de su implementación, por ejemplo:

curl -X POST -d '{"input": "{}","name": "MyExecution","stateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:HelloWorld"}' https://a1b2c3d4e5.execute-api.us-east-1.amazonaws.com/alpha/execution

Se devuelven el ARN de ejecución y su fecha de inicio, por ejemplo:

{"executionArn":"arn:aws:states:us-east-1:123456789012:execution:HelloWorld:MyExecution","startDate":1.486772644911E9}

Iteración de un bucle mediante LambdaEn este tutorial, implementará un patrón de diseño que utiliza una maquina de estado y una función deAWS Lambda para iterar un bucle un número específico de veces.

Utilice este patrón de diseño cada vez que necesite realizar un seguimiento del número de bucles en unamáquina de estado. Esta implementación puede ayudarle a desglosar tareas grandes o ejecuciones deejecución prolongada en trozos más pequeños o finalizar una ejecución después de un número específicode eventos. Puede utilizar una implementación similar para finalizar y reiniciar de forma periódica unaejecución de larga duración para evitar superar los límites de servicio para AWS Step Functions, AWSLambda u otros servicios de AWS.

Antes de comenzar, realice el tutorial Creación de una máquina de estado Lambda (p. 9) paraasegurarse de haber creado el rol de IAM necesario y estar familiarizado con el uso de Lambda y StepFunctions.

Temas• Paso 1: Creación de una función de Lambda para iterar un contador (p. 39)• Paso 2: Comprobación de la función de Lambda (p. 40)• Paso 3: Creación de una máquina de estado (p. 41)• Paso 4: Inicio de una nueva ejecución (p. 44)

Paso 1: Creación de una función de Lambda paraiterar un contadorAl utilizar una función de Lambda puede realizar un seguimiento de las iteraciones de un bucle en sumáquina de estado. La función de Lambda siguiente recibe valores de entrada de count, index y step.Devuelve estos valores con un valor de index y un valor booleano denominado continue actualizados.La función de Lambda establece continue en true si index es menor que count.

A continuación, la máquina de estado implementa un estado Choice que ejecuta una lógica de aplicaciónsi continue es trueo finaliza si es false.

39


Para crear la función de Lambda1. Inicie sesión en la consola de Lambda y, a continuación, elija Create function (Crear función).2. En la sección Create function (Crear función), elija Author from scratch (Crear desde cero).3. En la sección Author from scratch (Crear desde cero), configure la función de Lambda, tal y como se

indica a continuación:

a. En Name, ingrese Iterator.b. En Runtime (Tiempo de ejecución), seleccione Node.js 6.10.c. En Role, seleccione Choose an existing role.d. En Existing role (Rol existente), seleccione el rol de Lambda que creó en el tutorial Creación de

una máquina de estado Lambda (p. 9).

Note


e. Elija Create function.

Una vez creada la función de Lambda, tome nota de su Nombre de recurso de Amazon (ARN)que aparece en la esquina superior derecha de la página. Por ejemplo:

arn:aws:lambda:us-east-1:123456789012:function:Iterator

4. Copie el siguiente código de la función de Lambda en la sección Configuration (Configuración) de lapágina Iterator (Iterador) en la consola de Lambda.

exports.iterator = function iterator (event, context, callback) { let index = event.iterator.index let step = event.iterator.step let count = event.iterator.count index += step callback(null, { index, step, count, continue: index < count })}

Este código acepta los valores de entrada de count, index y step. Incrementa index en el valor destep y devuelve estos valores y el valor booleano de continue. El valor de continue es true siindex es menor que count.

5. Seleccione Save.

Paso 2: Comprobación de la función de LambdaEjecute su función de Lambda con valores numéricos para verla en acción. Puede proporcionar valores deentrada para la función de Lambda que imiten una iteración, para ver qué resultado se obtiene con valoresde entrada específicos.

40



Para comprobar la función de Lambda1. En el cuadro de diálogo Configure test event (Configurar evento de prueba), elija Create new test

event (Crear evento de prueba nuevo) y, a continuación, escriba TestIterator en Event name(Nombre del evento).

2. Sustituya los datos de ejemplo por lo siguiente.

{ "Comment": "Test my Iterator function", "iterator": { "count": 10, "index": 5, "step": 1 }}

Estos valores imitar lo que procederían de la máquina de estado durante una iteración. La función deLambda aumentará el índice y devolverá continue como true. Una vez que el índice no sea menorque count, devolverá continue como false. Para esta prueba, index ya se ha incrementado a 5.Los resultados deben incrementar el valor de index a 6 y establecer continue en true.

3. Seleccione Create.4. En la página Iterator (Iterador) en la consola de Lambda, asegúrese de que aparece TestIterator y,

a continuación, elija Test (Probar).

Los resultados de la prueba se muestran en la parte superior de la página. Elija Details (Detalles) yexamine el resultado.

{ "index": 6, "step": 1, "count": 10, "continue": true}

Note

Si establece index en 9 para esta prueba, index se incrementará a 10 y continue tendráel valor false.

Paso 3: Creación de una máquina de estadoPara crear la máquina de estado1. Inicie sesión en la consola de Step Functions y, a continuación, elija Create a state machine (Crear

una máquina de estado).

Important

Asegúrese de que la máquina de estado se encuentra en la misma cuenta de AWS y regiónque la función de Lambda que ha creado anteriormente.

2. En la página Create a state machine (Crear una máquina de estado), elija Author from scratch (Creardesde cero). En Give a name to your state machine (Asigne un nombre a la máquina de estado),introduzca IterateCount.

41



Note







Note


4. El siguiente código describe una máquina de estado con los siguientes estados:

• ConfigureCount: Establece los valores predeterminados para count, index y step.

"ConfigureCount": { "Type": "Pass", "Result": { "count": 10, "index": 0, "step": 1},

• Iterator: Hace referencia a la función de Lambda creada anteriormente, transfiriendo los valoresconfigurados en ConfigureCount.

"Iterator": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Iterate", "ResultPath": "$.iterator", "Next": "IsCountReached"},

• IsCountReached: Un estado de elección que ejecutará su trabajo de muestra de nuevo o pasará aDone en función de un valor booleano devuelto desde la función de Lambda Iterator.

42


"IsCountReached": { "Type": "Choice", "Choices": [ { "Variable": "$.iterator.continue", "BooleanEquals": true, "Next": "ExampleWork" } ], "Default": "Done"},

• ExampleWork: un stub para el trabajo que desea realizar en su ejecución. En este ejemplo es unestado pass. En una implementación real sería un estado task. Consulte Tareas (p. 56).

• Done: el estado final de la ejecución.

En el panel Code (Código), añada la siguiente definición de máquina de estado utilizando el Nombrede recurso de Amazon de la función de Lambda que creó anteriormente (p. 40).

{ "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:us-east-1: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",

43


"End": true } }}

Asegúrese de actualizar el Nombre de recurso de Amazon en el estado Iterator anterior deforma que haga referencia al Lambda creado anteriormente. Para obtener más información sobre elLenguaje de estados de Amazon, consulte Estructura de las máquinas de estado (p. 89).


Este gráfico muestra la lógica expresada en el código de la máquina de estado anterior.

Si no ve el gráfico, seleccione en el panel Visual Workflow.6. Seleccione Create State Machine.7. Seleccione Aceptar.

Se crea la máquina de estado y se muestra una página de confirmación.


Para iniciar una nueva ejecución1. En la página IterateCount, elija New execution (Nueva ejecución).2. (Opcional) Para ayudar a identificar la ejecución, puede especificar un ID en el recuadro Enter an


Note

Step Functions le permite crear una máquina de estado, una ejecución y nombres deactividad que contengan caracteres no ASCII. Estos nombres no ASCII no funcionan con

44


Amazon CloudWatch. Para asegurarse de que puede realizar un seguimiento de las métricasde CloudWatch, elija un nombre que solo use caracteres ASCII.


Se inicia una nueva ejecución de la máquina de estado, mostrando la ejecución en funcionamiento.

La ejecución se incrementa por pasos, y realiza el seguimiento del contador mediante la funciónde Lambda. En cada iteración, realiza el trabajo de ejemplo al que se hace referencia en el estadoExampleWork de la máquina de estado.


5. Una vez que el recuento alcanza el número configurado en el estado ConfigureCount de lamáquina de estado, la ejecución termina las iteraciones y finaliza.

45

AWS Step Functions Guía para desarrolladoresContinuar como una nueva ejecución

Continuar como una nueva ejecuciónAWS Step Functions se ha diseñado para ejecutar flujos de trabajo que tienen una duración y un númerode pasos finitos. Las ejecuciones se limitan a una duración de un año y un máximo de 25 000 eventos(consulte Límites (p. 112)). Sin embargo, puede crear una máquina de estado que utilice una funciónLambda para comenzar una nueva ejecución, antes de dejar que termine la actual. De este modo, puedetener una máquina de estado que puede dividir los trabajos grandes en flujos de trabajo más pequeños otener una máquina de estado que se ejecute de forma indefinida.

Este tutorial se basa en el concepto de utilizar una función Lambda externa para modificar el flujo detrabajo, que se presentó en el tutorial Iteración de un bucle mediante Lambda (p. 39). Utilizará la mismafunción Lambda (Iterator) para iterar por un bucle un número específico de veces. Además, crearáotra función Lambda para comenzar una nueva ejecución del flujo de trabajo y para reducir un contadorcada vez que comience una nueva ejecución. Al establecer el número de ejecuciones en la entrada, estamáquina de estado finalizará y reiniciará una ejecución un número específico de veces.

En este tutorial se muestra cómo crear una máquina de estado con una función Lambda que puedecomenzar una nueva ejecución, continuando el trabajo en curso en esa nueva ejecución.

46

AWS Step Functions Guía para desarrolladoresContinuar como una nueva ejecución

La máquina de estado que creará implementa los siguientes estados.

Estado Finalidad

ConfigureCount Un estado Pass (p. 91) que configura los valores count, indexy step que utiliza la función Lambda Iterator para recorrer lasiteraciones de trabajo.

Iterator Un estado Task (p. 92) que hace referencia a la función LambdaIterator.

IsCountReached Un estado Choice (p. 95) que usa un valor booleano de la funciónIterator para decidir si la máquina de estado debe continuar eltrabajo de ejemplo o cambiar al estado de elección ShouldRestart.

ExampleWork En este ejemplo, ExampleWork es un estado Pass que representa elestado Task que realizaría el trabajo en una implementación real.

ShouldRestart Un estado Choice (p. 95) que utiliza el valor executionCountpara decidir si debe finalizar una ejecución y comenzar otra, osimplemente finalizar.

Restart Un estado Task (p. 92) que usa una función Lambda paracomenzar una ejecución nueva de la máquina de estado. Al igual que lafunción Iterator, esta también disminuye un contador. Pasa ese valora la entrada de la nueva ejecución.

47

AWS Step Functions Guía para desarrolladoresRequisitos previos

Requisitos previosAntes de comenzar, realice el tutorial Creación de una máquina de estado Lambda (p. 9) paraasegurarse de haber creado un rol de IAM inicial y de que está familiarizado con el uso conjunto deLambda y Step Functions.

Temas• Paso 1: Creación de una función Lambda Iterate para iterar un contador (p. 48)• Paso 2: Creación de una función Lambda Restart para comenzar una nueva ejecución de Step

Functions (p. 50)• Paso 3: Creación de una máquina de estado (p. 51)• Paso 4: Actualización de la política de IAM (p. 53)• Paso 5: Comienzo de una ejecución (p. 53)

Paso 1: Creación de una función Lambda Iteratepara iterar un contador

Note

Si ha completado el tutorial Iteración de un bucle mediante Lambda (p. 39), puede omitir estepaso y utilizar esa función Lambda.

En esta sección y en el tutorial Iteración de un bucle mediante Lambda (p. 39) se muestra cómopuede usar una función Lambda para realizar el seguimiento de un contador para controlar el número deiteraciones de un bucle en su máquina de estado.

La función de Lambda siguiente recibe valores de entrada de count, index y step. Devuelve estosvalores con un valor de index y un valor booleano denominado continue actualizados. La función deLambda establece continue en true si index es menor que count.

A continuación, la máquina de estado implementa un estado Choice que ejecuta una lógica de aplicaciónsi continue es true, o cambia a ShouldRestart si continue es false.

Para crear la función Lambda Iterate1. Inicie sesión en la consola de Lambda y, a continuación, elija Create function (Crear función).2. En la sección Create function (Crear función), elija Author from scratch (Crear desde cero).3. En la sección Author from scratch (Crear desde cero), configure la función de Lambda, tal y como se


a. En Name, ingrese Iterator.b. En Runtime (Tiempo de ejecución), seleccione Node.js 6.10.c. En Role, seleccione Choose an existing role.d. En Existing role (Rol existente), seleccione el rol de Lambda que creó en el tutorial Creación de

una máquina de estado Lambda (p. 9).

Note


e. Elija Create function.

48


AWS Step Functions Guía para desarrolladoresPaso 1: Creación de una función Lambda

Iterate para iterar un contador


arn:aws:lambda:us-east-1:123456789012:function:Iterator

4. Copie el siguiente código de la función de Lambda en la sección Configuration (Configuración) de lapágina Iterator (Iterador) en la consola de Lambda.

exports.iterator = function iterator (event, context, callback) { let index = event.iterator.index let step = event.iterator.step let count = event.iterator.count index += step callback(null, { index, step, count, continue: index < count })}

Este código acepta los valores de entrada de count, index y step. Incrementa index en el valor destep y devuelve estos valores y el valor booleano de continue. El valor de continue es true siindex es menor que count.

5. Seleccione Save.

Probar la función Lambda IteratePara ver en acción la función Iterate, ejecútela con valores numéricos. Puede proporcionar valores deentrada para la función Lambda que imiten una iteración para ver qué resultado se obtiene con valores deentrada específicos.

Para comprobar la función de Lambda

1. En el cuadro de diálogo Configure test event (Configurar evento de prueba), elija Create new testevent (Crear evento de prueba nuevo) y, a continuación, escriba TestIterator en Event name(Nombre del evento).

2. Sustituya los datos de ejemplo por lo siguiente.

{ "Comment": "Test my Iterator function", "iterator": { "count": 10, "index": 5, "step": 1 }}

Estos valores imitar lo que procederían de la máquina de estado durante una iteración. La funciónLambda aumenta el índice y devuelve continue como true. Una vez que el índice no sea menorque count, devuelve continue como false. Para esta prueba, index ya se ha incrementado a 5.Los resultados deben incrementar el valor de index a 6 y establecer continue en true.

3. Seleccione Create.

49

AWS Step Functions Guía para desarrolladoresPaso 2: Creación de una función Lambda Restart

para comenzar una nueva ejecución de Step Functions

4. En la página Iterator (Iterador) en la consola de Lambda, asegúrese de que aparece TestIterator y,a continuación, elija Test (Probar).

Los resultados de la prueba se muestran en la parte superior de la página. Elija Details (Detalles) yexamine el resultado.

{ "index": 6, "step": 1, "count": 10, "continue": true}

Note

Si establece index en 9 para esta prueba, index se incrementa a 10 y continue tiene elvalor false.

Paso 2: Creación de una función Lambda Restartpara comenzar una nueva ejecución de StepFunctions1. Inicie sesión en la consola de Lambda y, a continuación, elija Create function (Crear función).2. En la sección Author from scratch (Crear desde cero), configure la función de Lambda, tal y como se


a. En Name, ingrese Restart.b. En Runtime (Tiempo de ejecución), seleccione Node.js 6.10.c. En Role, seleccione Choose an existing role.d. En Existing role (Rol existente), seleccione el rol que incluye la política de IAM que creó

anteriormente.e. Elija Create function.


arn:aws:lambda:us-east-1:123456789012:function:Restart

3. Copie el siguiente código de la función de Lambda en la sección Configuration (Configuración) de lapágina Restart (Reiniciar) en la consola de Lambda.

El siguiente código disminuye un contador del número de ejecuciones y comienza una nuevaejecución de la máquina de estado, incluido el valor reducido.

var aws = require('aws-sdk');var sfn = new aws.StepFunctions();

exports.restart = function(event, context, callback) {

let StateMachineArn = event.restart.StateMachineArn; event.restart.executionCount -= 1; event = JSON.stringify(event);

let params = {

50



input: event, stateMachineArn: StateMachineArn };

sfn.startExecution(params, function(err, data) { if (err) callback(err); else callback(null,event); });

}

4. Seleccione Save.

Paso 3: Creación de una máquina de estadoAhora que ha creado las dos funciones Lambda, cree una máquina de estado. En esta máquina de estado,los estados ShouldRestart y Restart son el modo en que divide su trabajo en varias ejecuciones.

Example Estado Choice de ShouldRestart

Este fragmento de la máquina de estado muestra el estado Choice (p. 95) de ShouldRestart. Esteestado decide si debe reiniciar la ejecución.

"ShouldRestart": {"Type": "Choice","Choices": [ { "Variable": "$.restart.executionCount", "NumericGreaterThan": 1, "Next": "Restart" }],

El valor $.restart.executionCount se incluye en la entrada de la ejecución inicial. Se reduce en unocada vez que se llama a la función Restart y, a continuación, se incluye en la entrada de cada ejecuciónposterior.

Example Estado Task de Restart

Este fragmento de la máquina de estado muestra el estado Task (p. 92) de Restart. Este estadousa la función Lambda que creó antes para reiniciar la ejecución y para reducir el contador con el fin derealizar el seguimiento del número restante de ejecuciones que se iniciarán.

"Restart": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Restart", "Next": "Done"},

1. En la consola de Step Functions, elija Create a state machine (Crear una máquina de estado).2. Seleccione Author from scratch (Crear desde cero) y escriba ContinueAsNew como el nombre de

máquina de estado.3. En IAM role for your state machine executions (Rol de IAM para las ejecuciones de máquina de

estado), seleccione el rol de IAM que usará para las funciones Lambda.4. Pegue lo siguiente en el panel Code.

51


Example ContinueAsNew máquina de estado

{ "Comment": "Continue-as-new State Machine Example", "StartAt": "ConfigureCount", "States": { "ConfigureCount": { "Type": "Pass", "Result": { "count": 100, "index": -1, "step": 1 }, "ResultPath": "$.iterator", "Next": "Iterator" }, "Iterator": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Iterator", "ResultPath": "$.iterator", "Next": "IsCountReached" }, "IsCountReached": { "Type": "Choice", "Choices": [ { "Variable": "$.iterator.continue", "BooleanEquals": true, "Next": "ExampleWork" } ], "Default": "ShouldRestart" }, "ExampleWork": { "Comment": "Your application logic, to run a specific number of times", "Type": "Pass", "Result": { "success": true }, "ResultPath": "$.result", "Next": "Iterator" }, "ShouldRestart": { "Type": "Choice", "Choices": [ { "Variable": "$.restart.executionCount", "NumericGreaterThan": 0, "Next": "Restart" } ], "Default": "Done" }, "Restart": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Restart", "Next": "Done" }, "Done": { "Type": "Pass", "End": true } }

52

AWS Step Functions Guía para desarrolladoresPaso 4: Actualización de la política de IAM

}

5. Actualice la cadena Resource y los estados Restart e Iterator para hacer referencia a lasfunciones Lambda correspondientes que creó antes.

6. Seleccione Create State Machine (Crear máquina de estado).

Note

Guarde el Nombre de recurso de Amazon de esta máquina de estado.

Paso 4: Actualización de la política de IAMPara asegurarse de que la función Lambda tiene permisos para iniciar una nueva ejecución de StepFunctions, adjunte una política insertada al rol de IAM que use para la función Lambda Restart. Paraobtener más información, consulte el tema relacionado con la integración de políticas insertadas en la Guíadel usuario de IAM.

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "states:StartExecution" ], "Resource": "*" } ]}

Note

Puede actualizar la línea "Resource": "*" en el ejemplo anterior para hacer referencia al ARNde su máquina de estado ContinueAsNew. De este modo se restringe la política de modo quesolo comience una ejecución de esa máquina de estado específica.

Paso 5: Comienzo de una ejecuciónPara comenzar una ejecución, proporcione una entrada que incluya el ARN de la máquina de estado y unvalor executionCount correspondiente al número de veces que debe comenzar una nueva ejecución.

1. En la página ContinueAsNew, elija New execution (Nueva ejecución).2. En la sección Input (Entrada), en la página New execution (Nueva ejecución), escriba Test1 para el

nombre de ejecución. A continuación, escriba lo siguiente en Input (Entrada).

{ "restart": { "StateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:ContinueAsNew", "executionCount": 4 }}

3. Actualice el campo StateMachineArn con el Nombre de recurso de Amazon de la máquina deestado ContinueAsNew.

53

https://docs.aws.amazon.com/IAM/latest/UserGuide//access_policies_manage-attach-detach.html#embed-inline-policy-console

AWS Step Functions Guía para desarrolladoresPaso 5: Comienzo de una ejecución


En el gráfico Visual Workflow (Flujo de trabajo visual) se mostrará la primera de las cuatro ejecuciones.Antes de que finalice, pasará el estado Restart y comenzará una nueva ejecución.

Con esta ejecución completa, puede examinar la siguiente ejecución que se está ejecutando. Seleccioneel enlace ContinueAsNew en la parte superior para ver la lista de ejecuciones. Debe verse la ejecucióncerrada recientemente y una ejecución en curso que inició la función Lambda Restart.

Una vez que están completas todas las ejecuciones, debe ver cuatro ejecuciones correctas en la lista. Laprimera ejecución iniciada muestra el nombre que eligió y las posteriores tienen un nombre generado.

54

AWS Step Functions Guía para desarrolladoresEstados

Cómo funciona Step FunctionsPara comprender el funcionamiento de AWS Step Functions, debe estar familiarizado con algunosconceptos importantes. En esta sección, se describe cómo funciona Step Functions.

Temas• Estados (p. 55)• Tareas (p. 56)• Tareas (p. 56)• Transiciones (p. 64)• Datos de la máquina de estado (p. 64)• Procesamiento de entrada y salida en Step Functions (p. 66)• Ejecuciones (p. 74)• Control de errores (p. 74)• Consistencia de lectura (p. 81)• Plantillas (p. 81)• Proyectos de muestra (p. 82)

EstadosUna máquina de estado finito puede expresar un algoritmo como un número de estados, sus relaciones ysu entrada y la salida. AWS Step Functions le permite coordinar tareas individuales expresando el flujo detrabajo como una máquina de estado finito, escritas en el Lenguaje de estados de Amazon. Los estadosindividuales pueden tomar decisiones en función de su entrada, realizar acciones y transferir la salida aotros estados. En Step Functions expresa sus flujos de trabajo en Lenguaje de estados de Amazon y laconsola de Step Functions ofrece una representación gráfica de dicha máquina de estado para ayudarle avisualizar la lógica de su aplicación.

Los estados son elementos de la máquina de estado. La referencia de los estados se realiza por sunombre, que puede ser cualquier cadena, pero que debe ser único dentro del ámbito de toda la máquinade estado.

Note

La instancia de un estado existe hasta que finaliza su ejecución.

Los estados pueden realizar una gran variedad de funciones en la máquina de estado:

• Pueden realizar algunas tareas en la máquina de estado (estado Task (p. 56)).• Pueden tomar una decisión entre las ramificaciones de una ejecución (estado Choice (p. 95)).• Pueden detener una ejecución con errores o con éxito (estado Fail (p. 99) o Succeed (p. 99)).• Pueden pasar simplemente los datos de entrada a la salida o insertar ciertos datos fijos (estado

Pass (p. 91)).• Pueden proporcionar un retraso que dure cierto tiempo o hasta una fecha u hora determinada (estado

Wait (p. 98)).• Pueden iniciar ramificaciones de ejecución paralelas (estado Parallel (p. 100)).

Por ejemplo, este es un estado de ejemplo llamado HelloWorld que ejecuta una función de Lambda:

"HelloWorld": {

55

AWS Step Functions Guía para desarrolladoresTareas

"Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HelloFunction", "Next": "AfterHelloWorldState", "Comment": "Run the HelloWorld Lambda function"}

Los estados comparten una serie de características comunes:

• Todos los estados deben tener un campo Type que indique de qué tipo se trata.• Todos los estados pueden tener un campo Comment opcional que contenga comentarios o

descripciones del estado en lenguaje natural.• Todos los estados (excepto Succeed o Fail) necesitan un campo Next o pueden adoptar un estado

terminal a través de un campo End.Note

Los estados Choice pueden tener uno o varios campos Next, pero solo puede haber uno encada regla de Choice. Los estados Choice no pueden utilizar End.

Algunos tipos de estado necesitan campos adicionales o pueden cambiar el uso habitual de los camposcomunes.

Para obtener más información sobre los diferentes estados que se pueden definir con Lenguaje de estadosde Amazon, consulte States (p. 90).

Cuando haya creado y ejecutado una máquina de estado, podrá obtener acceso a información de cadaestado, su entrada y salida, así como cuándo se activó y durante cuánto tiempo, en la página ExecutionDetails de la consola de Step Functions.

TareasTodo el trabajo de la máquina de estado se realiza a través de tareas. Una tarea puede ser una actividad ouna función de Lambda.

• Una actividad se compone del código del programa que espera a que un operador realice una accióno proporcione datos de entrada. Puede alojar actividades en Amazon EC2, en Amazon ECS o inclusoen dispositivos móviles. Las actividades sondean Step Functions utilizando GetActivityTask y lasacciones de API SendTaskSuccess, SendTaskFailure y SendTaskHeartbeat.

• Una función de Lambda (p. 9) es una tarea nativa en la nube que se ejecuta en AWS Lambda. Puedeescribir funciones Lambda en diferentes lenguajes de programación, a través de la Consola deadministración de AWS o cargando código en Lambda.

Para representar tareas, Lenguaje de estados de Amazon establece un tipo de estado en Task yproporciona la tarea con el ARN de la actividad o la función de Lambda. Para obtener más informaciónacerca de cómo se especifican tipos de tareas, consulte Tarea (p. 92) en Lenguaje de estados deAmazon (p. 88).

Para consultar su lista de tareas, utilice la página Tasks de la consola de Step Functions.

TareasLas actividades son un concepto de AWS Step Functions que hace referencia a una tarea que realiza unproceso de trabajo que se puede alojar en EC2, ECS, dispositivos móviles o prácticamente en cualquierlugar.

56



AWS Step Functions Guía para desarrolladoresCreación de una actividad

Temas• Creación de una actividad (p. 57)• Creación de un proceso de trabajo (p. 57)• Ejemplo de proceso de trabajo de actividad en Ruby (p. 57)

Creación de una actividadA las actividades se hace referencia por su nombre. Un nombre de actividad puede ser cualquier cadenaque cumpla las reglas siguientes:

• Debe tener entre 0 y 80 caracteres de longitud.• Debe ser único en su cuenta y región de AWS.

La actividades se pueden crear con Step Functions de alguna de las siguientes formas:

• Llamando a CreateActivity con el nombre de actividad• Mediante la consola de Step Functions

Note

Las actividades no tienen control de versiones y se espera que siempre sean compatibles conversiones anteriores. Si debe realizar un cambio incompatible con versiones anteriores en unadefinición de actividad, debe crearse una nueva actividad con Step Functions utilizando unnombre único.

Creación de un proceso de trabajoLos procesos de trabajo se pueden implementar en cualquier lenguaje que pueda realizar acciones deAPI de AWS Step Functions. Los procesos de trabajo deben buscar una y otra vez tareas que realizarimplementando el siguiente algoritmo de pseudocódigo:

[taskToken, jsonInput] = GetActivityTask();try { // Do some work... SendTaskSuccess(taskToken, jsonOutput); } catch (Exception e) { SendTaskFailure(taskToken, reason, errorCode);}

Envío de notificaciones de latidoLos estados que tienen actividades de ejecución prolongada deben tener un valor de tiempo de espera delatido para comprobar que la actividad se sigue ejecutando correctamente.

Si su actividad tiene un valor de tiempo de espera de latido, el proceso de trabajo que la implementa debeenviar actualizaciones de latido a Step Functions. Para enviar una notificación de latido desde un procesode trabajo, utilice la acción SendTaskHeartbeat.

Ejemplo de proceso de trabajo de actividad en RubyA continuación se muestra un ejemplo de proceso de trabajo de actividad escrito en Ruby. Estoproporciona una implementación basada en prácticas recomendadas que se puede utilizar como referenciapara la creación de procesos de trabajo de actividad. El código implementa un patrón consumidor-productor con un número configurable de subprocesos para sondeadores y procesos de trabajo de

57

https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateActivity.html


https://docs.aws.amazon.com/step-functions/latest/apireference/API_SendTaskHeartbeat.html

AWS Step Functions Guía para desarrolladoresEjemplo de proceso de trabajo de actividad en Ruby

actividad. El subprocesos de sondeador están realizando constantemente un sondeo largo de la tarea deactividad. Cuando se recupera una tarea de actividad, se pasa a través de una cola de bloqueo limitadapara que el subproceso de actividad la recoja.

• Para obtener más información sobre el AWS SDK parar Ruby, consulte la AWS SDK parar Ruby APIReference.

• Para descargar este código y los recursos relacionados, consulte step-functions-ruby-activity-worker enGitHub.com.

El siguiente código Ruby es el principal punto de entrada y ejemplo de uso del proceso de trabajo deactividad de Ruby que se muestra más adelante.

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 ) # The start method takes as argument the block that is the actual logic of your custom activity. activity.start do |input| { result: :SUCCESS, echo: input['value'] }

El código anterior incluye valores predeterminados que puede modificar para hacer referencia a suactividad, así como para adaptarlo a su implementación específica. Este código toma como entradala lógica de implementación real, le permite incluir referencias a una actividad y unas credencialesespecíficas, y le permite configurar el número de subprocesos y el retraso de latido. Para obtener másinformación y descargar el código, consulte Step Functions Ruby Activity Worker.

Elemento Descripción

require_relative Ruta relativa al código de proceso de trabajo deactividad que se muestra a continuación.

region Región de AWS de la actividad.

workers_count Número de subprocesos del proceso detrabajo de actividad. Para la mayoría de lasimplementaciones, deberían ser suficientes entre10 y 20 subprocesos. Cuanto más tiempo tarde laactividad en procesarse, más subprocesos puedenecesitar. Para realizar una estimación, multipliqueel número de actividades de proceso por segundopor la latencia de procesamiento de actividades delpercentil 99th, en segundos.

pollers_count Número de subprocesos de los sondeadores.Deberían ser suficientes entre 10 y 20 subprocesospara la mayoría de las implementaciones.

58

https://docs.aws.amazon.com/sdk-for-ruby/v3/api/

https://docs.aws.amazon.com/sdk-for-ruby/v3/api/

https://github.com/aws-samples/step-functions-ruby-activity-worker

https://github.com/aws-samples/step-functions-ruby-activity-worker


Elemento Descripción

heartbeat_delay Retraso entre latidos, en segundos.

input Lógica de implementación de la actividad.

A continuación se muestra el proceso de trabajo de actividad de Ruby utilizado por el ejemplo anterior y alque se hace referencia con ../lib/step_functions/activity.

require 'set'require 'json'require 'thread'require 'logger'require 'aws-sdk'

module Validate def self.positive(value) raise ArgumentError, 'Argument has to positive' if value <= 0 value end

def self.required(value) raise ArgumentError, 'Argument is required' if value.nil? value endend

module StepFunctions class RetryError < StandardError def initialize(message) super(message) end end

def self.with_retries(options = {}, &block) retries = 0 base_delay_seconds = options[:base_delay_seconds] || 2 max_retries = options[:max_retries] || 3 begin block.call rescue => e puts e if retries < max_retries retries += 1 sleep base_delay_seconds**retries retry end raise RetryError, 'All retries of operation had failed' end end

class Activity def initialize(options = {}) @states = Aws::States::Client.new( credentials: Validate.required(options[:credentials]), region: Validate.required(options[:region]), http_read_timeout: Validate.positive(options[:http_read_timeout] || 60) ) @activity_arn = Validate.required(options[:activity_arn]) @heartbeat_delay = Validate.positive(options[:heartbeat_delay] || 60) @queue_max = Validate.positive(options[:queue_max] || 5) @pollers_count = Validate.positive(options[:pollers_count] || 1)

59


@workers_count = Validate.positive(options[:workers_count] || 1) @max_retry = Validate.positive(options[:workers_count] || 3) @logger = Logger.new(STDOUT) end

def start(&block) @sink = SizedQueue.new(@queue_max) @activities = Set.new start_heartbeat_worker(@activities) start_workers(@activities, block, @sink) start_pollers(@activities, @sink) wait end

def queue_size return 0 if @sink.nil? @sink.size end

def activities_count return 0 if @activities.nil? @activities.size end

private

def start_pollers(activities, sink) @pollers = Array.new(@pollers_count) do PollerWorker.new( states: @states, activity_arn: @activity_arn, sink: sink, activities: activities, max_retry: @max_retry ) end @pollers.each(&:start) end

def start_workers(activities, block, sink) @workers = Array.new(@workers_count) do ActivityWorker.new( states: @states, block: block, sink: sink, activities: activities, max_retry: @max_retry ) end @workers.each(&:start) end

def start_heartbeat_worker(activities) @heartbeat_worker = HeartbeatWorker.new( states: @states, activities: activities, heartbeat_delay: @heartbeat_delay, max_retry: @max_retry ) @heartbeat_worker.start end

def wait sleep rescue Interrupt shutdown

60


ensure Thread.current.exit end

def shutdown stop_workers(@pollers) wait_workers(@pollers) wait_activities_drained stop_workers(@workers) wait_activities_completed shutdown_workers(@workers) shutdown_worker(@heartbeat_worker) end

def shutdown_workers(workers) workers.each do |worker| shutdown_worker(worker) end end

def shutdown_worker(worker) worker.kill end

def wait_workers(workers) workers.each(&:wait) end

def wait_activities_drained wait_condition { @sink.empty? } end

def wait_activities_completed wait_condition { @activities.empty? } end

def wait_condition(&block) loop do break if block.call sleep(1) end end

def stop_workers(workers) workers.each(&:stop) end

class Worker def initialize @logger = Logger.new(STDOUT) @running = false end

def run raise 'Method run hasn\'t been implemented' end

def process loop do begin break unless @running run rescue => e puts e @logger.error('Unexpected error had occurred') @logger.error(e)

61


end end end

def start return unless @thread.nil? @running = true @thread = Thread.new do process end end

def stop @running = false end

def kill return if @thread.nil? @thread.kill @thread = nil end

def wait @thread.join end end

class PollerWorker < Worker def initialize(options = {}) @states = options[:states] @activity_arn = options[:activity_arn] @sink = options[:sink] @activities = options[:activities] @max_retry = options[:max_retry] @logger = Logger.new(STDOUT) end

def run activity_task = StepFunctions.with_retries(max_retry: @max_retry) do begin @states.get_activity_task(activity_arn: @activity_arn) rescue => e @logger.error('Failed to retrieve activity task') @logger.error(e) end end return if activity_task.nil? || activity_task.task_token.nil? @activities.add(activity_task.task_token) @sink.push(activity_task) end end

class ActivityWorker < Worker def initialize(options = {}) @states = options[:states] @block = options[:block] @sink = options[:sink] @activities = options[:activities] @max_retry = options[:max_retry] @logger = Logger.new(STDOUT) end

def run activity_task = @sink.pop result = @block.call(JSON.parse(activity_task.input)) send_task_success(activity_task, result)

62


rescue => e send_task_failure(activity_task, e) ensure @activities.delete(activity_task.task_token) unless activity_task.nil? end

def send_task_success(activity_task, result) StepFunctions.with_retries(max_retry: @max_retry) do begin @states.send_task_success( task_token: activity_task.task_token, output: JSON.dump(result) ) rescue => e @logger.error('Failed to send task success') @logger.error(e) end end end

def send_task_failure(activity_task, error) StepFunctions.with_retries do begin @states.send_task_failure( task_token: activity_task.task_token, cause: error.message ) rescue => e @logger.error('Failed to send task failure') @logger.error(e) end end end end

class HeartbeatWorker < Worker def initialize(options = {}) @states = options[:states] @activities = options[:activities] @heartbeat_delay = options[:heartbeat_delay] @max_retry = options[:max_retry] @logger = Logger.new(STDOUT) end

def run sleep(@heartbeat_delay) @activities.each do |token| send_heartbeat(token) end end

def send_heartbeat(token) StepFunctions.with_retries(max_retry: @max_retry) do begin @states.send_task_heartbeat(token) rescue => e @logger.error('Failed to send heartbeat for activity') @logger.error(e) end end rescue => e @logger.error('Failed to send heartbeat for activity') @logger.error(e) end end end

63

AWS Step Functions Guía para desarrolladoresTransiciones

end

TransicionesCuando se inicia una ejecución de una máquina de estado, el sistema comienza con el estado al quese hace referencia en el campo principal StartAt. Este campo (que es una cadena) debe coincidirexactamente (mayúsculas y minúsculas) con el nombre de uno de los estados.

Después de ejecutar un estado, AWS Step Functions utiliza el valor del campo Next para determinar elsiguiente estado al que debe avanzar.

Los campos Next también especifican los nombres de estado como cadenas y deben coincidirexactamente (mayúsculas y minúsculas incluidas) con el nombre del estado definido en la descripción dela máquina de estado.

Por ejemplo, el siguiente estado incluye una transición a NextState:

"SomeState" : { ..., "Next" : "NextState"}

La mayoría de los estados solamente permiten usar una regla de transición a través del campo Next. Sinembargo, algunos estados de control de flujo (por ejemplo, el estado Choice) permiten especificar variasreglas de transición, cada una con su propio campo Next. El lenguaje de estados de Amazon (p. 88)proporciona detalles sobre cada uno de los tipos de estado que se pueden especificar; por ejemplo,información acerca de cómo especificar las transiciones.

Los estados pueden tener varias transiciones de entrada procedentes de otros estados.

El proceso se repite hasta que alcanza un estado terminal (un estado con "Type": Succeed, "Type":Fail o "End": true) o se produce un error del sistema en tiempo de ejecución.

Las siguientes reglas se aplican a los estados de una máquina de estado:

• Los estados pueden tener lugar en cualquier orden dentro del bloque delimitado; el orden en el queaparecen no afecta al orden en el que se ejecutan, ya que este viene determinado por el contenido delos propios estados.

• En una máquina de estado, solo puede haber un estado designado como start; esta designación sehace a través del valor del campo StartAt en la estructura principal.

• En función de la lógica de la máquina de estado (por ejemplo, si la máquina de estado tiene variasramificaciones de ejecución), es posible que haya varios estados end.

• Si la máquina de estado se compone de un solo estado, este podría ser tanto el estado start como elestado end.

Datos de la máquina de estadoLos datos de las máquinas de estado son los siguientes:

64

AWS Step Functions Guía para desarrolladoresFormato de los datos

• Los datos de entrada iniciales de la máquina de estado• Los datos que se pasan entre estados• La salida de la máquina de estado

En esta sección, se describe el formato de los datos de la máquina de estado y cómo se utilizan estosdatos en AWS Step Functions.

Temas• Formato de los datos (p. 65)• Entrada y salida de la máquina de estado (p. 65)• Entrada y salida de estados (p. 65)

Formato de los datosLos datos de la máquina de estado están representados por un texto JSON, por lo que los valores sepueden proporcionar utilizando cualquier tipo de dato compatible con JSON:

Note

• Los números en formato de texto JSON se ajustan a la semántica de JavaScript. Por lo general,estos números se corresponden con valores IEEE-854 de doble precisión.

• Un texto JSON válido está formado por: cadenas independientes separadas mediante comas,objetos, matrices, números, valores booleanos y null.

• La salida de un estado se convierte en la entrada del siguiente estado. Sin embargo, con elprocesamiento de entrada y salida (p. 103), puede restringir los estados para que trabajen conun subconjunto de los datos de entrada.

Entrada y salida de la máquina de estadoPuede proporcionar los datos de entrada iniciales de AWS Step Functions pasándolos a una acciónStartExecution cuando comience la ejecución o pasándolos a través de la consola de Step Functions.Los datos iniciales se pasan al estado StartAt de la máquina de estado. Si no se proporcionan datos deentrada, el valor predeterminado es un objeto vacío ({}).

El último estado (terminal) es el encargado de devolver la salida de la ejecución. Esta salidaaparece como un texto JSON en el resultado de la ejecución. Puede recuperar los resultados de laejecución en el historial de ejecuciones mediante generadores de llamadas (por ejemplo, la acciónDescribeExecution). Puede consultar los resultados de la ejecución en la consola de Step Functions.

Entrada y salida de estadosCada entrada de estado se compone de un texto JSON procedente del estado anterior o del estadoStartAt, la entrada que activa la ejecución. Algunos estados de control de flujo replican los datos deentrada en la salida.

En el ejemplo siguiente, la máquina de estado suma dos números:

1. Defina la función de Lambda.

function Add(input) { var numbers = JSON.parse(input).numbers;

65

https://standards.ieee.org/findstds/standard/854-1987.html



https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html


AWS Step Functions Guía para desarrolladoresProcesamiento de entrada y salida

var total = numbers.reduce( function(previousValue, currentValue, index, array) { return previousValue + currentValue; }); return JSON.stringify({ result: total });}

2. Defina la máquina de estado.

{ "Comment": "An example that adds two numbers together.", "StartAt": "Add", "Version": "1.0", "TimeoutSeconds": 10, "States": { "Add": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Add", "End": true } }}

3. Inicie una ejecución con el siguiente texto JSON:

{ "numbers": [3, 4] }

El estado Add recibe el texto JSON y lo pasa a la función de Lambda.

La función de Lambda devuelve el resultado del cálculo al estado.

El estado devuelve el siguiente valor en la salida:

{ "result": 7 }

Como Add también es el estado final de la máquina de estado, este valor se devuelve como salida dela máquina de estado.

Si el estado final no devuelve ninguna salida, la máquina de estado devuelve un objeto vacío ({}).

Para obtener más información, consulte Procesamiento de entrada y salida en Step Functions (p. 66)

Procesamiento de entrada y salida en StepFunctions

Una ejecución de Step Functions recibe un archivo JSON como entrada y transfiere dicha entrada alprimer estado en el flujo de trabajo. Los estados individuales reciben JSON como entrada y normalmentetransfieren JSON como salida al siguiente estado. Comprender cómo fluye esta información de estado aestado y aprender a filtrar y manipular estos datos resulta esencial para diseñar e implementar de formaeficaz los flujos de trabajo en AWS Step Functions.

En el Lenguaje de estados de Amazon, tres componentes filtran y controlan el flujo de JSON de estado aestado:

• InputPath

66

AWS Step Functions Guía para desarrolladoresDescripción de ResultPath

• OutputPath

• ResultPath

En el siguiente diagrama se muestra cómo se traslada la información de JSON a través de un estado detarea. InputPath selecciona qué componentes de la entrada se transfieren a la tarea del estado Task(por ejemplo, una función de AWS Lambda). ResultPath selecciona a continuación la combinación dela entrada de estado y del resultado de tarea que transferir a la salida. OutputPath puede filtrar la salidaJSON para limitar más la información que se transfiere a la salida.

InputPath, OutputPath y ResultPath utilizan rutas (p. 103) para manipular JSON a medida que sedesplaza a través de cada estado en el flujo de trabajo. Una ruta es una cadena, que empieza por $, queidentifica componentes dentro de texto JSON. Las rutas de Step Functions utilizan la sintaxis JsonPath.

Note

ResultPath se limita al uso de rutas de referencia (p. 103), que limitan el ámbito de forma quesolo pueden identificar un único nodo en JSON. Consulte Rutas de referencia (p. 103) en elLenguaje de estados de Amazon (p. 88).

Temas• Descripción de ResultPath (p. 67)• Filtrado con InputPath y OutputPath (p. 72)

Descripción de ResultPathLa salida de un estado puede ser una copia de su entrada, el resultado que produce (por ejemplo, la salidadesde una función de Lambda del estado de una tarea) o una combinación de su entrada y resultado. UseResultPath para controlar qué combinación de estos se transfiere a la salida del estado.

Los siguientes tipos de estado pueden generar un resultado y pueden incluir ResultPath:

• Pass (p. 91)• Tarea (p. 92)• Parallel (p. 100)

67

https://github.com/json-path/JsonPath


Use ResultPath para combinar un resultado de tarea con una entrada de tarea o para seleccionar unode estos. La ruta que proporcione a ResultPathcontrola la información que se transfiere a la salida.

Estos ejemplos se basan en la máquina de estado y en la función de Lambda que se describen en eltutorial Creación de una máquina de estado Lambda (p. 9). Realice el tutorial y ensaye las distintas salidasprobando diversas rutas en un campo ResultPath.

Use ResultPath para:• Use ResultPath para reemplazar la entrada por el resultado (p. 68)• Use ResultPath para incluir resultado con entrada (p. 69)• Utilice ResultPath para actualizar un nodo en la entrada con el resultado (p. 70)• Utilice ResultPath para incluir error y entrada en un Catch (p. 72)

Use ResultPath para reemplazar la entrada por el resultadoSi no especifica una ResultPath, el comportamiento predeterminado es como si hubiera especificado"ResultPath": "$". Dado que esto indica al estado que reemplace toda la entrada por el resultado, laentrada de estado se reemplaza por completo por el resultado procedente del resultado de la tarea.

En el siguiente diagrama se muestra cómo ResultPath puede reemplazar por completo la entrada por elresultado de la tarea.

Uso de la máquina de estado y de la función de Lambda descrita en Creación de una máquina de estadoLambda (p. 9), si transferimos la siguiente entrada:

{ "comment": "This is a test of the input and output of a Task state.", "details": "Default example", "who": "AWS Step Functions"}

La función de Lambda proporciona el siguiente resultado:

68


"Hello, AWS Step Functions!"

Si ResultPath no se especifica en el estado o si se ha establecido "ResultPath": "$", la entrada delestado se reemplaza por el resultado de la función de Lambda y la salida del estado es:


Note

ResultPath se utiliza para incluir contenido a partir del resultado con la entrada, antes detransferirlo a la salida. Pero, si no se especifica ResultPath, el valor predeterminado consiste enreemplazar toda la entrada.

Use ResultPath para incluir resultado con entradaEl diagrama siguiente muestra cómo ResultPath puede incluir el resultado con la entrada.

Utilizando la máquina de estado y la función de Lambda descrita en el tutorial Creación de una máquina deestado Lambda (p. 9), podríamos transferir la siguiente entrada:


El resultado de la función de Lambda es:


69


Si se desea conservar la entrada, inserte el resultado de la función de Lambda y, a continuación, transfierael JSON combinado al siguiente estado, podríamos establecer ResultPath en:

"ResultPath": "$.taskresult"

Esto incluye el resultado de la función de Lambda con la entrada original:

{ "comment": "This is a test of input and output of a Task state.", "details": "Default behavior example", "who": "AWS Step Functions", "taskresult": "Hello, AWS Step Functions!"}

La salida de la función de Lambda se añade a la entrada original como un valor para taskresult. Laentrada, incluido el valor recién insertado, se transfiere al siguiente estado.

También puede insertar el resultado en un nodo secundario de la entrada. Establezca ResultPath en:

"ResultPath": "$.strings.lambdaresult"

Inicie una ejecución utilizando la siguiente entrada:

{ "comment": "An input comment.", "strings": { "string1": "foo", "string2": "bar", "string3": "baz" }, "who": "AWS Step Functions"}

El resultado de la función de Lambda se inserta como un elemento secundario del nodo strings en laentrada:

{ "comment": "An input comment.", "strings": { "string1": "foo", "string2": "bar", "string3": "baz", "lambdaresult": "Hello, AWS Step Functions!" }, "who": "AWS Step Functions"}

La salida de estado ahora incluye el JSON de entrada original con el resultado como nodo secundario.

Utilice ResultPath para actualizar un nodo en la entrada con elresultadoEn el siguiente diagrama se muestra cómo ResultPath puede actualizar el valor de los nodos JSONexistentes en la entrada con valores del resultado de tarea.

70


Utilizando el ejemplo de la máquina de estado y de la función de Lambda descrito en el tutorial Creación deuna máquina de estado Lambda (p. 9), podríamos transferir la siguiente entrada:


El resultado de la función de Lambda es:

Hello, AWS Step Functions!

En lugar de conservar la entrada e insertar el resultado como un nuevo nodo en el JSON, podemossobrescribir un nodo existente. Por ejemplo, al igual que omitir o establecer "ResultPath": "$" sesobrescribe todo el nodo, puede especificar un nodo individual para sobrescribir con el resultado:

"ResultPath": "$.comment"

Como el nodo comment ya existe en la entrada de estado, al establecer ResultPath en "$.comment"se reemplaza dicho nodo en la entrada por el resultado de la función de Lambda. Sin filtrar más medianteOutputPath, se transfiere lo siguiente a la salida:

{ "comment": "Hello, AWS Step Functions!", "details": "Default behavior example", "who": "AWS Step Functions",}

71

AWS Step Functions Guía para desarrolladoresFiltrado con InputPath y OutputPath

El valor para el nodo comment, "This is a test of the input and output of a Taskstate.", se reemplaza por el resultado de la función de Lambda: "Hello, AWS Step Functions!"en la salida de estado.

Utilice ResultPath para incluir error y entrada en un CatchEl tutorial Administración de las condiciones de error con una máquina de estado (p. 26) muestra cómoutilizar una máquina de estado para detectar un error. En algunos casos, es posible que desee conservarla entrada original con el error. Utilice ResultPath en un Catch para incluir el error con la entradaoriginal, en lugar de reemplazarlo:

"Catch": [{ "ErrorEquals": ["States.ALL"], "Next": "NextTask", "ResultPath": "$.error" }]

Si la instrucción Catch anterior detecta un error, incluye el resultado en un nodo error dentro de laentrada de estado. Por ejemplo, con la siguiente entrada:

{"foo": "bar"}

La salida de estado al detectar un error es:

{ "foo": "bar", "error": { "Error": "Error here" }}

Para obtener más información sobre el control de errores, consulte:

• Control de errores (p. 74)• Administración de las condiciones de error con una máquina de estado (p. 26)

Filtrado con InputPath y OutputPathCualquier estado distinto de Fail puede incluir InputPath u OutputPath. Le permiten utilizar una rutapara filtrar el JSON a medida que se desplaza a través del flujo de trabajo.

Por ejemplo, comience por la función de AWS Lambda y la máquina de estado que se describe en eltutorial Creación de una máquina de estado Lambda (p. 9). Modifique la máquina de estado de forma queincluya el siguiente InputPath, ResultPath y OutputPath:

{ "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HelloFunction", "InputPath": "$.lambda", "ResultPath": "$.data.lambdaresult", "OutputPath": "$.data",

72

AWS Step Functions Guía para desarrolladoresFiltrado con InputPath y OutputPath

"End": true } }}

Inicie una ejecución utilizando la siguiente entrada:

{ "comment": "An input comment.", "data": { "val1": 23, "val2": 17 }, "extra": "foo", "lambda": { "who": "AWS Step Functions" }}

Supongamos que los nodos comment y extra se puedan descartar, pero que deseamos incluir la salidade la función de Lambda, así como conservar la información en el nodo data.

En la máquina de estado actualizada, el estado Task se modifica para procesar la entrada a la tarea:

"InputPath": "$.lambda",

Esta línea en la definición de la máquina de estado limita la entrada de tarea a solo el nodo lambdade la entrada del estado. La función de Lambda recibe solo el objeto JSON {"who": "AWS StepFunctions"} como entrada.

"ResultPath": "$.data.lambdaresult",

Este ResultPath indica a la máquina de estado que inserte el resultado de la función de Lambda en unnodo denominado lambdaresult, como elemento secundario del nodo data en la entrada de la máquinade estado original. Sin procesamiento adicional con OutputPath, la entrada del estado ahora incluye elresultado de la función de Lambda con la entrada original:

{ "comment": "An input comment.", "data": { "val1": 23, "val2": 17, "lambdaresult": "Hello, AWS Step Functions!" }, "extra": "foo", "lambda": { "who": "AWS Step Functions" }}

Sin embargo, nuestro objetivo consistía en conservar solo el nodo data e incluir el resultado de la funciónde Lambda. OutputPath filtra este JSON combinado antes de transferirlo a la salida del estado:

"OutputPath": "$.data",

Esto selecciona solo el nodo data de la entrada original (incluido el nodo secundario lambdaresultinsertado por ResultPath) para transferirlo a la salida. La salida de estado se filtra a:

73

AWS Step Functions Guía para desarrolladoresEjecuciones

{ "val1": 23, "val2": 17, "lambdaresult": "Hello, AWS Step Functions!"}

En este estado de tarea:

1. InputPath envía solo el nodo lambda desde la entrada a la función de Lambda.2. ResultPath inserta el resultado como un elemento secundario del nodo data de la entrada original.3. OutputPath filtra la entrada del estado (que ahora incluye el resultado de la función de Lambda) de

forma que solo transfiere el nodo data a la salida del estado.

Para obtener más información, consulte: Procesamiento de entrada y salida en Step Functions (p. 66).

EjecucionesLa ejecución de una máquina de estado se produce cuando se ejecuta una máquina de estado de StepFunctions y se realizan sus tareas. Cada máquina de estado de Step Functions puede tener variasejecuciones simultáneas que se pueden iniciar desde la consola de Step Functions o mediante los SDK deAWS, las acciones de la API de Step Functions o la AWS CLI. Una ejecución recibe una entrada JSON yproduce una salida JSON.

Para obtener más información sobre los diferentes modos de trabajar con Step Functions, consulteOpciones de desarrollo (p. 7). Para obtener más información acerca de cómo iniciar una ejecución desde laconsola de Step Functions, consulte Para iniciar una nueva ejecución (p. 4).

Note

La consola de Step Functions muestra un máximo de 1 000 ejecuciones por máquina de estado.Si tiene más de 1 000 ejecuciones, utilice las acciones de la API de Step Functions o la AWS CLIpara mostrar todas las ejecuciones.

Control de erroresCualquier estado puede registrar errores en tiempo de ejecución. Los errores pueden producirse por variasrazones:

• Problemas con la definición de la máquina de estado (por ejemplo, no coincide ninguna regla del estadoChoice).

• Errores de tareas (por ejemplo, una excepción de una función de Lambda).• Problemas transitorios (por ejemplo, eventos relacionados con las particiones de red).

De forma predeterminada, cuando un estado registra un error, Step Functions hace que la ejecución fallepor completo.

Nombres de errorStep Functions identifica errores en Lenguaje de estados de Amazon utilizando cadenas que distinguenmayúsculas de minúsculas, lo que se conoce como nombres de error. Lenguaje de estados de Amazondefine un conjunto de cadenas integradas que designan errores conocidos, que comienzan por el prefijoStates.

74


AWS Step Functions Guía para desarrolladoresReintento después de un error

States.ALL

Comodín que coincide con cualquier nombre de error conocido.States.Timeout

Estado Task que se ejecuta durante más tiempo que el valor TimeoutSeconds o que no puedeenviar un latido durante un período mayor que el valor de HeartbeatSeconds.

States.TaskFailed

Estado Task que registró un error durante la ejecución.States.Permissions

Estado Task que registró un error porque no tenía privilegios suficientes para ejecutar el códigoespecificado.

Los estados pueden notificar errores con otros nombres. Sin embargo, estos nombres no puedencomenzar por el prefijo States.

Use la práctica recomendada de asegurarse de que el código de producción controle las excepciones delservicio de Lambda (Lambda.ServiceException y Lambda.SdkclientException). Para obtenermás información, consulte Control de excepciones de servicio en Lambda (p. 111).

Note

Los errores no administrados de Lambda se indican como Lambda.Unknown en la salida deerrores. Incluyen errores de falta de memoria, tiempos de espera de funciones agotados yalcanzar el límite de invocaciones de Lambda simultáneas. Puede buscar correspondenciascon Lambda.Unknown, States.ALL o States.TaskFailed para administrar estos errores.Para obtener más información sobre los errores Handled y Unhandled de Lambda, consulteFunctionError en la AWS Lambda Developer Guide.

Reintento después de un errorLos estados Task y Parallel pueden tener un campo llamado Retry, cuyo valor debe ser una matriz deobjetos, denominados reintentadores. Cada reintentador representa un número determinado de reintentos,que normalmente aumentan en intervalos de tiempo.

Note

Los reintentos se tratan como transiciones de estado. Para obtener más información sobre cómoafectan las transiciones de estado a la facturación, consulte Precios de Step Functions.

Los reintentadores contienen los siguientes campos:

ErrorEquals (Obligatorio)

Matriz no vacía de cadenas que coinciden con nombres de error. Cuando un estado registra un error,Step Functions lo analiza a través de los reintentadores. Cuando el nombre de error aparece en estamatriz, se implementa la política de reintentos que se describe en este reintentador.

IntervalSeconds (Opcional)

Entero que representa el número de segundos antes del primer reintento (el valor predeterminado es1).

MaxAttempts (Opcional)

Entero positivo que representa el número máximo de reintentos (el valor predeterminado es 3). Siel error se repite más veces de las especificadas, se interrumpen los reintentos y se reanuda laadministración normal de errores. El valor 0 indica que no se efectúan reintentos en el error o errores.

75


https://aws.amazon.com/step-functions/pricing/


BackoffRate (Opcional)

Multiplicador según el cual aumenta el intervalo de reintentos durante cada fase (el valorpredeterminado es 2.0).

Este ejemplo de Retry realiza dos fases de reintentos después de esperar a 3 y 4,5 segundos.

"Retry": [ { "ErrorEquals": [ "States.Timeout" ], "IntervalSeconds": 3, "MaxAttempts": 2, "BackoffRate": 1.5} ]

El nombre reservado States.ALL que aparece en el campo ErrorEquals de un reintentador esun nombre comodín que coincide con cualquier nombre de error. Debe aparecer solo en la matrizErrorEquals y debe aparecer en el último reintentador de la matriz Retry.

En este ejemplo del campo Retry, se reintentan todos los errores excepto States.Timeout.

"Retry": [ { "ErrorEquals": [ "States.Timeout" ], "MaxAttempts": 0}, { "ErrorEquals": [ "States.ALL" ]} ]

Escenarios de reintentos complejosLos parámetros de un reintentador se aplican a todas las visitas que se realizan a dicho reintentadordurante la ejecución de un único estado. Supongamos que tenemos el siguiente estado Task:

"X": { "Type": "Task", "Resource": "arn:aws:states:us-east-1:123456789012:task:X", "Next": "Y", "Retry": [ { "ErrorEquals": [ "ErrorA", "ErrorB" ], "IntervalSeconds": 1, "BackoffRate": 2.0, "MaxAttempts": 2 }, { "ErrorEquals": [ "ErrorC" ], "IntervalSeconds": 5 } ], "Catch": [ { "ErrorEquals": [ "States.ALL" ], "Next": "Z" } ]}

Esta tarea falla cinco veces seguidas y devuelve estos nombres de error: ErrorA, ErrorB, ErrorC,ErrorB y ErrorB. Como resultado, se produce lo siguiente:

• Los dos primeros errores coinciden con el primer reintentador y produce esperas de 1 y 2 segundos.• El tercer error coincide con el segundo reintentador y produce una espera de 5 segundos.• El cuarto error coincide con el primer reintentador y produce una espera de 4 segundos.

76

AWS Step Functions Guía para desarrolladoresEstados alternativos

• El quinto error también coincide con el primer reintentador. Sin embargo, ya ha alcanzado el límite dedos reintentos (MaxAttempts) para ese error específico (ErrorB), por lo que falla y la ejecución seredirige al estado Z a través del campo Catch.

Estados alternativosLos estados Task y Parallel pueden tener un campo llamado Catch. El valor de este campo debe seruna matriz de objetos, denominados receptores.

Un receptor contiene los siguientes campos:


Matriz no vacía de cadenas que coinciden con nombres de error, especificados exactamente como seindicaron en el campo Retrier del mismo nombre.

Next (Obligatorio)

Cadena que debe coincidir exactamente con uno de los nombres de estado de la máquina de estado.ResultPath (Opcional)

Ruta (p. 103) que determina qué datos de entrada se envían al estado especificado en el campoNext.

Cuando un estado registra un error y no hay un campo Retry o los reintentos no son capaces de resolverel problema, Step Functions lo analiza a través de los receptores en el orden en que aparecen en la matriz.Cuando el nombre de error aparece en el valor del campo ErrorEquals de un reintentador, la máquinade estado adopta el estado especificado en el campo Next.

El nombre reservado States.ALL que aparece en el campo ErrorEquals de un receptor es un nombrecomodín que coincide con cualquier nombre de error. Debe aparecer solo en la matriz ErrorEquals ydebe aparecer en el último receptor de la matriz Catch.

En el siguiente ejemplo, el campo Catch cambia a un estado llamado RecoveryState cuando unafunción de Lambda genera una excepción Java no controlada. De lo contrario, el campo cambia al estadoEndState:

"Catch": [ { "ErrorEquals": [ "java.lang.Exception" ], "ResultPath": "$.error-info", "Next": "RecoveryState"}, { "ErrorEquals": [ "States.ALL" ], "Next": "EndState"} ]

Note

Cada receptor puede especificar varios errores que deben administrarse.

Salida de errorCuando Step Functions adopta el estado especificado en un nombre de Catch, por lo general, el objetocontiene el campo Cause. El valor de este campo es una descripción del error en lenguaje natural. Esteobjeto se conoce como salida de error.

En este ejemplo, el primer receptor contiene un campo ResultPath. Funciona de manera parecida a uncampo ResultPath del nivel superior del estado, lo que genera dos posibilidades:

77

AWS Step Functions Guía para desarrolladoresEjemplos sobre el uso de Retry y Catch

• Toma los resultados de la ejecución del estado y sobrescribe una parte de los datos de entrada delestado (o todos ellos).

• Toma los resultados y los agrega a los datos de entrada. En el caso de los errores gestionados por unreceptor, el resultado de la ejecución del estado es la salida de error.

Por tanto, en el primer receptor de este ejemplo, la salida de error se agrega a los datos de entrada comoun campo llamado error-info (si no hay ningún campo con este nombre en los datos de entrada). Acontinuación, toda la entrada se envía a RecoveryState. En el segundo receptor, la salida de errorsobrescribe los datos de entrada y solo se envía la salida de error a EndState.

Note

Si no se especifica el campo ResultPath, este se establece de forma predeterminada en $, queselecciona y sobrescribe toda la entrada.

Cuando un estado tiene ambos campos, Retry y Catch, Step Functions utiliza primero alguno de losreintentadores correspondientes y, posteriormente, solo aplica la transición del receptor coincidente si lapolítica de reintentos no puede resolver el error.

Ejemplos sobre el uso de Retry y CatchLas máquinas de estado que se definen en los ejemplos siguientes presuponen la existencia de dosfunciones Lambda: una que siempre registra errores y otra que espera lo suficiente para permitir quetranscurra el tiempo de espera especificado en la máquina de estado.

Esta es una definición de una función de Lambda que nunca se ejecuta correctamente y devuelve elmensaje error. En los ejemplos de máquinas de estado siguientes, esta función de Lambda se llamaFailFunction.

exports.handler = (event, context, callback) => { callback("error");};

Esta es una definición de una función de Lambda que se suspende durante 10 segundos. En los ejemplosde máquinas de estado siguientes, esta función de Lambda se llama sleep10.

Note

Cuando cree esta función de Lambda en la consola de Lambda, no olvide cambiar el valor deTimeout en la sección Advanced settings de 3 segundos (valor predeterminado) a 11 segundos.

exports.handler = (event, context, callback) => { setTimeout(function(){ }, 11000);};

Gestión de errores con RetryEsta máquina de estado utiliza un campo Retry para recuperar una función que no se ejecutacorrectamente y que devuelve el nombre de error HandledError. La función se reintenta dos veces, conun retardo exponencial entre los reintentos.

{ "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function", "StartAt": "HelloWorld", "States": {

78


"HelloWorld": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction", "Retry": [ { "ErrorEquals": ["HandledError"], "IntervalSeconds": 1, "MaxAttempts": 2, "BackoffRate": 2.0 } ], "End": true } }}

Esta variante utiliza el código de error predefinido States.TaskFailed, que coincide con cualquier errorque una función de Lambda puede devolver.

{ "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction", "Retry": [ { "ErrorEquals": ["States.TaskFailed"], "IntervalSeconds": 1, "MaxAttempts": 2, "BackoffRate": 2.0 } ], "End": true } }}

Note

Use la práctica recomendada de que las tareas que hacen referencia a una función Lambdacontrolen las excepciones del servicio de Lambda. Para obtener más información, consulteControl de excepciones de servicio en Lambda (p. 111).

Gestión de errores con CatchEn este ejemplo se utiliza un campo Catch. Cuando una función de Lambda devuelve un error, se recibeel error y la máquina de estado adopta el estado fallback.

{ "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction", "Catch": [ { "ErrorEquals": ["HandledError"], "Next": "fallback" } ], "End": true }, "fallback": {

79


"Type": "Pass", "Result": "Hello, AWS Step Functions!", "End": true } }}

Esta variante utiliza el código de error predefinido States.TaskFailed, que coincide con cualquier errorque una función de Lambda puede devolver.

{ "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FailFunction", "Catch": [ { "ErrorEquals": ["States.TaskFailed"], "Next": "fallback" } ], "End": true }, "fallback": { "Type": "Pass", "Result": "Hello, AWS Step Functions!", "End": true } }}

Gestión de tiempos de espera con RetryEsta máquina de estado utiliza un campo Retry para reintentar una función que agota el tiempo deespera. La función se reintenta dos veces, con un retardo exponencial entre los reintentos.

{ "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:sleep10", "TimeoutSeconds": 2, "Retry": [ { "ErrorEquals": ["States.Timeout"], "IntervalSeconds": 1, "MaxAttempts": 2, "BackoffRate": 2.0 } ], "End": true } }}

Gestión de tiempos de espera con CatchEn este ejemplo se utiliza un campo Catch. Cuando se agota un tiempo de espera, la maquina de estadoadopta el estado fallback.

80

AWS Step Functions Guía para desarrolladoresConsistencia de lectura

{ "Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:sleep10", "TimeoutSeconds": 2, "Catch": [ { "ErrorEquals": ["States.Timeout"], "Next": "fallback" } ], "End": true }, "fallback": { "Type": "Pass", "Result": "Hello, AWS Step Functions!", "End": true } }}

Note

Puede conservar la entrada de estado junto con el error utilizando ResultPath. Consulte UtiliceResultPath para incluir error y entrada en un Catch (p. 72)

Consistencia de lecturaLas actualizaciones de las máquinas de estado de AWS Step Functions presentan consistencia final.Todas las llamadas a StartExecution que se realicen pasados unos segundos utilizarán la definicióny el roleArn (el Nombre de recurso de Amazon del rol de IAM) actualizados. Es posible que lasejecuciones que se inicien inmediatamente después de llamar a UpdateStateMachine utilicen ladefinición de la máquina de estado y el roleArn anteriores.

Para obtener más información, consulte:

• UpdateStateMachine en la Referencia de la API de AWS Step Functions• Paso 3: (Opcional) Actualización de una máquina de estado (p. 5) en la sección Introducción (p. 3)

PlantillasEn la consola de Step Functions, puede elegir una de las siguientes plantillas de máquina de estado pararellenar automáticamente el panel Code. Todas las plantillas son totalmente funcionales y puede usarcualquiera de ellas como la plantilla de su propia máquina de estado.

Note

Cuando se elige alguna de las plantillas, se sobrescribe el contenido del panel Code.

• Hello world: una máquina de estado con un estado Pass.• Wait state: una máquina de estado que muestra diferentes formas de incluir un estado Wait en una

máquina de estado en ejecución:

81

https://docs.aws.amazon.com/step-functions/latest/apireference/API_UpdateStateMachine.html


AWS Step Functions Guía para desarrolladoresProyectos de muestra

• Esperando una serie de segundos• Esperando un tiempo absoluto (marca temporal)• Especificando la definición del estado Wait• Utilizando los datos de entrada del estado

• Retry failure: una máquina de estado que reintenta una tarea tras producirse un error. Este proyectomuestra cómo tratar varios reintentos y distintos tipos de error.

• Parallel: una máquina de estado que muestra cómo ejecutar dos ramificaciones al mismo tiempo.• Catch failure: una máquina de estado que realiza una tarea diferente cuando la tarea principal produce

un error. Este proyecto muestra cómo llamar a diferentes tareas en función del tipo de error.• Choice state: una máquina de estado que hace una elección: ejecuta un estado Task de un conjunto de

estados Task o ejecuta un estado Fail una vez completado el estado inicial.

Proyectos de muestraEn la consola de Step Functions, puede elegir uno de los siguientes proyectos de muestra de máquina deestado para crear automáticamente el Code (Código) y el Visual Workflow (Flujo de trabajo visual) de lamáquina de estado y todos los recursos de AWS relacionados para el proyecto. Cada uno de los proyectosde muestra aprovisiona una máquina de estado plenamente funcional y crea los recursos relacionadospara que se ejecute. Al crear un proyecto de muestra, Step Functions utiliza AWS CloudFormation paracrear los recursos relacionados a los que hace referencia la máquina de estado.

Temas• Job Status Poller (p. 82)• Task Timer (p. 85)

Job Status PollerEste proyecto de muestra crea un sondeador de estado de trabajo AWS Batch. Implementa una máquinade estado AWS Step Functions que utiliza AWS Lambda para crear un bucle de estado Wait quecomprueba una tarea por lotes de AWS. Este proyecto de muestra crea y configura todos los recursos a finde que su flujo de trabajo de Step Functions envíe un trabajo AWS Batch y esperará a que dicho trabajo secomplete antes de finalizar correctamente.

Este proyecto de muestra crea la máquina de estado, dos funciones de Lambda, una cola de AWS Batchy configura los permisos de IAM relacionados. Para obtener más información sobre los recursos que secrean con el proyecto de ejemplo Job Status Poller, consulte:

• Guía del usuario de AWS CloudFormation• Guía del usuario de AWS Batch• AWS Lambda Developer Guide• Guía de introducción a IAM

Para crear la máquina de estado Job Status Poller y aprovisionar todos los recursos:

1. Inicie sesión en la consola de Step Functions y elija Create a state machine (Crear una máquina deestado).

2. Seleccione Sample Projects y elija Job Status Poller.

Aparecen el Code (Código) y el Visual Workflow (Flujo de trabajo visual) de la máquina de estado.

82


https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/

https://docs.aws.amazon.com/batch/latest/userguide/

https://docs.aws.amazon.com/lambda/latest/dg/

https://docs.aws.amazon.com/IAM/latest/GettingStartedGuide/


AWS Step Functions Guía para desarrolladoresJob Status Poller

Note

La sección Code de esta máquina de estado hace referencia a los recursos de AWS que secrearán para este proyecto de muestra.

3. Elija Create Sample Project.

Se muestra la ventana Create Project Resources, que muestra los recursos que se crearán. Para esteproyecto de muestra los recursos incluyen:

• Una función de Lambda SubmitJob• Una función de Lambda CheckJob• Una cola de trabajo por lotes SampleJobQueue

Note

Este proceso puede tardar hasta 10 minutos mientras se crean estos recursos y los permisosde IAM relacionados. Mientras la ventana Create Project Resources muestra Creatingresources, puede abrir el enlace Stack ID para ver qué recursos se están aprovisionando.

Una vez completo, se muestra la ventana New execution, con una entrada de ejemplo similar a esta:

{ "jobName": "my-job", "jobDefinition": "arn:aws:batch:us-east-2:123456789012:job-definition/SampleJobDefinition-343f54b445d5312:1", "jobQueue": "arn:aws:batch:us-east-2:123456789012:job-queue/SampleJobQueue-4d9d696031e1449", "wait_time": 60}

Iniciación de una ejecuciónDespués de crear la máquina de estado, puede iniciar una ejecución.

Para iniciar una nueva ejecución

1. En la página New execution, introduzca un nombre de ejecución (opcional) y elija Start Execution.

83

AWS Step Functions Guía para desarrolladoresJob Status Poller

2. (Opcional) Para ayudar a identificar la ejecución, puede especificar un ID en el recuadro Enter anexecution name (Especifique un nombre de ejecución). Si no especifica ningún ID, Step Functionsgenera un ID único automáticamente.

Note


3. De forma opcional, puede acceder a la máquina de estado recién creada en el Dashboard de StepFunctions, selecciona New execution e introducir el código de entrada con los nombres o Nombre derecurso de Amazon de los recursos que acaba de crear.

Por ejemplo, la entrada de la ejecución anterior utilizando solo los nombres de recursos sería:

{ "jobName": "my-job", "jobDefinition": "SampleJobDefinition-343f54b445d5312", "jobQueue": "SampleJobQueue-4d9d696031e1449", "wait_time": 60}

Note

wait_time indica al estado Wait que se repita cada sesenta segundos.4. Seleccione Start Execution (Iniciar ejecución).


5. (Opcional) En la sección Execution Details, seleccione Info para ver el estado de ejecución enExecution Status y las marcas de tiempo Started y Closed.

6. Para ver los cambios de estado del trabajo de AWS Batch y los resultados de los bucles de laejecución, seleccione Output.

84

AWS Step Functions Guía para desarrolladoresTask Timer

Task TimerEste proyecto de muestra crea un temporizador de tarea. Implementa una máquina de estado de AWSStep Functions que implementa un estado de espera y utiliza una función Lambda para enviar unanotificación de Amazon Simple Notification Service. Un estado Wait es un tipo de estado que espera a queun disparador realice una unidad de trabajo.

Este proyecto de muestra crea la máquina de estado, una función de Lambda, un tema de Amazon SNSy configura los permisos de IAM relacionados. Para obtener más información sobre los recursos que secrean con el proyecto de ejemplo Task Timer, consulte:

• https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/• https://docs.aws.amazon.com/sns/latest/dg/• https://docs.aws.amazon.com/lambda/latest/dg/• https://docs.aws.amazon.com/IAM/latest/GettingStartedGuide/

Para crear la máquina de estado Task Timer y aprovisionar todos los recursos:

1. Inicie sesión en la consola de Step Functions y elija Create a state machine (Crear una máquina deestado).

2. Seleccione Sample Projects y elija Task Timer.

Aparecen el Code (Código) y el Visual Workflow (Flujo de trabajo visual) de la máquina de estado.

85



Note

La sección Code de esta máquina de estado hace referencia a los recursos de AWS que secrearán para este proyecto de muestra.

3. Elija Create Sample Project.

Se muestra la ventana Create Project Resources, que muestra los recursos que se crearán. Para esteproyecto de muestra los recursos incluyen:

• Una función de Lambda SendToSNS• Un tema de Amazon SNS TaskTimerTopic

Note

Este proceso puede tardar hasta 10 minutos mientras se crean estos recursos y los permisosde IAM relacionados. Mientras la ventana Create Project Resources muestra Creatingresources, puede abrir el enlace Stack ID: para ver qué recursos se están aprovisionando.

Una vez completo, se muestra la ventana New execution, con una entrada de ejemplo similar a esta:

{ "topic": "arn:aws:sns:us-east-2:123456789012:StepFunctionsSample-TaskTimer-517b8680-e0ad-07cf-feee-65aa5fc63ac0-SNSTopic-96RHT77RAKTS", "message": "HelloWorld", "timer_seconds": 10}



5. (Opcional) En la sección Execution Details, seleccione Info para ver el estado de ejecución enExecution Status y las marcas de tiempo Started y Closed.

6. Para ver los cambios de estado del trabajo de AWS Batch y los resultados de los bucles de laejecución, seleccione Output.

86


87

AWS Step Functions Guía para desarrolladoresEspecificación de Lenguaje deestados de Amazon de ejemplo

Lenguaje de estados de AmazonLenguaje de estados de Amazon es un lenguaje estructurado basado en JSON que se utiliza para definirmáquinas de estado: un conjunto de estados (p. 55), que realizan tareas (estados Task), determinana qué estados se debe pasar a continuación (estados Choice), detienen una ejecución con un error(estados Fail), etcétera. Para obtener más información, consulte Amazon States Language Specificationy Statelint, una herramienta que valida el código de Amazon States Language.

Para crear una máquina de estado en la consola de Step Functions mediante Lenguaje de estados deAmazon, consulte Introducción (p. 3).

Temas• Especificación de Lenguaje de estados de Amazon de ejemplo (p. 88)• Estructura de las máquinas de estado (p. 89)• Estados (p. 90)• Procesamiento de entrada y salida (p. 103)• Errores (p. 105)

Especificación de Lenguaje de estados de Amazonde ejemplo

{ "Comment": "An example of the Amazon States Language using a choice state.", "StartAt": "FirstState", "States": { "FirstState": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FUNCTION_NAME", "Next": "ChoiceState" }, "ChoiceState": { "Type" : "Choice", "Choices": [ { "Variable": "$.foo", "NumericEquals": 1, "Next": "FirstMatchState" }, { "Variable": "$.foo", "NumericEquals": 2, "Next": "SecondMatchState" } ], "Default": "DefaultState" },

"FirstMatchState": { "Type" : "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:OnFirstMatch", "Next": "NextState" },

"SecondMatchState": {

88

https://states-language.net/spec.html

https://github.com/awslabs/statelint


AWS Step Functions Guía para desarrolladoresEstructura de las máquinas de estado

"Type" : "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:OnSecondMatch", "Next": "NextState" },

"DefaultState": { "Type": "Fail", "Error": "DefaultStateError", "Cause": "No Matches!" },

"NextState": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:FUNCTION_NAME", "End": true } }}

Estructura de las máquinas de estadoLas máquinas de estado se definen utilizando un texto JSON que representa una estructura que contienelos siguientes campos:

Comment (Opcional)

Descripción en lenguaje natural de la máquina de estado.StartAt (Obligatorio)

Cadena que debe coincidir exactamente (mayúsculas y minúsculas) con el nombre de uno de losobjetos de estado.

TimeoutSeconds (Opcional)

Máximo número de segundos que puede durar la ejecución de la máquina de estado; si seejecuta más tiempo del especificado, se produce un error con el nombre de error (p. 106)States.Timeout.

Version (Opcional)

Versión de Lenguaje de estados de Amazon que se utiliza en la máquina de estado (el valorpredeterminado es "1.0").

States (Obligatorio)

El valor de este campo es un objeto que contiene un conjunto de estados separados por comas.

El campo States contiene el número de estados (p. 90):

{ "State1" : { },

"State2" : { }, ...}

Las máquinas de estado se definen por los estados que contienen y la relación entre ellos.

A continuación se muestra un ejemplo:

89

AWS Step Functions Guía para desarrolladoresEstados

{ "Comment": "A Hello World example of the Amazon States Language using a Pass state", "StartAt": "HelloWorld", "States": { "HelloWorld": { "Type": "Pass", "Result": "Hello World!", "End": true } }}

Cuando se inicia una ejecución de esta máquina de estado, el sistema comienza con el estado al que sehace referencia en el campo StartAt ("HelloWorld"). Si este estado tiene un campo "End": true, laejecución se detiene y se devuelven los resultados. De lo contrario, el sistema busca un campo "Next": ycontinúa con ese estado "next". Este proceso se repite hasta que el sistema alcanza un estado terminal (unestado con "Type": "Succeed", "Type": "Fail" o "End": true) o se produce un error del sistemaen tiempo de ejecución.

Las siguientes reglas se aplican a los estados de una máquina de estado:

• Los estados pueden tener lugar en cualquier orden dentro del bloque delimitado; el orden en el queaparecen no afecta al orden en el que se ejecutan, ya que este viene determinado por el contenido delos propios estados.

• En una máquina de estado, solo puede haber un estado designado como start; esta designación sehace a través del valor del campo StartAt de la estructura principal. Este estado es uno de los que seejecuta primero cuando se inicia la ejecución.

• Los estados que tienen el campo End establecido en true se consideran estados end (o terminal).En función de la lógica de la máquina de estado (por ejemplo, si la máquina de estado tiene variasramificaciones de ejecución), es posible que haya varios estados end.

• Si la máquina de estado se compone de un solo estado, este podría ser tanto el estado start como elestado end.

EstadosLos estados son elementos de nivel superior dentro del campo States de una máquina de estado ypueden adoptar diferentes roles en la máquina de estado en función de su tipo.

"FirstState" : { "Type" : "Task", ...}

Los estados se identifican por su nombre, que debe ser único dentro de la especificación de la máquina deestado, pero también puede ser cualquier cadena válida en formato de texto JSON. Cada estado contienetambién una serie de campos con opciones que varían según el contenido del campo Type del estado.

Note

Los nombres de la máquina de estado deben tener entre 1 y 80 caracteres, deben ser únicos enla cuenta y la región, y no deben incluir ninguno de los caracteres siguientes:

• Espacios en blanco• Caracteres comodín (? *)• Caracteres de corchetes (< > { } [ ])• Caracteres especiales (: ; , \ | ^ ~ $ # % & ` ")

90

AWS Step Functions Guía para desarrolladoresCampos de estado comunes

• Caracteres de control (\\u0000 - \\u001f o \\u007f - \\u009f).

Step Functions le permite crear una máquina de estado, una ejecución y nombres de actividadque contengan caracteres no ASCII. Estos nombres no ASCII no funcionan con AmazonCloudWatch. Para asegurarse de que puede realizar un seguimiento de las métricas deCloudWatch, elija un nombre que solo use caracteres ASCII.

Temas• Campos de estado comunes (p. 91)• Pass (p. 91)• Tarea (p. 92)• Choice (p. 95)• Wait (p. 98)• Succeed (p. 99)• Fail (p. 99)• Parallel (p. 100)

Campos de estado comunesType (Obligatorio)

El tipo de estado.Next

El nombre del siguiente estado que se ejecutará cuando finalice el estado actual. Algunos tipos deestado, como Choice, permiten varios estados de transición.

End

Designa este estado como un estado terminal (termina la ejecución) si está establecido en true.Puede haber un número cualquiera de estados terminales por máquina de estado. Solo se puedeutilizar Next o End en un estado. Algunos tipos de estado, como Choice, no admiten ni utilizan elcampo End.

Comment (Opcional)

Almacena una descripción en lenguaje natural del estado.InputPath (Opcional)

Una ruta (p. 103) que selecciona una parte de la entrada del estado que se va a pasar a la tareadel estado para su procesamiento. Si se omite, tiene el valor de $, que designa toda la entrada. Paraobtener más información, consulte Procesamiento de entrada y salida (p. 103).

OutputPath (Opcional)

Una ruta (p. 103) que selecciona una parte de la entrada del estado que se va a pasar a la salida delestado. Si se omite, tiene el valor de $, que designa toda la entrada. Para obtener más información,consulte Procesamiento de entrada y salida (p. 103).

PassEl estado Pass ("Type": "Pass") simplemente pasa los datos de entrada a la salida sin realizar ningunatarea. Los estados Pass son útiles cuando se construyen y depuran máquinas de estado.

Además de los campos de estado comunes (p. 91), los estados Pass permiten los siguientes campos:

91

AWS Step Functions Guía para desarrolladoresTarea

Result (Opcional)

Se considera la salida de una tarea virtual que se va a pasar al estado siguiente y se va a filtrar segúnlo determine el campo ResultPath (si está presente).

ResultPath (Opcional)

Especifica dónde (en la entrada) se coloca la "salida" de la tarea virtual especificada en Result. Laentrada se filtra según lo determine el campo OutputPath (si existe) antes de usarse como salida delestado. Para obtener más información, consulte Procesamiento de entrada y salida (p. 103).

A continuación, se muestra un ejemplo de un estado Pass que inserta algunos datos fijos en la máquinade estado, posiblemente con fines de prueba.

"No-op": { "Type": "Pass", "Result": { "x-datum": 0.381018, "y-datum": 622.2269926397355 }, "ResultPath": "$.coords", "Next": "End"}

Imagine que la entrada a este estado es:

{ "georefOf": "Home"}

En ese caso, la salida sería:

{ "georefOf": "Home", "coords": { "x-datum": 0.381018, "y-datum": 622.2269926397355 }}

TareaUn estado Task ("Type": "Task") representa una única unidad de trabajo realizada por una máquinade estado.

Además de los campos de estado comunes (p. 91), los estados Task, disponen de los siguientescampos:

Resource (Obligatorio)

Un URI, en concreto, un Nombre de recurso de Amazon (ARN) que identifica de forma inequívoca latarea específica que se va a ejecutar.


Especifica dónde (en la entrada) se colocan los resultados de la ejecución de la tarea especificada enResource. La entrada se filtra según lo determine el campo OutputPath (si existe) antes de usarsecomo salida del estado. Para obtener más información, consulte path (p. 103).

92


Retry (Opcional)

Una matriz de objetos, llamados "reintentadores", que definen una política de reintentos en caso deque el estado encuentre errores en tiempo de ejecución. Para obtener más información, consulteReintento después de un error (p. 106).

Catch (Opcional)

Una matriz de objetos, llamados "receptores", que definen un estado alternativo que se ejecutaen caso de que el estado encuentre errores en tiempo de ejecución y se haya agotado o nose haya definido la política de reintentos. Para obtener más información, consulte Estadosalternativos (p. 108).

TimeoutSeconds (Opcional)

Si la tarea se ejecuta más tiempo de los segundos especificados, este estado produce el errorStates.Timeout. Debe ser un número entero positivo, distinto de cero. Si no se proporciona, elvalor predeterminado es 99999999.

HeartbeatSeconds (Opcional)

Si transcurre más tiempo de los segundos especificados entre los latidos de la tarea, este estadoproduce el error States.Timeout. Debe ser un número entero positivo, distinto de cero e inferioral número de segundos especificado en el campo TimeoutSeconds. Si no se proporciona, el valorpredeterminado es 99999999.

Un estado Task debe establecer el campo End en true si el estado finaliza la ejecución, o bien debeproporcionar un estado en el campo Next que se ejecutará cuando finalice el estado Task.


"ActivityState": { "Type": "Task", "Resource": "arn:aws:states:us-east-1:123456789012:activity:HelloWorld", "TimeoutSeconds": 300, "HeartbeatSeconds": 60, "Next": "NextState"}

En este ejemplo, ActivityState programará la actividad HelloWorld para su ejecución en la regiónus-east-1 en la cuenta de AWS de la entidad que realiza la llamada. Cuando se complete HelloWorld,se ejecutará el siguiente estado (que aquí se llama NextState).

Si esta tarea no puede completarse en un plazo de 300 segundos o no envía notificaciones de latido enintervalos de 60 segundos, la tarea se marca como failed. Es aconsejable definir un valor de tiempo deespera y un intervalo de latido para actividades de ejecución prolongada.

Especificación de ARN de recursos en tareasEl Nombre de recurso de Amazon (ARN) del campo Resource se especifica usando el siguiente patrón:

arn:partition:service:region:account:task_type:name

Donde:

• partition es la partición de AWS Step Functions que se utiliza, normalmente aws.• service indica el servicio de AWS utilizado para ejecutar la tarea y es:

• states para una actividad (p. 94).• lambda para una función de Lambda (p. 94).

93


• region es la región de AWS en la que se ha creado el tipo de máquina de estado/actividad de StepFunctions o la función de Lambda.

• account es su ID de cuenta de AWS.• task_type es el tipo de tarea que se va a ejecutar. Puede ser uno de los siguientes valores:

• activity: una actividad (p. 94).• function: una función de Lambda (p. 94).

• name es el nombre de recurso registrado (nombre de la actividad o nombre de función de Lambda).

Note

Step Functions no permite hacer referencia a ARN entre particiones (por ejemplo, "aws-cn" nopuede invocar tareas en la partición "aws", y viceversa).

Tipos de tareasSe admiten los siguientes tipos de tareas:

• activity (p. 94)• Funciones Lambda (p. 94)

En las secciones siguientes se proporcionan más detalles sobre cada tipo.

ActividadLas actividades representan procesos o subprocesos de trabajo implementados y alojados por usted, querealizan una tarea específica.

Los ARN de resource de actividad usan la siguiente sintaxis:

arn:partition:states:region:account:activity:name

Para obtener más información sobre estos campos, consulte Especificación de ARN de recursos entareas (p. 93).

Note

Las actividades deben crearse con Step Functions (mediante una acción de la API CreateActivityo la consola de Step Functions) antes de usarse por primera vez.

Para obtener más información sobre la creación de una actividad y la implementación de procesos detrabajo, consulte Actividades (p. 56).

Funciones LambdaLa funciones Lambda ejecutan una función mediante AWS Lambda. Para especificar una función deLambda, utilice el ARN de la función de Lambda del campo Resource.

Los ARN de Resource de funciones Lambda usan la siguiente sintaxis:

arn:partition:lambda:region:account:function:function_name

Para obtener más información sobre estos campos, consulte Especificación de ARN de recursos entareas (p. 93).

Por ejemplo:

94

https://docs.aws.amazon.com/general/latest/gr/rande.html



AWS Step Functions Guía para desarrolladoresChoice

"LambdaState": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:HelloWorld", "Next": "NextState"}

Una vez especificada la función de Lambda en el campo Resource, la salida se envía al estadoidentificado en el campo Next ("NextState").

ChoiceEl estado Choice ("Type": "Choice") agrega una lógica de ramificaciones a la máquina de estado.

Además de los campos de estado comunes (p. 91), los estados Choice incorporan los camposadicionales que se indican a continuación:

Choices (Obligatorio)

Matriz de reglas de Choice (p. 96) que determina qué estado provoca que la máquina de estadoadopte el siguiente estado.

Default (opcional, recomendado)

Nombre del estado que se va a adoptar si no tiene lugar ninguna de las transiciones de Choices.

Important

Los estados Choice no admiten el campo End. Además, solamente utilizan Next dentro delcampo Choices.

A continuación, se muestra un ejemplo de un estado Choice y otros estados que adopta.

Note

Debe especificar el campo $.type. Si los datos de entrada del estado no contienen el campo$.type, la ejecución no se realizará correctamente y aparecerá un error en el historial deejecución.

"ChoiceStateX": { "Type": "Choice", "Choices": [ { "Not": { "Variable": "$.type", "StringEquals": "Private" }, "Next": "Public" }, { "Variable": "$.value", "NumericEquals": 0, "Next": "ValueIsZero" }, { "And": [ { "Variable": "$.value", "NumericGreaterThanEquals": 20 }, {

95


"Variable": "$.value", "NumericLessThan": 30 } ], "Next": "ValueInTwenties" } ], "Default": "DefaultState"},

"Public": { "Type" : "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Foo", "Next": "NextState"},

"ValueIsZero": { "Type" : "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Zero", "Next": "NextState"},

"ValueInTwenties": { "Type" : "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:Bar", "Next": "NextState"},

"DefaultState": { "Type": "Fail", "Cause": "No Matches!"}

En este ejemplo, la máquina de estado comienza con el siguiente valor de entrada:

{ "type": "Private", "value": 22}

Step Functions adopta el estado ValueInTwenties con arreglo al campo value.

Si no hay ninguna correspondencia con el campo Choices del estado Choice, se ejecuta el estadoproporcionado en el campo Default. Si no es especifica el estado Default, se produce un error en laejecución.

Reglas de ChoiceEl estado Choice debe tener un campo Choices cuyo calor sea una matriz que no este vacía, dondecada elemento sea un objeto que represente una regla de Choice. Las reglas de Choice contienen lossiguientes elementos:

• Una comparación: dos campos que especifican la variable de entrada que se va a comparar, el tipo decomparación y el valor con el que se va a comprar la variable de entrada.

• Un Next campo: el valor de este campo debe coincidir con el nombre del estado en que se encuentra lamáquina de estado.

En el ejemplo siguiente, se comprueba si el valor numérico es igual a 1:

{

96


"Variable": "$.foo", "NumericEquals": 1, "Next": "FirstMatchState"}

En el ejemplo siguiente, se comprueba si la cadena es igual a MyString:

{ "Variable": "$.foo", "StringEquals": "MyString", "Next": "FirstMatchState"}

En el ejemplo siguiente, se comprueba si la cadena es mayor que MyStringABC:

{ "Variable": "$.foo", "StringGreaterThan": "MyStringABC", "Next": "FirstMatchState"}

En el ejemplo siguiente, se comprueba si la marca de tiempo es igual a 2001-01-01T12:00:00Z:

{ "Variable": "$.foo", "TimestampEquals": "2001-01-01T12:00:00Z", "Next": "FirstMatchState"}

Step Functions examina cada una de las reglas de Choice en el orden en el que aparecen en el campoChoices y adopta el estado especificado en el campo Next de la primera regla de Choice en la que lavariable coincide con el valor que corresponde al operador de comparación.

Se admiten los siguientes operadores de comparación:

• And

• BooleanEquals

• Not

• NumericEquals

• NumericGreaterThan

• NumericGreaterThanEquals

• NumericLessThan

• NumericLessThanEquals

• Or

• StringEquals

• StringGreaterThan

• StringGreaterThanEquals

• StringLessThan

• StringLessThanEquals

• TimestampEquals

• TimestampGreaterThan

• TimestampGreaterThanEquals

• TimestampLessThan

97

AWS Step Functions Guía para desarrolladoresWait

• TimestampLessThanEquals

En cada uno de estos operadores, el valor correspondiente debe ser del tipo adecuado: cadena, número,booleano o marca de tiempo. Step Functions no intenta asociar un campo numérico con un valor decadena. Sin embargo, como los campos de marca de tiempo son cadenas lógicas, es posible que uncampo que se considera una marca de tiempo se asocie con un comparador StringEquals.

Note

Por motivos de interoperabilidad, no presuponga que las comparaciones numéricas funcionancon valores que están fuera del rango de magnitud o precisión que el tipo de datos binary64 deIEEE 754-2008 representa. En particular, es posible que los enteros que están fuera del rango[-253+1, 253-1] no puedan compararse del modo esperado.Las marcas de tiempo (por ejemplo, 2016-08-18T17:33:00Z) deben ajustarse al perfilRFC3339 de ISO 8601, con restricciones adicionales:

• Las partes de fecha y hora deben separarse con una letra T mayúscula.• Debe utilizarse una letra Z mayúscula para indicar que no se aplica ningún ajuste numérico de

zona horaria.

Para comprender el comportamiento de comparación de cadenas, consulte la documentación deJava compareTo.Los valores de los operadores And y Or deben ser matrices de reglas de Choice que no esténvacías y que no contengan campos Next. Del mismo modo, el valor de un operador Not tieneque ser una única regla de Choice que no debe contener campos Next.Puede crear reglas de Choice anidadas y complejas utilizando And, Not y Or. Sin embargo, elcampo Next solamente puede aparecer en las reglas de Choice de nivel superior.

WaitUn estado Wait ("Type": "Wait") retrasa la máquina de estado durante el tiempo especificado. Sepuede seleccionar un tiempo relativo, especificado en segundos desde el inicio del estado, o un tiempo definalización absoluto, especificado como una marca de tiempo.

Además de los campos de estado comunes (p. 91), los estados Wait tienen uno de los campossiguientes:

Seconds

Tiempo, en segundos, que se va a esperar hasta que comience el estado especificado en el campoNext.

Timestamp

Tiempo absoluto que se va a esperar hasta que comience el estado especificado en el campo Next.

Las marcas de tiempo deben ajustarse al perfil RFC3339 de ISO 8601, con la restricción adicionalde que las partes de fecha y hora deben separarse con una letra T mayúscula y debe usarse unaletra Z mayúscula para dar cuenta de que no se aplica ningún ajuste numérico de la zona horaria; porejemplo, 2016-08-18T17:33:00Z.

SecondsPath

Tiempo, en segundos, que se va a esperar hasta que comience el estado especificado en el campoNext. Se define utilizando una ruta (p. 103) en los datos de entrada del estado.

TimestampPath

Tiempo absoluto que se va a esperar hasta que comience el estado especificado en el campo Next.Se define utilizando una ruta (p. 103) en los datos de entrada del estado.

98

https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats

https://en.wikipedia.org/wiki/IEEE_754#Basic_and_interchange_formats

https://www.ietf.org/rfc/rfc3339.txt

https://www.ietf.org/rfc/rfc3339.txt

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#compareTo-java.lang.String-

https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#compareTo-java.lang.String-

AWS Step Functions Guía para desarrolladoresSucceed

Note

Solo debe especificar uno: Seconds, Timestamp, SecondsPath o TimestampPath.

Por ejemplo, los estados Wait siguientes introducen un retraso de diez segundos en una máquina deestado:

"wait_ten_seconds": { "Type": "Wait", "Seconds": 10, "Next": "NextState"}

En el ejemplo siguiente, el estado Wait espera hasta un momento especificado en términos absolutos 14de marzo de 2016, a las 1:59 p. m. UTC.

"wait_until" : { "Type": "Wait", "Timestamp": "2016-03-14T01:59:00Z", "Next": "NextState"}

La duración de Wait no tiene que codificarse de forma rígida. Por ejemplo, en el caso de los datos deentrada siguientes:

{ "expirydate": "2016-03-14T01:59:00Z"}

Puede seleccionar el valor de "expirydate" de los datos de entrada utilizando una ruta (p. 103) dereferencia:

"wait_until" : { "Type": "Wait", "TimestampPath": "$.expirydate", "Next": "NextState"}

SucceedUn estado Succeed ("Type": "Succeed") detiene correctamente una ejecución. El estado Succeed esun destino útil para las ramificaciones del estado Choice que no hacen otra cosa que detener la ejecución.

Como los estados Succeed son estados terminales, no tienen un campo Next ni necesitan tener uncampo End, por ejemplo:

"SuccessState": { "Type": "Succeed"}

FailUn estado Fail ("Type": "Fail") detiene la ejecución de la máquina de estado y la marca comoerrónea.

99

AWS Step Functions Guía para desarrolladoresParallel

El estado Fail solo permite el uso de los campos Type y Comment del conjunto de campos de estadocomunes (p. 91). Además, el estado Fail permite los siguientes campos:

Cause (Opcional)

Proporciona una cadena de error personalizada que se puede utilizar para fines operativos o dediagnóstico.

Error (Opcional)

Proporciona un nombre de error que se puede utilizar para el tratamiento de errores (Retry/Catch) ypara fines operativos o de diagnóstico.

Como el estado Fail siempre cierra la máquina de estado, no existe un campo Next ni se requiere uncampo End.

Por ejemplo:

"FailState": { "Type": "Fail", "Cause": "Invalid response.", "Error": "ErrorA"}

ParallelEl estado Parallel ("Type": "Parallel") puede utilizarse para crear ramificaciones de ejecuciónparalelas en la máquina de estado.

Además de los campos de estado comunes (p. 91), los estados Parallel introducen los camposadicionales que se detallan a continuación:

Branches (Obligatorio)

Matriz de objetos que especifica las máquinas de estado que se van a ejecutar en paralelo. Cadauno de estos objetos de la máquina de estado debe tener los campos States y StartAt, cuyossignificados son exactamente iguales a los del nivel superior de una máquina de estado.


Especifica en qué lugar (de los datos de entrada) se va a situar la salida de las ramificaciones. Laentrada se filtra según lo determine el campo OutputPath (si existe) antes de usarse como salida delestado. Para obtener más información, consulte Procesamiento de entrada y salida (p. 103).

Retry (Opcional)

Matriz de objetos, llamados "reintentadores", que definen una política de reintentos en caso de que elestado encuentre errores en tiempo de ejecución. Para obtener más información, consulte Reintentodespués de un error (p. 106).

Catch (Opcional)

Matriz de objetos, llamados "receptores", que definen un estado alternativo que se ejecuta en caso deque el estado encuentre errores en tiempo de ejecución y se haya agotado o no se haya definido lapolítica de reintentos. Para obtener más información, consulte Estados alternativos (p. 108).

Un estado Parallel hace que AWS Step Functions ejecute cada ramificación, comenzando con el estadoespecificado en el campo StartAt de esa ramificación, con la mayor simultaneidad posible, y espera

100


hasta que terminan todas las ramificaciones (alcanzan un estado terminal) antes de procesar el campoNext del estado Parallel.


{ "Comment": "Parallel Example.", "StartAt": "LookupCustomerInfo", "States": { "LookupCustomerInfo": { "Type": "Parallel", "End": true, "Branches": [ { "StartAt": "LookupAddress", "States": { "LookupAddress": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:AddressFinder", "End": true } } }, { "StartAt": "LookupPhone", "States": { "LookupPhone": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:PhoneFinder", "End": true } } } ] } }}

En este ejemplo, las ramificaciones LookupAddress y LookupPhone se ejecutan en paralelo. Acontinuación se muestra el aspecto del flujo de trabajo en la consola de Step Functions:

101


Cada una de las ramificaciones debe ser autónoma. Los estados de una ramificación de un estadoParallel no deben incluir un campo Next que tenga como destino un campo que está fuera de laramificación ni ningún otro estado fuera de la ramificación puede cambiar a esa ramificación.

Salida del estado ParallelEl estado Parallel proporciona a cada ramificación una copia de sus propios datos de entrada (sujetosa las modificaciones realizadas por el campo InputPath). Genera la salida, que es una matriz con unelemento para cada ramificación que contiene la salida de dicha ramificación. No es necesario que todoslos elementos sean del mismo tipo. La matriz de salida puede insertarse en los datos de entrada (y elconjunto enviado como salida del estado Parallel) a través del campo ResultPath de la forma habitual(consulte Procesamiento de entrada y salida (p. 103)).

Este es otro ejemplo:

{ "Comment": "Parallel Example.", "StartAt": "FunWithMath", "States": { "FunWithMath": { "Type": "Parallel", "End": true, "Branches": [ { "StartAt": "Add", "States": { "Add": { "Type": "Task", "Resource": "arn:aws:swf:us-east-1:123456789012:task:Add", "End": true } } }, { "StartAt": "Subtract", "States": { "Subtract": { "Type": "Task", "Resource": "arn:aws:swf:us-east-1:123456789012:task:Subtract", "End": true } } } ] } }}

Si al estado FunWithMath se le proporcionó como entrada la matriz [3, 2], tanto el estado Add como elestado Subtract recibirán esa matriz como datos de entrada. La salida de Add sería 5, la de Subtractsería 1 y la del estado Parallel sería una matriz:

[ 5, 1 ]

Control de errores

Si alguna ramificación no se ejecuta correctamente por un error no controlado o porque cambia a unestado Fail, se considera que el error afecta a todo el estado Parallel y se detienen todas lasramificaciones. Si el error no está gestionado por el propio estado Parallel, Step Functions detendrá laejecución con un error.

102

AWS Step Functions Guía para desarrolladoresProcesamiento de entrada y salida

Note

Cuando un estado Parallel no se ejecuta correctamente, las funciones de Lambda invocadasse siguen ejecutando y los trabajadores de actividad que procesan un token de tarea no sedetendrán:

• Para detener actividades de ejecución prolongada utilice latidos para detectar si Step Functionsha detenido su ramificación y detenga a los trabajadores que están procesando tareas. Llamara SendTaskHeartbeat, SendTaskSuccess o SendTaskFailure generará un error si elestado ha producido un error. Consulte Errores de latido.

• La ejecución de funciones de Lambda no se puede detener. Si ha implementado unaalternativa, utilice un estado Wait de modo que el trabajo de limpieza se realice una vezfinalizada la función de Lambda.

Procesamiento de entrada y salidaEn esta sección aprenderá a utilizar rutas y rutas de referencia para el procesamiento de entrada y salida.

Note

Para obtener información general, consulte Procesamiento de entrada y salida en StepFunctions (p. 66) en la sección Cómo funciona Step Functions (p. 55).

RutasEn Lenguaje de estados de Amazon, una ruta es una cadena que empieza por $ que puede utilizar paraidentificar componentes en texto JSON. Las rutas siguen la sintaxis de JsonPath.

Rutas de referenciaUna ruta de referencia es una ruta cuya sintaxis está limitada de tal forma que solo puede identificar unúnico nodo en una estructura JSON:

• Solo puede obtener acceso a los campos de objeto con la notación de punto (.) y corchete ([ ]).• No se admiten los operadores @ .. , : ? *.• Funciones como length() no son compatibles.

Por ejemplo, los datos de entrada de estado contienen los siguientes valores:

{ "foo": 123, "bar": ["a", "b", "c"], "car": { "cdr": true }}

En este caso, las siguientes rutas de referencia devolverían:

$.foo => 123$.bar => ["a", "b", "c"]$.car.cdr => true

Algunos estados utilizan rutas y rutas de referencia para controlar el flujo de una máquina de estado o paraconfigurar valores u opciones de estado.

103


https://docs.aws.amazon.com/step-functions/latest/apireference/API_SendTaskSuccess.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_SendTaskFailure.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_SendTaskHeartbeat.html#API_SendTaskHeartbeat_Errors


AWS Step Functions Guía para desarrolladoresRutas de referencia

Rutas de los campos InputPath, ResultPath y OutputPathPara especificar cómo se utiliza la parte de la entrada del estado y qué se envía como salida al siguienteestado, puede utilizar InputPath, OutputPath y ResultPath:

• Para InputPath y OutputPath, debe utilizar una ruta (p. 103) que siga la sintaxis de JsonPath.• Para ResultPath, debe utilizar una ruta de referencia (p. 103).

InputPathEl campo InputPath selecciona una parte de la entrada del estado que se va a pasar a la tarea delestado para su procesamiento. Si omite el campo, se obtiene el valor $, que representa la totalidad de laentrada. Si utiliza null, se descarta la entrada (no se envía a la tarea de estado) y la tarea recibe el textoJSON que representa un objeto vacío {}.

Note

Una ruta puede generar una selección de valores. Considere el siguiente ejemplo:

{ "a": [1, 2, 3, 4] }

Si aplica la ruta $.a[0:2], el resultado es el siguiente:

[ 1, 2 ]

ResultPathNormalmente, si un estado ejecuta una tarea, los resultados de la tarea se envía como la salida del estado(que pasa a ser la entrada de la siguiente tarea).

Si un estado no ejecuta una tarea, se envía la propia entrada del estado sin modificar como su salida. Sinembargo, cuando se especifica una ruta en el valor de los campos ResultPath y OutputPath de unestado, se pueden dar varias situaciones.

ResultPath toma los resultados de ejecutar la tarea del estado y los coloca en la entrada. Acontinuación, OutputPath selecciona una parte de la entrada para enviarla como salida del estado.ResultPath podría añadir los resultados de ejecutar la tarea del estado a la entrada, sobrescribir unaparte existente o sobrescribir toda la entrada:

• Si ResultPath coincide con un elemento de la entrada del estado, solo se sobrescribe este elementode entrada con los resultados de ejecutar la tarea del estado. Toda la entrada modificada vuelve a estardisponible en la salida del estado.

• Si ResultPath no coincide con un elemento de la entrada del estado, se añade el elemento a laentrada. El elemento contiene los resultados de ejecutar la tarea del estado. La entrada expandidavuelve a estar disponible en la salida del estado.

• Si ResultPath tiene el valor predeterminado de $, coincide con toda la entrada. En este caso, losresultados de la ejecución del estado sobrescriben toda la entrada y la entrada vuelve a estar disponiblepara su procesamiento.

• Si ResultPath es null, los resultados de la ejecución del estado se descartan y la entrada se quedatal como está.

Note

Los valores del campo ResultPath deben ser rutas de referencia (p. 103). Para obtener másinformación sobre ResultPath, consulte Descripción de ResultPath (p. 67).

104


AWS Step Functions Guía para desarrolladoresErrores

OutputPath

• Si OutputPath coincide con un elemento de la entrada del estado, solo se selecciona ese elemento deentrada. Este elemento de entrada se convierte en la salida del estado.

• Si OutputPath no coincide con un elemento de la entrada del estado, se produce una excepción queindica que la ruta no es válida. Para obtener más información, consulte Errores (p. 105).

• Si OutputPath tiene el valor predeterminado de $, el elemento coincide con toda la entrada. En estecaso, la totalidad de la entrada se pasa al siguiente estado.

• Si OutputPath es null, el texto JSON que representa un objeto vacío {} se envía al siguiente estado.

El siguiente ejemplo ilustra cómo funcionan los campos InputPath, ResultPath y OutputPath en lapráctica. Considere la siguiente entrada para el estado actual:

{ "title": "Numbers to add", "numbers": { "val1": 3, "val2": 4 }}

Además, el estado tiene los siguientes campos InputPath, ResultPath y OutputPath:

"InputPath": "$.numbers","ResultPath": "$.sum","OutputPath": "$"

La tarea del estado recibe solo el objeto numbers de la entrada. A su vez, si esta tarea devuelve 7, lasalida de este estado es la siguiente:

{ "title": "Numbers to add", "numbers": { "val1": 3, "val2": 4 } "sum": 7}

Puede modificar ligeramente el campo OutputPath:

"InputPath": "$.numbers","ResultPath": "$.sum","OutputPath": "$.sum"

Como antes, utilice los siguientes datos de entrada del estado:

{ "numbers": { "val1": 3, "val2": 4 }}

Sin embargo, ahora los datos de salida del estado son 7.

ErroresCualquier estado puede registrar errores en tiempo de ejecución. Los errores pueden surgir debido aproblemas de definición de la máquina de estado (por ejemplo, no hay ninguna regla coincidente en unestado Choice), errores en las tareas (por ejemplo, se produce una excepción de una función de Lambda)

105

AWS Step Functions Guía para desarrolladoresRepresentación de errores

o debido a problemas transitorios, como eventos de partición de red. Cuando un estado registra un error, elprocedimiento predeterminado de AWS Step Functions es producir un error en toda la ejecución.

Representación de erroresLos errores se identifican en Lenguaje de estados de Amazon por cadenas que distinguen mayúsculasde minúsculas, denominadas "nombres de error". Lenguaje de estados de Amazon define un conjuntointegrado de cadenas que designan errores conocidos, que comienzan por el prefijo "States".:

Códigos de error predefinidos

States.ALL

Un nombre comodín que coincide con cualquier nombre de error.States.Timeout

Un estado Task se ha ejecutado durante más tiempo que el especificado en el valor"TimeoutSeconds" o no pudo enviar un latido durante un tiempo mayor que el especificado en el valor"HeartbeatSeconds".

States.TaskFailed

Un estado Task produjo un error durante la ejecución.States.Permissions

Un estado Task produjo un error porque no tenía privilegios suficientes para ejecutar el códigoespecificado.

Los estados pueden registrar errores con otros nombres, que no deben empezar por el prefijo "States".

Reintento después de un errorLos estados Task y Parallel pueden tener un campo llamado Retry, cuyo valor debe ser una matriz deobjetos, denominados "reintentadores". Un reintentador individual representa un número determinado dereintentos, normalmente en intervalos de tiempo en aumento.

Note

Los reintentos se tratan como transiciones de estado. Para obtener más información sobre cómoafectan las transiciones de estado a la facturación, consulte Precios de Step Functions.

Un reintentador contiene los siguientes campos:


Una matriz no vacía de cadenas que coinciden con nombres de error. Cuando un estado registra unerror, Step Functions realiza un examen a través de los reintentadores y, cuando el nombre de erroraparece en esta matriz, implementa la política de reintentos descrita en este reintentador.

IntervalSeconds (Opcional)

Un número entero que representa el número de segundos antes del primer reintento (el valorpredeterminado es 1).

MaxAttempts (Opcional)

Un número entero positivo que representa el número máximo de reintentos (el valor predeterminadoes 3). Si el error se repite más veces de las especificadas, se interrumpen los reintentos y se reanudala administración normal de errores. Se permite un valor de 0 e indica que el error o los errores no sedeben reintentar nunca.

106



BackoffRate (Opcional)

Un número que es el multiplicador en el que aumenta el intervalo de reintentos en cada intento (elvalor predeterminado es 2,0).

A continuación, se muestra un ejemplo de un campo Retry que realiza dos reintentos tras dos esperas de 3y 4,5 segundos:

"Retry" : [ { "ErrorEquals": [ "States.Timeout" ], "IntervalSeconds": 3, "MaxAttempts": 2, "BackoffRate": 1.5 }]

El nombre reservado States.ALL que aparece en el campo ErrorEquals de un reintentador esun nombre comodín que coincide con cualquier nombre de error. Debe aparecer solo en la matrizErrorEquals y debe aparecer en el último reintentador de la matriz Retry.

A continuación, se muestra un ejemplo de un campo Retry que reintentará cualquier error, excepto paraStates.Timeout:

"Retry" : [ { "ErrorEquals": [ "States.Timeout" ], "MaxAttempts": 0 }, { "ErrorEquals": [ "States.ALL" ] }]

Escenarios de reintentos complejosLos parámetros de un reintentador se aplican a todas las visitas que se realizan a dicho reintentadordurante la ejecución de un único estado. Esto se ilustra mejor con un ejemplo; considere el siguienteestado Task:

"X": { "Type": "Task", "Resource": "arn:aws:states:us-east-1:123456789012:task:X", "Next": "Y", "Retry": [ { "ErrorEquals": [ "ErrorA", "ErrorB" ], "IntervalSeconds": 1, "BackoffRate": 2.0, "MaxAttempts": 2 }, { "ErrorEquals": [ "ErrorC" ], "IntervalSeconds": 5 } ], "Catch": [ { "ErrorEquals": [ "States.ALL" ], "Next": "Z"

107


} ]}

Supongamos que esta tarea falla cinco veces seguidas y devuelve los nombres de error: "ErrorA","ErrorB", "ErrorC", "ErrorB" y "ErrorB". Los dos primeros errores coinciden con el primer reintentador,y generan esperas de uno y dos segundos. El tercer error coincide con el segundo reintentador, y generauna espera de cinco segundos. El cuarto error coincide con el primer reintentador y produce una esperade cuatro segundos. El quinto error también coincide con el primer reintentador, pero como ya se haalcanzado el límite de dos reintentos ("MaxAttempts") para ese error en concreto ("ErrorB"), se produceun error y la ejecución se redirige al estado "Z" a través del campo "Catch".

Tenga en cuenta que una vez que el sistema pasa a otro estado, de la manera que sea, se restablecen losparámetros de todos los reintentadores.

Note

Puede generar nombres de error personalizados (por ejemplo, ErrorA y ErrorB arriba)utilizando una actividad (p. 94) o funciones Lambda (p. 94). Para obtener más información,consulte Administrar las condiciones de error con una máquina de estado (p. 26).

Estados alternativosLos estados Task y Parallel pueden tener un campo llamado Catch, cuyo valor debe ser una matriz deobjetos, denominados "receptores".

Un receptor contiene los siguientes campos:


Una matriz no vacía de cadenas que coinciden con nombres de error, especificados exactamentecomo se indicaron en el campo Retrier del mismo nombre.

Next (Obligatorio)

Una cadena que debe coincidir exactamente con uno de los nombres de estado de la máquina deestado.


Una ruta (p. 103) que determina lo que se envía como entrada al estado especificado por el campoNext.

Cuando un estado registra un error y no hay ningún campo Retry o ningún reintento ha conseguidoresolver el error, AWS Step Functions realiza un examen a través de los receptores en el orden indicadoen la matriz y, cuando el nombre de error aparece en el campo ErrorEquals del receptor, la máquina deestado pasa al estado designado en el campo Next.

El nombre reservado States.ALL que aparece en el campo ErrorEquals de un receptor es un nombrecomodín que coincide con cualquier nombre de error. Debe aparecer solo en la matriz ErrorEquals ydebe aparecer en el último receptor de la matriz Catch.

A continuación, se muestra un ejemplo de un campo Catch que moverá la máquina de estado al estadodenominado "RecoveryState" cuando una función de Lambda produzca una excepción Java no controlada;en caso contrario, pasará al estado "EndState".

"Catch": [ { "ErrorEquals": [ "java.lang.Exception" ], "ResultPath": "$.error-info",

108


"Next": "RecoveryState" }, { "ErrorEquals": [ "States.ALL" ], "Next": "EndState" }]

Cada receptor puede especificar varios errores para su tratamiento.

Cuando AWS Step Functions pasa al estado especificado en un receptor, este estado se envía comoun texto JSON de entrada que es diferente del que se enviaría normalmente al siguiente estado si no sehubiera producido ningún error. Este texto JSON representa un objeto que contiene un campo "Error"cuyo valor es una cadena que contiene el nombre de error. Normalmente, el objeto también contendrá uncampo "Cause", que es una descripción en lenguaje natural del error. Denominamos a este objeto "salidade error".

En este ejemplo, el primer receptor contiene un campo ResultPath. Esto funciona de forma similar aun campo ResultPath en el nivel superior de un estado: toma los resultados de ejecutar el estado ysobrescribe una parte de la entrada del estado o toda la entrada del estado, o toma los resultados y losañade a la entrada. En el caso de un error gestionado por un receptor, el resultado de ejecutar el estado esla salida de error.

Por lo tanto, en el ejemplo, para el primer receptor se añadirá la salida de error a la entrada como uncampo denominado error-info (suponiendo que aún no existe un campo con ese nombre en la entrada)y toda la entrada se enviará a RecoveryState. Para el segundo receptor, la salida de error sobrescribirála entrada y se enviará a EndState. Si no se especifica ningún valor, el campo ResultPath se establecede forma predeterminada en $, que selecciona y, por tanto, sobrescribe toda la entrada.

Cuando un estado tiene ambos campos Retry y Catch, Step Functions utiliza primero alguno de losreintentadores correspondientes y solo aplica la transición del receptor coincidente si la política dereintentos no puede resolver el error.

109

AWS Step Functions Guía para desarrolladoresUtilice tiempos de espera para

evitar las ejecuciones bloqueadas

Prácticas recomendadas para StepFunctions

Las siguientes prácticas recomendadas para implementar flujos de trabajo de Step Functions puedenayudarle a optimizar el desempeño de las implementaciones.

Temas• Utilice tiempos de espera para evitar las ejecuciones bloqueadas (p. 110)• Utilice ARN en lugar de pasar cargas de gran tamaño (p. 110)• Evitar alcanzar el límite de historial (p. 111)• Control de excepciones de servicio en Lambda (p. 111)

Utilice tiempos de espera para evitar lasejecuciones bloqueadas

De forma predeterminada, el Lenguaje de estados de Amazon no establece tiempos de espera en lasdefiniciones de las máquinas de estado. Sin un tiempo de espera explícito, Step Functions a menudose basa únicamente en una respuesta de un empleado de la actividad para saber que una tarea se hacompletado. Si algo va mal y no se especifica TimeoutSeconds, una ejecución se bloquea esperandouna respuesta que nunca llegará.

Para evitar esto, especifique un límite de tiempo de espera razonable cuando cree una tarea en la máquinade estado. Por ejemplo:

"ActivityState": { "Type": "Task", "Resource": "arn:aws:states:us-east-1:123456789012:activity:HelloWorld", "TimeoutSeconds": 300, "HeartbeatSeconds": 60, "Next": "NextState"}

Para obtener más información, consulte Tarea (p. 92) en la documentación del Lenguaje de estados deAmazon.

Utilice ARN en lugar de pasar cargas de grantamaño

Las ejecuciones que pasan cargas de gran tamaño entre los estados pueden terminarse. Si los datos quese pasan entre los estados pueden superar los 32 K, utilice Amazon Simple Storage Service (Amazon S3)para almacenarlos y pase el Nombre de recurso de Amazon en lugar de los datos sin procesar. Tambiénpuede ajustar la implementación para que se pasen cargas más pequeñas en las ejecuciones.


110

AWS Step Functions Guía para desarrolladoresEvitar alcanzar el límite de historial

• Guía para desarrolladores de Amazon Simple Storage Service• Nombres de recursos de Amazon (ARN)

Evitar alcanzar el límite de historialAWS Step Functions tiene un límite máximo de 25 000 entradas en el historial de ejecución. Para evitaralcanzar este límite en las ejecuciones prolongadas, implemente un patrón que use una función AWSLambda que puede comenzar una nueva ejecución de la máquina de estado para dividir el trabajo encurso en varias ejecuciones de flujo de trabajo.

Para obtener más información, consulte el tutorial Continuar como una nueva ejecución (p. 46).

Control de excepciones de servicio en LambdaEn ocasiones, AWS Lambda puede experimentar errores de servicio transitorios. Si se invoca Lambda enesta situación, se producirá un error 500, como ServiceException o SdkClientException. Use lapráctica recomendada de controlar estas excepciones de manera protectora en la máquina de estado yejecutar Retry para volver a invocar la función Lambda o Catch para capturar el error.

Los errores de Lambda se notifican como Lambda.ErrorName. Para reintentar la función Lambdadespués de una excepción de error de servicio, puede usar el código Retry siguiente:

"Retry": [ { "ErrorEquals": [ "Lambda.ServiceException", "Lambda.SdkClientException"], "IntervalSeconds": 2, "MaxAttempts": 6, "BackoffRate": 2} ]

Note

Los errores no administrados de Lambda se indican como Lambda.Unknown en la salida deerrores. Incluyen errores de falta de memoria, tiempos de espera de funciones agotados yalcanzar el límite de invocaciones de Lambda simultáneas. Puede buscar correspondenciascon Lambda.Unknown, States.ALL o States.TaskFailed para administrar estos errores.Para obtener más información sobre los errores Handled y Unhandled de Lambda, consulteFunctionError en la AWS Lambda Developer Guide.


• Reintento después de un error (p. 75)• Administración de las condiciones de error con una máquina de estado (p. 26)• InvoqueErrores de Invoke de Lambda

111

https://docs.aws.amazon.com/AmazonS3/latest/dev/

https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html


https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_Errors

AWS Step Functions Guía para desarrolladoresLímites generales

LímitesAWS Step Functions impone límites en el tamaño de algunos parámetros de la máquina de estado,como el número de acciones de la API que puede realizar durante un determinado periodo de tiempo oel número de máquinas de estado que puede definir. Aunque estos límites se han diseñado para impedirque una máquina de estado configurada erróneamente consuma todos los recursos del sistema, no soninflexibles.

Note

Si una determinada etapa de la ejecución de su máquina de estado o actividad tarda demasiadotiempo, puede configurar el tiempo de espera de una máquina de estado para producir un eventode tiempo de espera agotado.

Temas• Límites generales (p. 112)• Límites relacionados con las cuentas (p. 113)• Límites relacionados con ejecuciones de máquinas de estado (p. 113)• Límites relacionados con las ejecuciones de tareas (p. 113)• Límites relacionados con las limitaciones de acciones de API (p. 114)• Límites relacionados con las limitaciones de estados (p. 115)• Solicitar un aumento de límite (p. 115)

Límites generalesLímite Descripción

Nombre de la máquina de estado Los nombres de la máquina de estado deben tenerentre 1 y 80 caracteres, deben ser únicos en lacuenta y la región, y no deben incluir ninguno delos caracteres siguientes:

• Espacios en blanco• Caracteres comodín (? *)• Caracteres de corchetes (< > { } [ ])• Caracteres especiales (: ; , \ | ^ ~ $ # %& ` ")

• Caracteres de control (\\u0000 - \\u001f o \\u007f - \\u009f).

Step Functions le permite crear una máquina deestado, una ejecución y nombres de actividad quecontengan caracteres no ASCII. Estos nombres noASCII no funcionan con Amazon CloudWatch. Paraasegurarse de que puede realizar un seguimientode las métricas de CloudWatch, elija un nombreque solo use caracteres ASCII.

112

AWS Step Functions Guía para desarrolladoresLímites relacionados con las cuentas

Límites relacionados con las cuentasLímite Descripción

Número máximo de actividades registradas 10 000

Número máximo de máquinas de estadoregistradas

10 000

Número máximo de acciones de API Además de los picos infrecuentes, las aplicacionespueden sufrir limitaciones si realizan un grannúmero de acciones de API en un periodo detiempo muy corto.

Tamaño máximo de solicitud 1 MB por solicitud. Este es el tamaño total de losdatos para cada solicitud API de Step Functions,incluido el encabezado de la solicitud y todos losdemás datos de solicitud relacionados.

Límites relacionados con ejecuciones de máquinasde estado

Límite Descripción

Máximo de ejecucionesabiertas

1 000 000

Tiempo máximo deejecución

1 año. Si una ejecución dura más del límite de 1 año, se produce el errorStates.Timeout y se emite una métrica ExecutionsTimedout deCloudWatch.

Tamaño máximo delhistorial de ejecución

25 000 eventos

Tiempo máximo deinactividad de ejecución

1 año (limitado por el tiempo de ejecución)

Tiempo máximo deretención del historial deejecución

90 días. Transcurrido ese plazo, no podrá ver ni recuperar el historial deejecuciones. No hay ningún límite con respecto al número de ejecucionescerradas que conserva Step Functions.

Número máximo deejecuciones mostradasen la consola de StepFunctions

La consola de Step Functions muestra un máximo de 1 000 ejecuciones pormáquina de estado. Si tiene más de 1 000 ejecuciones, utilice las acciones dela API de Step Functions o la AWS CLI para mostrar todas las ejecuciones.

Límites relacionados con las ejecuciones de tareasLímite Descripción

Tiempo máximo de ejecución de la tarea 1 año (limitado por el tiempo de ejecución)

113



AWS Step Functions Guía para desarrolladoresLímites relacionados con las limitaciones de acciones de API

Límite Descripción

Tiempo máximo que Step Functions mantiene unatarea en la cola

1 año (limitado por el tiempo de ejecución)

Sondeadores de actividades máximos por ARN 1 000 sondeadores llaman a GetActivityTaskpor Nombre de recurso de Amazon. Si se excedeeste límite, da lugar al error: "Se ha alcanzadoel número máximo de procesos de trabajo quesondean de forma simultánea las tareas deactividad".

Tamaño máximo de los datos de entrada oresultados para una tarea, estado o ejecución

32,768 caracteres. Este límite afecta a las tareas(actividad o función de Lambda), a los datos deresultados de los estados o las ejecuciones y a losdatos de entrada cuando se programa una tarea,se entra en un estado o se inicia una ejecución.

Límites relacionados con las limitaciones deacciones de API

Algunas acciones de la API de Step Functions se limitan mediante un esquema de bucket de token paramantener el ancho de banda del servicio.

Note

Estas limitaciones se aplican por cuenta y región. AWS Step Functions puede aumentar el tamañoy la velocidad de reposición de los buckets en cualquier momento. No confíe en estas tasas delimitación para limitar sus costos.

Nombre de API Tamaño del bucket Velocidad de reposición porsegundo

CreateActivity 100 1

CreateStateMachine 100 1

DeleteActivity 100 1

DeleteStateMachine 100 1

DescribeActivity 200 1

DescribeExecution 200 2

DescribeStateMachine 200 1

DescribeStateMachineForExecution100 1

GetActivityTask 1 000 25

GetExecutionHistory 250 5

ListActivities 100 1

ListExecutions 100 2

114

AWS Step Functions Guía para desarrolladoresLímites relacionados con las limitaciones de estados

Nombre de API Tamaño del bucket Velocidad de reposición porsegundo

ListStateMachines 100 1

SendTaskFailure 1 000 25

SendTaskHeartbeat 1 000 25

SendTaskSuccess 1 000 25

StartExecution: en US East(N. Virginia), EE.UU. Oeste(Oregón) y UE (Irlanda)

1 000 200

StartExecution: las demásregiones

500 25

StopExecution: en US East(N. Virginia), EE.UU. Oeste(Oregón) y UE (Irlanda)

1 000 200

StopExecution: las demásregiones

500 25

UpdateStateMachine 200 1

Límites relacionados con las limitaciones deestados

Las transiciones de estado de Step Functions se limitan mediante un esquema de bucket de token paramantener el ancho de banda del servicio.

Note

La limitación controlada en la métrica del servicio StateTransition se comunica comoExecutionThrottled en CloudWatch. Para obtener más información, consulte la métrica deCloudWatch ExecutionThrottled (p. 117).

Métricas de servicio Tamaño del bucket Velocidad de reposición porsegundo

StateTransition: en USEast (N. Virginia), EE.UU. Oeste(Oregón) y UE (Irlanda)

5 000 1 000

StateTransition: las demásregiones

800 400

Solicitar un aumento de límiteUse la página del Centro de soporte de la Consola de administración de AWS para solicitar un aumento delímite para los recursos que ofrece AWS Step Functions por cada región. Para obtener más información,consulte Para solicitar un aumento de límite en la AWS General Reference.

115

https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html

AWS Step Functions Guía para desarrolladoresMonitorización de Step Functions con CloudWatch

Monitorización y registroEn esta sección se proporciona información sobre la monitorización y el registro de Step Functions.

Temas• Monitorización de Step Functions con CloudWatch (p. 116)• Registro de Step Functions con CloudTrail (p. 123)

Monitorización de Step Functions con CloudWatchLa monitorización es una parte importante para mantener la fiabilidad, la disponibilidad y el desempeñode AWS Step Functions y las soluciones de AWS. Para que le resulte más sencillo depurar los erroresque se producen en distintas partes del código, debe recopilar la mayor cantidad posible de datos demonitorización de los servicios de AWS que utilice. Antes de empezar a monitorizar Step Functions, debecrear un plan de monitorización que responda a las siguientes preguntas:

• ¿Cuáles son los objetivos de la monitorización?• ¿Qué recursos va a monitorizar?• ¿Con qué frecuencia va a monitorizar estos recursos?• ¿Qué herramientas de monitorización va a utilizar?• ¿Quién se encargará de realizar las tareas de monitorización?• ¿Quién debería recibir una notificación cuando surjan problemas?

El siguiente paso consiste en establecer un punto de referencia en el entorno que se considereun desempeño de Step Functions normal. Para ello, mida el desempeño en diversas ocasiones ycon diferentes condiciones de carga. Cuando monitorice Step Functions, debe tener en cuenta elalmacenamiento de los datos históricos de monitorización. Estos datos pueden servirle como referenciapara compararlos con los datos de desempeño actuales, para identificar los patrones de desempeñonormales y las anomalías del desempeño, y para idear métodos de solución de problemas.

Por ejemplo, con Step Functions, puede supervisar cuántas actividades o tareas de Lambda hanexperimentado errores porque se ha agotado el tiempo de espera del latido. Si el desempeño se sale de lareferencia establecida, es posible que tenga que cambiar el intervalo de latidos.

Para establecer un punto de referencia debe, como mínimo, monitorizar las siguientes métricas:

• ActivitiesStarted

• ActivitiesTimedOut

• ExecutionsStarted

• ExecutionsTimedOut

• LambdaFunctionsStarted

• LambdaFunctionsTimedOut

En las secciones siguientes, se describen las métricas que Step Functions proporciona a CloudWatch.Puede utilizarlas para supervisar las máquinas de estado y las actividades, así como para estableceralarmas en los valores que actúan como umbral. Puede consultar las métricas utilizando la Consola deadministración de AWS.

Temas

116

AWS Step Functions Guía para desarrolladoresMétricas que registran un intervalo de tiempo

• Métricas que registran un intervalo de tiempo (p. 117)• Métricas que registran un recuento (p. 117)• Métricas de las máquinas de estado (p. 117)• Consulta de métricas de Step Functions (p. 120)• Configuración de alarmas en Step Functions (p. 121)

Métricas que registran un intervalo de tiempoAlgunas de las métricas de CloudWatch para Step Functions son intervalos de tiempo, que siempre semiden en milisegundos. Estas métricas, por lo general, se corresponden con fases de ejecución en las quepuede definir tiempos de espera para las máquinas de estado, las actividades y las funciones de Lambda,utilizando nombres descriptivos.

Por ejemplo, la métrica ActivityRunTime mide el tiempo que tarda una actividad en completarse unavez que comienza su ejecución Puede establecer un tiempo de espera con este mismo período de tiempo.

En la consola de CloudWatch, obtendrá mejores resultados si selecciona average como la estadística quedebe aparecer con las métricas de intervalo de tiempo.

Métricas que registran un recuentoAlgunas de las métricas de CloudWatch para Step Functions registran los resultados en forma de recuento.Por ejemplo, ExecutionsFailed registra el número o recuento de ejecuciones con errores de lamáquina de estado.

En la consola de CloudWatch, obtendrá mejores resultados si selecciona sum como la estadística quedebe aparecer con las métricas de recuento.

Métricas de las máquinas de estadoLas métricas disponibles para las máquinas de estado de Step Functions son las siguientes:

Métricas de ejecuciónEl espacio de nombres AWS/States incluye las siguientes métricas para las ejecuciones de StepFunctions:

Métrica Descripción

ExecutionTime El intervalo, en milisegundos, entre el momento en que se inicia laejecución y el momento en que se cierra.

ExecutionThrottled El número de eventos StateEntered y de reintentos que hansido objeto de una limitación controlada. Está relacionado conla limitación controlada de StateTransition. Para obtener másinformación, consulte Límites relacionados con las limitaciones deestados en la Guía para desarrolladores de AWS Step Functions.

ExecutionsAborted El número de ejecuciones canceladas o terminadas.

ExecutionsFailed El número de ejecuciones que han producido un error.

ExecutionsStarted El número de ejecuciones iniciadas.

ExecutionsSucceeded El número de ejecuciones realizadas correctamente.

117

https://docs.aws.amazon.com/step-functions/latest/dg/limits.html#service-limits-api-state-throttling

https://docs.aws.amazon.com/step-functions/latest/dg/limits.html#service-limits-api-state-throttling

AWS Step Functions Guía para desarrolladoresMétricas de las máquinas de estado


ExecutionsTimedOut El número de ejecuciones cuyo tiempo de espera se agotó por algúnmotivo.

Dimensiones de métricas de ejecución de Step Functions

Dimensión Descripción

StateMachineArn El ARN de la máquina de estado de la ejecución en cuestión.

Métricas de actividadEl espacio de nombres AWS/States incluye las siguientes métricas para las actividades de StepFunctions:


ActivityRunTime El intervalo, en milisegundos, entre el momento en que se inicia laactividad y el momento en que se cierra.

ActivityScheduleTime El intervalo, en milisegundos, en el que la actividad permanece en elestado de programación.

ActivityTime El intervalo, en milisegundos, entre el momento en que se programala actividad y el momento en que se cierra.

ActivitiesFailed El número de actividades que han producido un error.

ActivitiesHeartbeatTimedOutEl número de actividades cuyo tiempo de espera se agotó debido aque se agotó el tiempo de espera del latido.

ActivitiesScheduled El número de actividades programadas.

ActivitiesStarted El número de actividades iniciadas.

ActivitiesSucceeded El número de actividades realizadas correctamente.

ActivitiesTimedOut El número de actividades cuyo tiempo de espera se agotó durante elcierre.

Dimensión de métricas de actividad de Step Functions


ActivityArn El ARN de la actividad.

Métricas de funciones LambdaEl espacio de nombres AWS/States incluye las siguientes métricas para las funciones Lambda de StepFunctions:

118

AWS Step Functions Guía para desarrolladoresMétricas de las máquinas de estado


LambdaFunctionRunTime El intervalo, en milisegundos, entre el momento en que se inicia lafunción Lambda y el momento en que se cierra.

LambdaFunctionScheduleTime El intervalo, en milisegundos, en el que la función Lambdapermanece en el estado de programación.

LambdaFunctionTime El intervalo, en milisegundos, entre el momento en que se programala función Lambda y el momento en que se cierra.

LambdaFunctionsFailed El número de funciones Lambda que han producido un error.

LambdaFunctionsHeartbeatTimedOutEl número de funciones Lambda cuyo tiempo de espera se agotódebido a que se agotó el tiempo de espera del latido.

LambdaFunctionsScheduled El número de funciones Lambda programadas.

LambdaFunctionsStarted El número de funciones Lambda iniciadas.

LambdaFunctionsSucceeded El número de funciones Lambda realizadas correctamente.

LambdaFunctionsTimedOut El número de funciones Lambda cuyo tiempo de espera se agotódurante el cierre.

Dimensión de las métricas de funciones Lambda de Step Functions


LambdaFunctionArn El ARN de la función Lambda.

Service MetricsThe AWS/States namespace includes the following metrics for the Step Functions service:

Metric Description

ThrottledEvents The count of requests that have been throttled.

ProvisionedBucketSize The count of available requests per second.

ProvisionedRefillRate The count of requests per second that are allowed into the bucket.

ConsumedCapacity The count of requests per second.

Dimension for Step Functions Service Metrics

Dimension Description

StateTransition Filters data to show State Transitions metrics.

119

AWS Step Functions Guía para desarrolladoresConsulta de métricas de Step Functions

Métricas de APIEl espacio de nombres AWS/States incluye las siguientes métricas para la API de Step Functions:


ThrottledEvents El número de solicitudes que han sido objeto de una limitacióncontrolada.

ProvisionedBucketSize El número de solicitudes disponibles por segundo.

ProvisionedRefillRate El número de solicitudes por segundo que se permiten en el bucket.

ConsumedCapacity El número de solicitudes por segundo.

Dimensión de las métricas de la API de Step Functions


APIName Filtra datos a una API con el nombre de API especificado.

Consulta de métricas de Step Functions1. Abra la Consola de administración de AWS y vaya a CloudWatch.2. Seleccione Metrics y, en la pestaña All Metrics, seleccione States.

Si recientemente realizó alguna ejecución, podrá ver hasta tres tipos de métricas:

• Métricas de ejecución• Métricas de funciones de actividades• Métricas de funciones de Lambda

3. Elija un tipo de métrica para ver una lista de métricas.

120

AWS Step Functions Guía para desarrolladoresConfiguración de alarmas en Step Functions

• Para ordenar las métricas por Metric Name o StateMachineArn, seleccione los encabezados decolumna.

• Para ver los gráficos de una métrica, active la casilla que aparece en la lista junto a la métrica.Puede cambiar los parámetros del gráfico utilizando los controles de intervalo de tiempo situadosencima del gráfico.

Puede elegir intervalos de tiempo personalizados que utilicen valores relativos o absolutos (fechas yhoras específicas). También puede utilizar la lista desplegable para mostrar los valores como líneas,áreas apiladas o números (valores).

• Para ver los detalles de un gráfico, coloque el cursor sobre el código de color de la métrica queaparece debajo del gráfico.

Se mostrarán los detalles de la métrica.

Para obtener más información sobre el uso de las métricas de CloudWatch, consulte Uso de las métricasde CloudWatch en la Guía del usuario de Amazon CloudWatch.

Configuración de alarmas en Step FunctionsPuede utilizar alarmas de CloudWatch para realizar acciones. Por ejemplo, si desea saber cuándo sealcanza el umbral de una alarma, puede configurar una alarma que envíe una notificación a un temaAmazon SNS o un correo electrónico cuando la métrica StateMachinesFailed supere un determinadoumbral.

Para configurar una alarma en una métrica1. Abra la Consola de administración de AWS y vaya a CloudWatch.2. Seleccione Metrics y, en la pestaña All Metrics, seleccione States.

121

https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/working_with_metrics.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/working_with_metrics.html

AWS Step Functions Guía para desarrolladoresConfiguración de alarmas en Step Functions

Si recientemente realizó alguna ejecución, podrá ver hasta tres tipos de métricas:

• Métricas de ejecución• Métricas de funciones de actividades• Métricas de funciones de Lambda

3. Elija un tipo de métrica para ver una lista de métricas.

4. Seleccione una métrica y haga clic en Graphed metrics.5. Seleccione el icono que aparece junto a una de las métricas de la lista.

Se abre el cuadro de diálogo Create Alarm.

122

AWS Step Functions Guía para desarrolladoresRegistro de Step Functions con CloudTrail

6. Especifique los valores de Alarm threshold y Actions, y seleccione Create Alarm.

Para obtener más información sobre la configuración y el uso de las alarmas de CloudWatch, consulteCrear alarmas de Amazon CloudWatch en la Guía del usuario de Amazon CloudWatch.

Registro de Step Functions con CloudTrailAWS Step Functions está integrado con CloudTrail, un servicio que captura llamadas específicas a la APIy envía los archivos de registro a un bucket de Amazon S3 especificado. Con la información recopilada porCloudTrail;, puede identificar la solicitud que se realizó a Step Functions, la dirección IP de origen desde laque se realizó la solicitud, quién realizó la solicitud, cuándo se realizó, etcétera.

Para obtener más información sobre CloudTrail (por ejemplo, cómo configurarlo y habilitarlo), consulte laGuía del usuario de AWS CloudTrail.

Información de Step Functions en CloudTrailSi el registro de CloudTrail está habilitado en su cuenta de AWS, las acciones de API realizadas enacciones específicas de Step Functions se graban en archivos de registro de CloudTrail. Las acciones deStep Functions se escriben junto con otros registros de servicio de AWS. CloudTrail determina cuándodebe crearse un nuevo archivo y escribir en él en función del período de tiempo y del tamaño del archivo.

Se admiten las siguientes acciones:

123

https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/AlarmThatSendsEmail.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html

AWS Step Functions Guía para desarrolladoresDescripción de las entradas dearchivos log de Step Functions

• CreateActivity• CreateStateMachine• DeleteActivity• DeleteStateMachine• StartExecution• StopExecution

Cada entrada de log contiene información sobre quién generó la solicitud. La información de identidad delusuario del log le ayuda a determinar lo siguiente:

• Si la solicitud se realizó con las credenciales del nodo raíz o del usuario de IAM.• Si la solicitud se realizó con credenciales de seguridad temporales de un rol o fue un usuario federado• Si la solicitud la realizó otro servicio de AWS

Para obtener más información, consulte el elemento userIdentity en la AWS CloudTrail User Guide.

Puede almacenar los archivos log en el bucket de S3 durante todo el tiempo que desee, pero tambiénpuede definir reglas de ciclo de vida de Amazon S3 para que los archivos log se archiven o eliminenautomáticamente. De forma predeterminada, los archivos log se cifran con el cifrado de servidor deAmazon S3.

Si desea recibir notificaciones sobre la entrega de archivos log, puede configurar CloudTrail para quepublique las notificaciones de Amazon SNS cuando se envíen nuevos archivos log. Para obtener másinformación, consulte Configuración de notificaciones de Amazon SNS para CloudTrail.

También puede agregar archivos log de Step Functions desde varias regiones de AWS y varias cuentasde AWS en un solo bucket de Amazon S3. Para obtener más información, consulte Recepción de archivosde registro de CloudTrail de varias regiones y Recepción de archivos de registro de CloudTrail de variascuentas.

Descripción de las entradas de archivos log de StepFunctionsLos archivos log de CloudTrail pueden contener una o varias entradas de log. Cada entrada muestravarios eventos con formato JSON. Una entrada de log representa una única solicitud de cualquier origen eincluye información sobre la acción solicitada, la fecha y la hora de la acción, los parámetros de la solicitud,etcétera. Las entradas de log no representan un registro ordenado de la pila de acciones de API públicas,por lo que no aparecen en ningún orden específico.

CreateActivityEn el ejemplo siguiente, se muestra una entrada de registro de CloudTrail que ilustra la acciónCreateActivity:

{ "eventVersion": "1.04", "userIdentity": { "type": "IAMUser", "principalId": "AIDAJYDLDBVBI4EXAMPLE", "arn": "arn:aws:iam::123456789012:user/test-user", "accountId": "123456789012", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "test-user" }, "eventTime": "2016-10-28T01:17:56Z",

124


https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteActivity.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachine.html


https://docs.aws.amazon.com/step-functions/latest/apireference/API_StopExecution.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/configure-sns-notifications-for-cloudtrail.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html


"eventSource": "states.amazonaws.com", "eventName": "CreateActivity", "awsRegion": "us-east-1", "sourceIPAddress": "10.61.88.189", "userAgent": "Coral/Netty", "requestParameters": { "name": "OtherActivityPrefix.2016-10-27-18-16-56.894c791e-2ced-4cf4-8523-376469410c25" }, "responseElements": { "activityArn": "arn:aws:states:us-east-1:123456789012:activity:OtherActivityPrefix.2016-10-27-18-16-56.894c791e-2ced-4cf4-8523-376469410c25", "creationDate": "Oct 28, 2016 1:17:56 AM" }, "requestID": "37c67602-9cac-11e6-aed5-5b57d226e9ef", "eventID": "dc3becef-d06d-49bf-bc93-9b76b5f00774", "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

CreateStateMachineEn el ejemplo siguiente, se muestra una entrada de registro de CloudTrail que ilustra la acciónCreateStateMachine:

{ "eventVersion": "1.04", "userIdentity": { "type": "IAMUser", "principalId": "AIDAJYDLDBVBI4EXAMPLE", "arn": "arn:aws:iam::123456789012:user/test-user", "accountId": "123456789012", "accessKeyId": "AKIAJL5C75K4ZEXAMPLE", "userName": "test-user" }, "eventTime": "2016-10-28T01:18:07Z", "eventSource": "states.amazonaws.com", "eventName": "CreateStateMachine", "awsRegion": "us-east-1", "sourceIPAddress": "10.61.88.189", "userAgent": "Coral/Netty", "requestParameters": { "name": "testUser.2016-10-27-18-17-06.bd144e18-0437-476e-9bb", "roleArn": "arn:aws:iam::123456789012:role/graphene/tests/graphene-execution-role", "definition": "{ \"StartAt\": \"SinglePass\", \"States\": { \"SinglePass\": { \"Type\": \"Pass\", \"End\": true } }}" }, "responseElements": { "stateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:testUser.2016-10-27-18-17-06.bd144e18-0437-476e-9bb", "creationDate": "Oct 28, 2016 1:18:07 AM" }, "requestID": "3da6370c-9cac-11e6-aed5-5b57d226e9ef", "eventID": "84a0441d-fa06-4691-a60a-aab9e46d689c", "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

DeleteActivityEn el ejemplo siguiente, se muestra una entrada de registro de CloudTrail que ilustra la acciónDeleteActivity:

125


{ "eventVersion": "1.04", "userIdentity": { "type": "IAMUser", "principalId": "AIDAJYDLDBVBI4EXAMPLE", "arn": "arn:aws:iam::123456789012:user/test-user", "accountId": "123456789012", "accessKeyId": "AKIAJL5C75K4ZEXAMPLE", "userName": "test-user" }, "eventTime": "2016-10-28T01:18:27Z", "eventSource": "states.amazonaws.com", "eventName": "DeleteActivity", "awsRegion": "us-east-1", "sourceIPAddress": "10.61.88.189", "userAgent": "Coral/Netty", "requestParameters": { "activityArn": "arn:aws:states:us-east-1:123456789012:activity:testUser.2016-10-27-18-11-35.f017c391-9363-481a-be2e-" }, "responseElements": null, "requestID": "490374ea-9cac-11e6-aed5-5b57d226e9ef", "eventID": "e5eb9a3d-13bc-4fa1-9531-232d1914d263", "eventType": "AwsApiCall", "recipientAccountId": "123456789012" }

DeleteStateMachineEn el ejemplo siguiente, se muestra una entrada de registro de CloudTrail que ilustra la acciónDeleteStateMachine:

{ "eventVersion": "1.04", "userIdentity": { "type": "IAMUser", "principalId": "AIDAJABK5MNKNAEXAMPLE", "arn": "arn:aws:iam::123456789012:user/graphene/tests/test-user", "accountId": "123456789012", "accessKeyId": "AKIAJA2ELRVCPEXAMPLE", "userName": "test-user" }, "eventTime": "2016-10-28T01:17:37Z", "eventSource": "states.amazonaws.com", "eventName": "DeleteStateMachine", "awsRegion": "us-east-1", "sourceIPAddress": "10.61.88.189", "userAgent": "Coral/Netty", "errorCode": "AccessDenied", "errorMessage": "User: arn:aws:iam::123456789012:user/graphene/tests/test-user is not authorized to perform: states:DeleteStateMachine on resource: arn:aws:states:us-east-1:123456789012:stateMachine:testUser.2016-10-27-18-16-38.ec6e261f-1323-4555-9fa", "requestParameters": null, "responseElements": null, "requestID": "2cf23f3c-9cac-11e6-aed5-5b57d226e9ef", "eventID": "4a622d5c-e9cf-4051-90f2-4cdb69792cd8", "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

126


StartExecutionEn el ejemplo siguiente, se muestra una entrada de registro de CloudTrail que ilustra la acciónStartExecution:

{ "eventVersion": "1.04", "userIdentity": { "type": "IAMUser", "principalId": "AIDAJYDLDBVBI4EXAMPLE", "arn": "arn:aws:iam::123456789012:user/test-user", "accountId": "123456789012", "accessKeyId": "AKIAJL5C75K4ZEXAMPLE", "userName": "test-user" }, "eventTime": "2016-10-28T01:17:25Z", "eventSource": "states.amazonaws.com", "eventName": "StartExecution", "awsRegion": "us-east-1", "sourceIPAddress": "10.61.88.189", "userAgent": "Coral/Netty", "requestParameters": { "input": "{}", "stateMachineArn": "arn:aws:states:us-east-1:123456789012:stateMachine:testUser.2016-10-27-18-16-26.482bea32-560f-4a36-bd", "name": "testUser.2016-10-27-18-16-26.6e229586-3698-4ce5-8d" }, "responseElements": { "startDate": "Oct 28, 2016 1:17:25 AM", "executionArn": "arn:aws:states:us-east-1:123456789012:execution:testUser.2016-10-27-18-16-26.482bea32-560f-4a36-bd:testUser.2016-10-27-18-16-26.6e229586-3698-4ce5-8d" }, "requestID": "264c6f08-9cac-11e6-aed5-5b57d226e9ef", "eventID": "30a20c8e-a3a1-4b07-9139-cd9cd73b5eb8", "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

StopExecutionEn el ejemplo siguiente, se muestra una entrada de registro de CloudTrail que ilustra la acciónStopExecution:

{ "eventVersion": "1.04", "userIdentity": { "type": "IAMUser", "principalId": "AIDAJYDLDBVBI4EXAMPLE", "arn": "arn:aws:iam::123456789012:user/test-user", "accountId": "123456789012", "accessKeyId": "AKIAJL5C75K4ZEXAMPLE", "userName": "test-user" }, "eventTime": "2016-10-28T01:18:20Z", "eventSource": "states.amazonaws.com", "eventName": "StopExecution", "awsRegion": "us-east-1", "sourceIPAddress": "10.61.88.189", "userAgent": "Coral/Netty", "requestParameters": {

127


"executionArn": "arn:aws:states:us-east-1:123456789012:execution:testUser.2016-10-27-18-17-00.337b3344-83:testUser.2016-10-27-18-17-00.3a0801c5-37" }, "responseElements": { "stopDate": "Oct 28, 2016 1:18:20 AM" }, "requestID": "4567625b-9cac-11e6-aed5-5b57d226e9ef", "eventID": "e658c743-c537-459a-aea7-dafb83c18c53", "eventType": "AwsApiCall", "recipientAccountId": "123456789012"}

128

AWS Step Functions Guía para desarrolladoresAutenticación

SeguridadEsta sección proporciona información sobre la seguridad y la autenticación en Step Functions.

Temas• Autenticación (p. 129)• Creación de roles de IAM para AWS Step Functions (p. 130)• Creación de permisos granulares de IAM para usuarios no administradores (p. 131)

Step Functions utiliza IAM para controlar el acceso a otros servicios y recursos de AWS. Para obtenerinformación general de cómo funciona IAM, consulte Overview of Access Management en la Guía delusuario de IAM. Para obtener información general de credenciales de seguridad, consulte AWS SecurityCredentials en la Referencia general de Amazon Web Services.

AutenticaciónPuede tener acceso a AWS como cualquiera de los siguientes tipos de identidades:

• Usuario de la cuenta raíz de AWS – Cuando crea por primera vez una cuenta de AWS, comienzaúnicamente por una identidad de inicio de sesión único que tiene acceso completo a todos los serviciosy recursos de AWS de la cuenta. Esta identidad recibe el nombre de usuario raíz de la cuenta de AWSy se obtiene acceso a ella iniciando sesión con la dirección de correo electrónico y la contraseña queutilizó para crear la cuenta. Le recomendamos que no utilice el usuario raíz en sus tareas cotidianas,ni siquiera en las tareas administrativas. En lugar de ello, es mejor ceñirse a la práctica recomendadade utilizar el usuario raíz exclusivamente para crear el primer usuario de IAM. A continuación, guardelas credenciales del usuario raíz en un lugar seguro y utilícelas únicamente para algunas tareas deadministración de cuentas y servicios.

• Usuario de IAM: un usuario de IAM es una identidad dentro de su cuenta de AWS que tiene permisospersonalizados específicos (por ejemplo, permisos para crear a state machine in Step Functions). Puedeutilizar un nombre de usuario de IAM y una contraseña para iniciar sesión en páginas web seguras deAWS, como la de Consola de administración de AWS, los foros de discusión de AWS o el AWS SupportCenter.

Además de un nombre de usuario y una contraseña, también puede generar claves de acceso paracada usuario. Puede utilizar estas claves cuando obtenga acceso a los servicios de AWS medianteprogramación, ya sea a través de uno de los varios SDK o mediante la AWS Command Line Interface(CLI). El SDK y las herramientas de CLI usan claves de acceso para firmar criptográficamente susolicitud. Si no utiliza las herramientas de AWS, debe firmar usted mismo la solicitud. Step Functionssupports Signature Version 4, un protocolo para autenticar solicitudes de API de entrada. Para obtenermás información sobre las solicitudes de autenticación, consulte Signature Version 4 Signing Process enla AWS General Reference.

• Rol de IAM: Un rol de IAM es una identidad de IAM que se puede crear en la cuenta y que tiene

permisos específicos. Es similar a un usuario de IAM, pero no está asociado a una determinada persona.Un rol de IAM le permite obtener claves de acceso temporal que se pueden utilizar para tener acceso

129

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html

https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html

https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html

https://console.aws.amazon.com/

https://forums.aws.amazon.com/

https://console.aws.amazon.com/support/home#/

https://console.aws.amazon.com/support/home#/

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html

https://aws.amazon.com/tools/

https://aws.amazon.com/cli/

https://aws.amazon.com/cli/

https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

AWS Step Functions Guía para desarrolladoresCreación de roles de IAM para AWS Step Functions

a los servicios y recursos de AWS. Los roles de IAM con credenciales temporales son útiles en lassiguientes situaciones:

• Acceso de usuario federado: En lugar de crear un usuario de IAM, puede utilizar identidades de

usuario existentes de AWS Directory Service, del directorio de usuarios de su compañía o de unproveedor de identidades web. Esto se conoce como usuarios federados. AWS asigna un rol a unusuario federado cuando se solicita acceso a través de un proveedor de identidad. Para obtener másinformación acerca de los usuarios federados, consulte Usuarios federados y roles en la Guía delusuario de IAM.

• Acceso al servicio de AWS: puede utilizar un rol de IAM en su cuenta para conceder permisos a un

servicio de AWS de forma que pueda tener acceso a los recursos de su cuenta. Por ejemplo, puedecrear un rol que permita a Amazon Redshift tener acceso a un bucket de Amazon S3 en su nombrey, a continuación, cargar los datos de ese bucket en un clúster de Amazon Redshift. Para obtenermás información, consulte Creating a Role to Delegate Permissions to an AWS Service en la Guía delusuario de IAM.

• Aplicaciones que se ejecutan en Amazon EC2: puede utilizar un rol de IAM para administrar

credenciales temporales para las aplicaciones que se ejecutan en una instancia EC2 y realizansolicitudes de API de AWS. Es preferible hacerlo de este modo a almacenar claves de acceso en lainstancia EC2. Para asignar un rol de AWS a una instancia EC2 y ponerla a disposición de todas lasaplicaciones, cree un perfil de instancia asociado a la misma. Un perfil de instancia contiene el rol ypermite a los programas que se ejecutan en la instancia EC2 obtener credenciales temporales. Paraobtener más información, consulte Uso de un rol de IAM para conceder permisos a aplicaciones quese ejecutan en instancias Amazon EC2 en la Guía del usuario de IAM.

Creación de roles de IAM para AWS Step FunctionsAWS Step Functions puede ejecutar código y acceder a los recursos de AWS (como invocar una funciónde AWS Lambda). Para mantener la seguridad, debe conceder a Step Functions acceso a esos recursosmediante un rol de IAM.

Los Tutoriales (p. 7) de esta guía le permiten utilizar los roles de IAM generados de forma automática, queson válidos para la región en la que crea la máquina de estado. Para crear su propio rol de IAM para unamáquina de estado, siga los pasos que se describen en esta sección.

Creación de un rol para Step FunctionsEn este ejemplo, se crea un rol de IAM con permiso para invocar una función de Lambda.

Para crear un rol para Step Functions1. Inicie sesión en la consola de IAM y, a continuación, elija Roles, Create role.2. En la página Select type of trusted entity, en AWS service, seleccione Step Functions en la lista y haga

clic en Next: Permissions.3. En la página Attached permissions policy, elija Next: Review.4. En la página Revisar, escriba StepFunctionsLambdaRole para Nombre de la función y después

elija Crear función.

El rol de IAM se muestra en la lista de roles.

130

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html


AWS Step Functions Guía para desarrolladoresCreación de permisos granulares de

IAM para usuarios no administradores

Para obtener más información sobre los permisos y las políticas de IAM, consulte Administración deaccesos en la Guía del usuario de IAM.

Creación de permisos granulares de IAM parausuarios no administradores

Las políticas administradas predeterminadas en IAM como, por ejemplo, ReadOnly, no cubrencompletamente todos los tipos de permisos de Step Functions. En esta sección se describen los distintostipos de permisos y se facilitan algunas configuraciones de ejemplo.

AWS Step Functions tiene cuatro categorías de permisos. En función del acceso que desee proporcionar aun usuario, puede controlar el acceso mediante la utilización de permisos en estas categorías.

Permisos de nivel de servicio (p. 131)

Aplicar a los componentes del API que no actúan en un recurso específico.Permisos de nivel de máquina de estado (p. 132)

Aplicar a todos los componentes del API que actúan en una máquina de estado específica.Permisos de nivel de ejecución (p. 132)

Aplicar a todos los componentes del API que actúan en una ejecución específica.Permisos de nivel de actividad (p. 132)

Aplicar a todos los componentes del API que actúan en una actividad específica o en una instanciaparticular de una actividad.

Permisos de nivel de servicioEste nivel de permiso se aplica a todas las acciones del API que no actúen en un recurso específico.Incluyen CreateStateMachine, CreateActivity, ListStateMachines y ListActivities.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "states:ListStateMachines", "states:ListActivities", "states:CreateStateMachine", "states:CreateActivity" ], "Resource": [ "arn:aws:states:*:*:*" ] }, { "Effect": "Allow", "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam:::role/my-execution-role" ] }

131

https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_CreateStateMachine.html


https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListStateMachines.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListActivities.html

AWS Step Functions Guía para desarrolladoresPermisos de nivel de máquina de estado

]}

Permisos de nivel de máquina de estadoEste nivel de permiso se aplica a todas las acciones del API que actúen en una máquina de estadoespecífica. Estos API requieren el ARN de la máquina de estado como parte de la solicitud, como porejemplo DeleteStateMachine, DescribeStateMachine, StartExecution y ListExecutions.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "states:DescribeStateMachine", "states:StartExecution", "states:DeleteStateMachine", "states:ListExecutions", "states:UpdateStateMachine" ], "Resource": [ "arn:aws:states:*:*:stateMachine:StateMachinePrefix*" ] } ]}

Permisos de nivel de ejecuciónEste nivel de permiso se aplica a todas las acciones del API que actúen en una ejecución específica.Estas operaciones del API requieren el ARN de la ejecución como parte de la solicitud, por ejemploDescribeExecution, GetExecutionHistory y StopExecution.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "states:DescribeExecution", "states:DescribeStateMachineForExecution", "states:GetExecutionHistory", "states:StopExecution" ], "Resource": [ "arn:aws:states:*:*:execution:*:ExecutionPrefix*" ] } ]}

Permisos de nivel de actividadEste nivel de permiso se aplica a todas las acciones del API que actúan en una actividad específica o enuna instancia particular de la misma. Estas operaciones del API requieren el ARN de la actividad o el tokende la instancia como parte de la solicitud, como por ejemplo DeleteActivity, DescribeActivity,GetActivityTask, SendTaskSuccess, SendTaskFailure y SendTaskHeartbeat.

132

https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteStateMachine.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeStateMachine.html


https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListExecutions.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_GetExecutionHistory.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_StopExecution.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_DeleteActivity.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeActivity.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_GetActivityTask.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_SendTaskSuccess.html

https://docs.aws.amazon.com/step-functions/latest/apireference/API_SendTaskFailure.html


AWS Step Functions Guía para desarrolladoresPermisos de nivel de actividad

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "states:DescribeActivity", "states:DeleteActivity", "states:GetActivityTask", "states:SendTaskSuccess", "states:SendTaskFailure", "states:SendTaskHeartbeat" ], "Resource": [ "arn:aws:states:*:*:activity:ActivityPrefix*" ] } ]}

133


Recursos relacionados de StepFunctions

En la tabla siguiente se enumeran todos los recursos relacionados que podrían resultarle útiles cuandotrabaje con este servicio.

Recurso Descripción

Referencia de la API de AWS Step Functions Descripciones de las acciones, parámetros y tiposde datos de la API, así como una lista de erroresque el servicio devuelve.

AWS Step Functions Command Line Reference Descripciones de los comandos de la CLI deAWS que puede usar para trabajar con AWS StepFunctions.

Información del producto de Step Functions Página web principal con información acerca deStep Functions.

Foros de debate Un foro de la comunidad para desarrolladoresdonde se tratan aspectos técnicos relacionadoscon Step Functions y otros servicios de AWS.

Información sobre AWS Premium Support Página web principal para obtener informaciónsobre AWS Premium Support, un canal desoporte individualizado y de respuesta rápidaque le ayudará a crear y ejecutar aplicaciones enservicios de infraestructura de AWS.

134


https://docs.aws.amazon.com/cli/latest/reference/stepfunctions/

https://aws.amazon.com/step-functions

https://forums.aws.amazon.com/

https://aws.amazon.com/premiumsupport/


Historial de revisiónEn esta sección se indican los cambios principales en la Guía para desarrolladores de AWS StepFunctions.

Cambio Descripción Fecha demodificación

Update Se han añadido ejemplos de JSON al tutorial de AWS CloudFormation.Consulte Creación de una máquina de estado Lambda mediante AWSCloudFormation (p. 13).

23 de juniode 2018

Update Se ha añadido un nuevo tema sobre control de errores de servicio enLambda. Consulte Control de excepciones de servicio en Lambda (p. 111).

20 de juniode 2018

Nuevacaracterística

AWS Step Functions ya está disponible en la región Asia Pacífico (Mumbai).Consulte Regiones admitidas (p. 1) para obtener una lista de las regionesadmitidas.

28 de juniode 2018


AWS Step Functions está ahora disponible en la región AWS GovCloud (US).Consulte Regiones admitidas (p. 1) para obtener una lista de las regionesadmitidas. Para obtener más información sobre el uso de Step Functions enla región AWS GovCloud (US), consulte Puntos de enlace de AWS GovCloud(EE. UU.).

28 de juniode 2018

Update Se ha mejorado la documentación sobre control de errores para estadosParallel. Consulte Control de errores (p. 102).

20 de juniode 2018

Update Se ha mejorado la documentación sobre procesamiento de entrada ysalida en Step Functions. Aprenda a utilizar InputPath, ResultPath yOutputPath para controlar el flujo de JSON a través de sus flujos de trabajo,estados y tareas. Consulte:

• Procesamiento de entrada y salida en Step Functions (p. 66)• Descripción de ResultPath (p. 67)• Filtrado con InputPath y OutputPath (p. 72)

7 de juniode 2018

Update Ejemplos de código mejorado para estados Parallel. ConsulteParallel (p. 100).

4 de juniode 2018


Ahora puede monitorear las métricas API y Servicio en CloudWatch. ConsulteMonitorización de Step Functions con CloudWatch (p. 116).

25 demayo de2018

Update StartExecution, StopExecution, y StateTransition ahora hanaumentado los límites controlados en las siguientes regiones:

• US East (N. Virginia)• EE.UU. Oeste (Oregón)• UE (Irlanda)

Para obtener más información, consulte Límites (p. 112).

16 demayo de2018

135

https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/using-govcloud-endpoints.html

https://docs.aws.amazon.com/govcloud-us/latest/UserGuide/using-govcloud-endpoints.html




AWS Step Functions ahora está disponible en las regiones EE.UU.Oeste (Norte de California) y Asia Pacífico (Seúl). Consulte Regionesadmitidas (p. 1) para obtener una lista de las regiones admitidas.

5 de mayode 2018

Update Actualización de los procedimientos e imágenes para que se correspondancon los cambios de la interfaz.

25 de abrilde 2018

Update Se agregó un nuevo tutorial que muestra cómo iniciar una nuevaejecución para continuar el trabajo. Consulte Continuar como una nuevaejecución (p. 46). En este tutorial se describe un patrón de diseño que puedeayudarle a evitar algunas limitaciones de servicio. Consulte, Evitar alcanzar ellímite de historial (p. 111).

19 de abrilde 2018

Update Se ha mejorado la introducción a la documentación de estados añadiendoinformación conceptual sobre máquinas de estado. Consulte Estados (p. 55).

9 de marzode 2018

Update Además de HTML, PDF y Kindle, la Guía para desarrolladores de AWS StepFunctions está disponible en GitHub. Para dejar comentarios, haga clic en elicono GitHub en la esquina superior derecha.

2 de marzode 2018

Update Se ha añadido un tema que describe otros recursos relacionados con StepFunctions.

Consulte Recursos relacionados de Step Functions (p. 134).

20 defebrero de2018


• Al crear una nueva máquina de estado, debe confirmar que AWS StepFunctions creará un rol de IAM que permite el acceso a sus funciones deLambda.

• Se han actualizado los siguientes tutoriales para reflejar pequeños cambiosen el flujo de trabajo de creación de máquinas de estado:• Introducción (p. 3)• Creación de una máquina de estado Lambda (p. 9)• Creación de una máquina de estado de actividades (p. 21)• Administración de las condiciones de error con una máquina de

estado (p. 26)• Iteración de un bucle mediante Lambda (p. 39)

19 defebrero de2018

Update Se ha añadido un tema que describe un ejemplo de proceso de trabajo deactividad escrito en Ruby. Esta implementación se puede utilizar para crearun proceso de trabajo de actividad de Ruby directamente, o como un patrónde diseño para la creación de un proceso de trabajo de actividad en otrolenguaje.

Consulte Ejemplo de proceso de trabajo de actividad en Ruby (p. 57).

6 defebrero de2018

136



Update Se ha añadido un nuevo tutorial que describe un patrón de diseño que utilizauna función de Lambda para iterar un contador.

Consulte Creación de una máquina de estado Lambda (p. 9).

31 deenero de2018

Update Se ha actualizado el contenido relacionado con los permisos de IAMpara incluir las API DescribeStateMachineForExecution yUpdateStateMachine.

Consulte Creación de permisos granulares de IAM para usuarios noadministradores (p. 131).

26 deenero de2018

Update Se han añadido la nuevas regiones disponibles: Canadá (Central) y AsiaPacífico (Singapur).

Consulte Regiones admitidas (p. 1).

25 deenero de2018

Update Se han actualizado los tutoriales y procedimientos para reflejar que IAMpermite seleccionar Step Functions como rol.

24 deenero de2018

Update Se ha añadido el tema nuevo Prácticas recomendadas que sugiere que no sepasen cargas de gran tamaño entre los estados.

Consulte Utilice ARN en lugar de pasar cargas de gran tamaño (p. 110).

23 deenero de2018


Se han corregido los siguientes procedimientos para adaptarlos a la interfazactualizada de creación de una máquina de estado:

• Introducción (p. 3)• Creación de una máquina de estado Lambda (p. 9)• Creación de una máquina de estado de actividades (p. 21)• Administración de las condiciones de error con una máquina de

estado (p. 26)

17 deenero de2018


Es posible utilizar proyectos de muestra para aprovisionar rápidamentemáquinas de estado y todos los recursos de AWS relacionados. ConsulteProyectos de muestra (p. 82),

Los proyectos de muestra disponibles son los siguientes:

• Job Status Poller (p. 82)• Task Timer (p. 85)

Note

Estos proyectos de muestra y la documentación relacionadasustituyen a los tutoriales en los que se describe la implementaciónde la misma funcionalidad.

11 deenero de2018

Update Se ha añadido una sección Prácticas recomendadas que incluye informaciónsobre cómo evitar que las ejecuciones se bloqueen. Consulte Prácticasrecomendadas para Step Functions (p. 110).

5 de enerode 2018

137



Update Se ha añadido una nota sobre cómo pueden afectar los reintentos al precio:

Note

Los reintentos se tratan como transiciones de estado. Para obtenermás información sobre cómo afectan las transiciones de estado a lafacturación, consulte Precios de Step Functions.

8 dediciembrede 2017

Update Se ha añadido información relacionada con los nombres de recursos:

Note

Step Functions le permite crear una máquina de estado, unaejecución y nombres de actividad que contengan caracteresno ASCII. Estos nombres no ASCII no funcionan con AmazonCloudWatch. Para asegurarse de que puede realizar un seguimientode las métricas de CloudWatch, elija un nombre que solo usecaracteres ASCII.


Update Se ha mejorado la información general sobre seguridad y se haañadido un tema sobre permisos granulares de IAM. ConsulteSeguridad (p. 129) y Creación de permisos granulares de IAM para usuariosno administradores (p. 131).

27 denoviembrede 2017


Puede actualizar una máquina de estado existente. Consulte Update a StateMachine (p. 5).

15 denoviembrede 2017

Update Se ha añadido una nota para aclarar errores Lambda.Unknown y se havinculado a la documentación de Lambda en las secciones siguientes:

• Nombres de error (p. 74)• Para crear la máquina de estado (p. 28)

Note

Los errores no administrados de Lambda se indican comoLambda.Unknown en la salida de errores. Incluyen errores defalta de memoria, tiempos de espera de funciones agotados yalcanzar el límite de invocaciones de Lambda simultáneas. Puedebuscar correspondencias con Lambda.Unknown, States.ALL oStates.TaskFailed para administrar estos errores. Para obtenermás información sobre los errores Handled y Unhandled deLambda, consulte FunctionError en la AWS Lambda DeveloperGuide.

17 deoctubre de2017

Update Se han corregido y aclarado las instrucciones de IAM y se han actualizadotodas las capturas de pantalla en todos los tutoriales (p. 7).

11 deoctubre de2017

138






Update • Se han añadido nuevas capturas de pantalla para que los resultados deejecución de máquina de estado reflejen cambios en la consola de StepFunctions. Se han reescrito las instrucciones de Lambda en los siguientestutoriales para reflejar los cambios en la consola de Lambda:• Creación de una máquina de estado Lambda (p. 9)• Creación de un sondeador de estados de trabajo• Creación de un temporizador de tareas• Administración de las condiciones de error con una máquina de

estado (p. 26)• Se ha corregido y aclarado la información sobre la creación de máquinas de

estado en las secciones siguientes:• Introducción (p. 3)• Creación de una máquina de estado de actividades (p. 21)

6 deoctubre de2017

Update Se han reescrito las instrucciones de IAM en las siguientes secciones parareflejar los cambios en la consola de IAM:

• Creación de roles de IAM para AWS Step Functions (p. 130)• Creación de una máquina de estado Lambda (p. 9)• Creación de un sondeador de estados de trabajo• Creación de un temporizador de tareas• Administración de las condiciones de error con una máquina de

estado (p. 26)• Creación de una API de Step Functions mediante API Gateway (p. 34)

5 deoctubre de2017

Update Se ha reescrito la sección Datos de la máquina de estado (p. 64). 28 deseptiembrede 2017


Los límites relacionados con las limitaciones de las acciones de API (p. 114)se han aumentado para todas las regiones donde Step Functions estádisponible.

18 deseptiembrede 2017

Update • Se ha corregido y clarificado la información sobre cómo iniciar nuevasejecuciones en todos los tutoriales.

• Se ha corregido y clarificado la información de la sección Límitesrelacionados con las cuentas (p. 113).

14 deseptiembrede 2017

Update Se ha corregido y clarificado la información de la sección Plantillas (p. 81). 1 deseptiembrede 2017

Update Se han reescrito los siguientes tutoriales para reflejar los cambios en laconsola de Lambda:

• Creación de una máquina de estado Lambda (p. 9)• Administración de las condiciones de error con una máquina de

estado (p. 26)• Creación de un sondeador de estados de trabajo

28 deagosto de2017

139




Step Functions está disponible en UE (Londres). 23 deagosto de2017


Los flujos de trabajo visuales de las máquinas de estado le permiten ampliar,reducir y centrar el gráfico.

21 deagosto de2017

Important

Una ejecución no puede utilizar el nombre de otra ejecución durante90 días.

Cuando realiza varias llamadas StartExecution con el mismo nombre, nose ejecuta la nueva ejecución y se aplican las reglas siguientes.

Estado de ejecuciónTipo de entrada

Open Closed

Identical Success ExecutionAlreadyExists

Different ExecutionAlreadyExistsExecutionAlreadyExists


Para obtener más información, consulte el parámetro de solicitud name de laacción de la API StartExecution en la Referencia de la API de AWS StepFunctions.

18 deagosto de2017

Update Se ha añadido información acerca de un método alternativo para pasar elARN de la máquina de estado en el tutorial Creación de una API de StepFunctions mediante API Gateway (p. 34).

17 deagosto de2017

Update Se ha añadido el nuevo tutorial Creación de un sondeador de estados detrabajo.

10 deagosto de2017


• Step Functions emite la métrica ExecutionThrottled de CloudWatch.Para obtener más información, consulte Métricas de las máquinas deestado (p. 117).

• Se ha añadido la sección Límites relacionados con las limitaciones deestados (p. 115).

3 deagosto de2017

Update Se han actualizado las instrucciones de la sección Para crear un rol para APIGateway (p. 35).

18 de juliode 2017

Update Se ha corregido y clarificado la información de la sección Choice (p. 95). 23 de juniode 2017

140

https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html#API_StartExecution_RequestParameters



Update Se ha añadido información sobre el uso de los recursos en otras cuentas deAWS en los siguientes tutoriales:

• Creación de una máquina de estado Lambda (p. 9)• Creación de una máquina de estado Lambda mediante AWS

CloudFormation (p. 13)• Creación de una máquina de estado de actividades (p. 21)• Administración de las condiciones de error con una máquina de

estado (p. 26)

22 de juniode 2017

Update Se ha corregido y clarificado la información de las siguientes secciones:

• Introducción (p. 3)• Administración de las condiciones de error con una máquina de

estado (p. 26)• Estados (p. 90)• Control de errores (p. 74)

21 de juniode 2017

Update Se han reescrito todos los tutoriales para adaptarlos a la actualización de laconsola de Step Functions.

12 de juniode 2017


Step Functions está disponible en Asia Pacífico (Sídney). 8 de juniode 2017

Update Se ha reestructurado la sección Lenguaje de estados de Amazon (p. 88). 7 de juniode 2017

Update Se ha corregido y clarificado la información de la sección Creación de unamáquina de estado de actividades (p. 21).

6 de juniode 2017

Update Se han corregido los ejemplos de código de la sección Ejemplos sobre el usode Retry y Catch (p. 78).

5 de juniode 2017

Update Se ha reestructurado esta guía mediante los estándares de documentación deAWS.

31 demayo de2017

Update Se ha corregido y clarificado la información de la sección Parallel (p. 100). 25 demayo de2017

Update Se han combinado las secciones Rutas y Filtros en la sección Procesamientode entrada y salida (p. 103).

24 demayo de2017

Update Se ha corregido y clarificado la información de la sección Plantillas (p. 81). 16 demayo de2017

Update Se ha corregido y clarificado la información de la sección Monitorización deStep Functions con CloudWatch (p. 116).

15 demayo de2017

141



Update Se ha actualizado el código del proceso de trabajoGreeterActivities.java en el tutorial Creación de una máquina deestado de actividades (p. 21).

9 de mayode 2017

Update Se ha añadido un vídeo introductorio en la sección ¿Qué es AWS StepFunctions? (p. 1).

19 de abrilde 2017

Update Se ha corregido y clarificado la información de los siguientes tutoriales:


estado (p. 26)

19 de abrilde 2017

Update Se ha añadido información sobre las plantillas de Lambda en los tutorialesCreación de una máquina de estado Lambda (p. 9) y Administración de lascondiciones de error con una máquina de estado (p. 26).

6 de abrilde 2017

Update Se ha cambiado el límite "Maximum input or result data size" a "Maximuminput or result data size for a task, state, or execution" (32 768 caracteres).Para obtener más información, consulte Límites relacionados con lasejecuciones de tareas (p. 113).

31 demarzo de2017


• Step Functions permite la ejecución de máquinas de estado configurandoStep Functions como un destino de Amazon CloudWatch Events.

• Se ha añadido el tutorial Iniciar la ejecución de una máquina de estado conEventos de CloudWatch (p. 32).

21 demarzo de2017


• Step Functions permite el tratamiento de errores de funciones Lambdacomo método de tratamiento de errores preferido.

• Se ha actualizado el tutorial Administración de las condiciones de error conuna máquina de estado (p. 26) y la sección Control de errores (p. 74).

16 demarzo de2017


Step Functions está disponible en UE (Fráncfort). 7 de marzode 2017

Update Se han reorganizado los temas de la tabla de contenido y se han actualizadolos siguientes tutoriales:


estado (p. 26)

23 defebrero de2017


• La página State Machines de la consola de Step Functions incluye losbotones Copy to New y Delete.

• Se han actualizado las capturas de pantalla para adaptarlas a los cambiosde la consola.

23 defebrero de2017

142




• Step Functions permite la creación de API mediante API Gateway.• Se ha añadido el tutorial Creación de una API de Step Functions mediante

API Gateway (p. 34).

14 defebrero de2017


• Step Functions admite la integración con AWS CloudFormation.• Se ha añadido el tutorial Creación de una máquina de estado Lambda

mediante AWS CloudFormation (p. 13).

10 defebrero de2017

Update Se ha clarificado el comportamiento actual de los campos ResultPath yOutputPath en relación con los estados Parallel.

6 defebrero de2017

Update • Se han clarificado las restricciones de nomenclatura de máquinas de estadoen los tutoriales.

• Se han corregido algunos ejemplos de código.

5 de enerode 2017

Update Se han actualizado los ejemplos de las funciones Lambda de acuerdo con elúltimo modelo de programación.



La versión inicial de Step Functions. 1 dediciembrede 2016

143


AWS GlossaryFor the latest AWS terminology, see the AWS Glossary in the AWS General Reference.

144

https://docs.aws.amazon.com/general/latest/gr/glos-chap.html

AWS Step Functions · IAM role ARN (Voy a proporcionar el ARN de una función de IAM existente) y...

Documents

Transcript of AWS Step Functions · IAM role ARN (Voy a proporcionar el ARN de una función de IAM existente) y...