Desarrollo de flujos de trabajo con Step Functions

Recomendamos empezar a crear flujos de trabajo en la consola Step Functions y en el editor visual de Workflow Studio. Puede empezar desde un lienzo en blanco o elegir plantillas de inicio para situaciones habituales.

La creación de sus flujos de trabajo requiere las siguientes tareas:

• Definir el flujo de trabajo

• Ejecutar y depurar tu flujo de trabajo

• Implementación de su flujo de trabajo

Usted define una máquina de estados en Amazon States Language. Puedes crear manualmente tus definiciones de idioma de Amazon States, pero Workflow Studio aparecerá en los tutoriales. Con Workflow Studio, puede definir la definición de su máquina, visualizar y editar los pasos, ejecutar y depurar su flujo de trabajo y ver los resultados desde la consola de Step Functions.

También puede utilizar muchas funciones de Step Functions del AWS Command Line Interface (AWS CLI). Por ejemplo, puede crear una máquina de estados y enumerar las máquinas de estado existentes. Puede utilizar los comandos de Step Functions en AWS CLI para iniciar y gestionar las ejecuciones, sondear las actividades, registrar los latidos de las tareas y mucho más. Para obtener una lista completa de los comandos de Step Functions, descripciones de los argumentos disponibles y ejemplos que muestran su uso, consulte la AWS CLI Referencia de comandos. AWS CLI Referencia de comandos

AWS CLI los comandos siguen de cerca el idioma de los estados de Amazon, por lo que puedes usar el AWS CLI para obtener información sobre las API acciones de Step Functions. También puedes usar tus API conocimientos actuales para crear prototipos de código o realizar acciones de Step Functions desde la línea de comandos.

Validar las definiciones de las máquinas de estado

Puede usarlo API para validar las máquinas de estado y detectar posibles problemas antes de crear su flujo de trabajo.

Para obtener más información sobre la validación de los flujos de trabajo, consulte ValidateStateMachineDefinitionla API Referencia de Step Functions.

Para empezar con una configuración mínima, puede seguir el tutorial Creación de una máquina de estados Lambda, que muestra cómo definir un flujo de trabajo con un solo paso que llama a una función Lambda, luego ejecutar el flujo de trabajo y ver los resultados.

Definir el flujo de trabajo

El primer paso para desarrollar tu flujo de trabajo es definir los pasos en Amazon States Language. Según sus preferencias y su herramienta, puede definir sus máquinas de estados de Step Functions en JSONYAML, o como una definición en cadena de Amazon States Language (ASL).

En la siguiente tabla, se muestra el soporte de formatos de definición ASL basados en cada herramienta.

AWS Herramienta	Formatos compatibles
Consola de Step Functions	JSON
HTTPSServicio API	Stringificado ASL
AWS CLI	Stringificado ASL
Step Functions Local	Stringificado ASL
AWS Toolkit for Visual Studio Code	JSON, YAML
AWS SAM	JSON, YAML
AWS CloudFormation	JSON,, Stringificado YAML ASL

YAMLlos comentarios de una sola línea en la definición de una plantilla de la máquina de estados no se transferirán a la definición del recurso creado. Si necesita conservar un comentario, debe usar la Comment propiedad incluida en la definición de la máquina de estados. Para obtener más información, consulte Estructura de las máquinas de estado.

¿Con AWS CloudFormation y AWS SAM, puede cargar sus definiciones de máquina de estado en Amazon S3 (JSONo YAML formatear) y proporcionar la ubicación de Amazon S3 de la definición en la plantilla. Para obtener más información, consulte la páginaAWS:StepFunctions:: StateMachine S3Location.

El siguiente ejemplo AWS CloudFormation las plantillas muestran cómo puede proporcionar la misma definición de máquina de estados utilizando diferentes formatos de entrada.

JSON with Definition

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "AWS Step Functions sample template.",
  "Resources": {
    "MyStateMachine": {
      "Type": "AWS::StepFunctions::StateMachine",
      "Properties": {
        "RoleArn": {
          "Fn::GetAtt": [ "StateMachineRole", "Arn" ]
        },
        "TracingConfiguration": {
          "Enabled": true
        },
        "Definition": {
          "StartAt": "HelloWorld",
          "States": {
            "HelloWorld": {
              "Type": "Pass",
              "End": true
            }
          }
        }
      }
    },
    "StateMachineRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",
          "Statement": [
            {
              "Action": [
                "sts:AssumeRole"
              ],
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "states.amazonaws.com"
                ]
              }
            }
          ]
        },
        "ManagedPolicyArns": [],
        "Policies": [
          {
            "PolicyName": "StateMachineRolePolicy",
            "PolicyDocument": {
              "Statement": [
                {
                  "Action": [
                    "lambda:InvokeFunction"
                  ],
                  "Resource": "*",
                  "Effect": "Allow"
                }
              ]
            }
          }
        ]
      }
    }
  },
  "Outputs": {
    "StateMachineArn": {
      "Value": {
        "Ref": "MyStateMachine"
      }
    }
  }
}

JSON with DefinitionString

{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "AWS Step Functions sample template.",
  "Resources": {
    "MyStateMachine": {
      "Type": "AWS::StepFunctions::StateMachine",
      "Properties": {
        "RoleArn": {
          "Fn::GetAtt": [ "StateMachineRole", "Arn" ]
        },
        "TracingConfiguration": {
          "Enabled": true
        },
        "DefinitionString": "{\n  \"StartAt\": \"HelloWorld\",\n  \"States\": {\n    \"HelloWorld\": {\n      \"Type\": \"Pass\",\n      \"End\": true\n    }\n  }\n}"
      }
    },
    "StateMachineRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Version": "2012-10-17",
          "Statement": [
            {
              "Action": [
                "sts:AssumeRole"
              ],
              "Effect": "Allow",
              "Principal": {
                "Service": [
                  "states.amazonaws.com"
                ]
              }
            }
          ]
        },
        "ManagedPolicyArns": [],
        "Policies": [
          {
            "PolicyName": "StateMachineRolePolicy",
            "PolicyDocument": {
              "Statement": [
                {
                  "Action": [
                    "lambda:InvokeFunction"
                  ],
                  "Resource": "*",
                  "Effect": "Allow"
                }
              ]
            }
          }
        ]
      }
    }
  },
  "Outputs": {
    "StateMachineArn": {
      "Value": {
        "Ref": "MyStateMachine"
      }
    }
  }
}

YAML with Definition

AWSTemplateFormatVersion: 2010-09-09
Description: AWS Step Functions sample template.
Resources:
  MyStateMachine:
    Type: 'AWS::StepFunctions::StateMachine'
    Properties:
      RoleArn: !GetAtt
        - StateMachineRole
        - Arn
      TracingConfiguration:
        Enabled: true
      Definition:
        # This is a YAML comment. This will not be preserved in the state machine resource's definition.
        Comment: This is an ASL comment. This will be preserved in the state machine resource's definition.
        StartAt: HelloWorld
        States:
          HelloWorld:
            Type: Pass
            End: true
  StateMachineRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Action:
              - 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service:
                - states.amazonaws.com
      ManagedPolicyArns: []
      Policies:
        - PolicyName: StateMachineRolePolicy
          PolicyDocument:
            Statement:
              - Action:
                  - 'lambda:InvokeFunction'
                Resource: "*"
                Effect: Allow

Outputs:
  StateMachineArn:
    Value:
      Ref: MyStateMachine

YAML with DefinitionString

AWSTemplateFormatVersion: 2010-09-09
Description: AWS Step Functions sample template.
Resources:
  MyStateMachine:
    Type: 'AWS::StepFunctions::StateMachine'
    Properties:
      RoleArn: !GetAtt
        - StateMachineRole
        - Arn
      TracingConfiguration:
        Enabled: true
      DefinitionString: |
        {
            "StartAt": "HelloWorld",
            "States": {
                "HelloWorld": {
                    "Type": "Pass",
                    "End": true
                }
            }
        }
  StateMachineRole:
    Type: 'AWS::IAM::Role'
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Action:
              - 'sts:AssumeRole'
            Effect: Allow
            Principal:
              Service:
                - states.amazonaws.com
      ManagedPolicyArns: []
      Policies:
        - PolicyName: StateMachineRolePolicy
          PolicyDocument:
            Statement:
              - Action:
                  - 'lambda:InvokeFunction'
                Resource: "*"
                Effect: Allow

Outputs:
  StateMachineArn:
    Value:
      Ref: MyStateMachinele

Desarrolle flujos de trabajo con AWS SDKs

Step Functions es compatible con AWS SDKspara Java,. NET, RubyPHP, Python (Boto 3) JavaScript, Go y C++. Estas SDKs proporcionan una forma cómoda de utilizar las HTTPS API acciones de Step Functions en varios lenguajes de programación. Puede desarrollar máquinas de estados, actividades o iniciadores de máquinas de estados utilizando las API acciones expuestas en estas SDK bibliotecas. También puede obtener acceso a las operaciones de visibilidad a través de estas bibliotecas para desarrollar sus propias herramientas de monitorización e informes de Step Functions. Consulte la documentación de referencia para ver la información actual AWS SDKsy herramientas para Amazon Web Services.

Desarrolle flujos de trabajo a través de HTTPS solicitudes

Step Functions proporciona operaciones de servicio a las que se puede acceder mediante HTTPS solicitudes. Puede utilizar estas operaciones para comunicarse directamente con Step Functions desde sus propias bibliotecas. Puede desarrollar máquinas de estado, trabajadores o iniciadores de máquinas de estado mediante las API acciones de servicio. También puede acceder a las operaciones de visibilidad mediante las API acciones necesarias para desarrollar sus propias herramientas de supervisión e informes. Para obtener más información, consulte la AWS Step Functions APIReferencia.

Desarrolle flujos de trabajo con AWS Step Functions Ciencia de datos SDK

Los científicos de datos pueden crear flujos de trabajo que procesen y publiquen modelos de aprendizaje automático mediante SageMaker Step Functions. También puede crear flujos de trabajo de aprendizaje automático de varios pasos en Python que organicen AWS infraestructura a escala. La AWS Step Functions Data Science SDK proporciona un Python API que puede crear e invocar flujos de trabajo de Step Functions. Puede administrar y ejecutar estos flujos de trabajo directamente en Python, así como en cuadernos de Jupyter. Para obtener más información, consulte: AWSProyecto de ciencia de datos de Step Functions en Github, SDKdocumentación sobre ciencia de datos y ejemplos de cuadernos de Jupyter y SageMaker ejemplos sobre. GitHub

Ejecutar y depurar tus flujos de trabajo

Puede iniciar los flujos de trabajo de varias formas, por ejemplo, desde la consola, una API llamada (por ejemplo, desde una función de Lambda), desde Amazon EventBridge y EventBridge Scheduler, desde otra máquina de estados de Step Functions. Los flujos de trabajo en ejecución pueden conectarse a servicios de terceros, utilice AWS SDKsy manipule los datos mientras se ejecuta. Existen varias herramientas para ejecutar y depurar los pasos de ejecución y los datos que fluyen por la máquina de estados. Las siguientes secciones proporcionan recursos adicionales para ejecutar y depurar sus flujos de trabajo.

Para obtener más información sobre las formas de iniciar las ejecuciones de máquinas de estado, consulteInicio de ejecuciones de máquinas de estado en Step Functions.

Elija un punto final para ejecutar sus flujos de trabajo

Para reducir la latencia y almacenar los datos en una ubicación que cumpla con sus requisitos, Step Functions proporciona puntos finales en diferentes AWS Regiones. Cada punto de conexión de Step Functions es totalmente independiente. Una máquina de estado o una actividad solo existe en la región en la que se creó. Las máquinas y actividades de estado que cree en una región no comparten ningún dato o atributo con las creadas en otra región. Por ejemplo, puede registrar una máquina de estado con el nombre STATES-Flows-1 en dos regiones diferentes. La máquina de estado STATES-Flows-1 de una región no compartirá datos ni atributos con la máquina de estado STATES-Flow-1 de la otra región. Para obtener una lista de los puntos finales de Step Functions, consulte AWS Step Functions Regiones y puntos finales del Referencia general de AWS.

Controle el flujo de datos en sus flujos de trabajo

Puede usar el simulador de flujo de datos de la consola Step Functions para ver cómo fluye la información de un estado a otro y para comprender cómo filtrar y manipular los datos. Con el simulador de flujo de datos, puede simular cada uno de los campos que Step Functions utiliza para procesar datos InputPathParameters, comoResultSelector,OutputPath, yResultPath. Para obtener más información, consulte Uso del simulador de flujo de datos para probar el flujo de datos en Step Functions.

Versión de desarrollo local de Step Functions

Para fines de pruebas y desarrollo, tiene la opción de instalar y ejecutar Step Functions en su máquina local. La versión local de Step Functions puede invocar AWS Lambda funciones, tanto en AWS y cuando se ejecuta localmente. También puede coordinar otros compatibles AWS servicios. Para obtener más información, consulte Probar máquinas de estado localmente en Step Functions.

Desarrollo local y remoto con VS Code

También puede usar VS Code para interactuar con máquinas de estado remotas y desarrollar máquinas de estado a nivel local. Puede crear o actualizar máquinas de estado, mostrar las máquinas de estado existentes y ejecutar o descargar una máquina de estado. VS Code también le permite crear nuevas máquinas de estado a partir de plantillas, ver una visualización de su máquina de estado y proporciona fragmentos de código, finalización de código y validación de código. Para obtener más información, consulte la AWS Toolkit for Visual Studio Code Guía del usuario

Implementación de sus flujos de trabajo

Una vez que haya definido y depurado sus flujos de trabajo, es probable que desee implementarlos mediante marcos de infraestructura como código. Puede optar por implementar sus máquinas de estado mediante una variedad de opciones de IaC, que incluyen: AWS Serverless Application Model, AWS CloudFormation, AWS CDK y Terraform.

AWS Serverless Application Model

Puede usar… AWS Serverless Application Model con Step Functions para crear flujos de trabajo e implementar la infraestructura que necesita, incluidas las funciones APIs y eventos de Lambda, para crear aplicaciones sin servidor. También puede utilizar el AWS SAM CLIjunto con el AWS Toolkit for Visual Studio Code como parte de una experiencia integrada.

Para obtener más información, consulte Uso AWS SAM para crear flujos de trabajo de Step Functions.

AWS CloudFormation

Puede utilizar las definiciones de su máquina de estados directamente en AWS CloudFormation plantillas.

Para obtener más información, consulte Utilización AWS CloudFormation para crear un flujo de trabajo en Step Functions.

AWS CDK

Puede crear máquinas de estado estándar y exprés con AWS CDK.

Para crear un flujo de trabajo estándar, consulteSe utiliza CDK para crear un flujo de trabajo estándar.

Para crear un flujo de trabajo exprés, consulteSe utiliza CDK para crear un flujo de trabajo exprés.

Terraform

Terraform by HashiCorp es un marco para crear aplicaciones utilizando la infraestructura como código (IaC). Con Terraform, puede crear máquinas de estado y utilizar características, como obtener una vista previa de las implementaciones de infraestructura y crear plantillas reutilizables. Las plantillas de Terraform le ayudan a mantener y reutilizar el código al dividirlo en partes más pequeñas.

Para obtener más información, consulte Uso de Terraform para implementar máquinas de estado en Step Functions.