Utilización CloudFormation para crear un flujo de trabajo en Step Functions - AWS Step Functions
Paso 1: Configure la CloudFormation plantillaPaso 2: Utilice la CloudFormation plantilla para crear una máquina de estado LambdaPaso 3: Iniciar la ejecución de una máquina de estado

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Utilización CloudFormation para crear un flujo de trabajo en Step Functions

En este tutorial, crearás una AWS Lambda función usando AWS CloudFormation. Utilizará la CloudFormation consola y una plantilla YAML para crear una pila (las funciones de IAM, la función Lambda y la máquina de estados). A continuación, usará la consola de Step Functions para iniciar la ejecución de la máquina de estado.

Para obtener más información, consulte Trabajar con CloudFormation plantillas y el AWS::StepFunctions::StateMachine recurso en la Guía del AWS CloudFormation usuario.

Paso 1: Configure la CloudFormation plantilla

Antes de utilizar las plantillas de ejemplo, debe comprender cómo declarar las distintas partes de una plantilla de CloudFormation .

Para crear un rol de IAM para Lambda

Defina la política de confianza asociada al rol de IAM para la función de Lambda. En los siguientes ejemplos se define una política de confianza mediante YAML o JSON.

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"
                          }
                      ]
                  }
              }

Cómo crear una función de Lambda

Defina las siguientes propiedades de la función de Lambda que imprimirá el mensaje Hello World.

importante

Asegúrese de que la función Lambda esté en la misma AWS cuenta y en la misma Región de AWS máquina de estados.

YAML
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: "nodejs12.x"
      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": "nodejs12.x",
                  "Timeout": "25"
              }
          },

Para crear un rol de IAM para la ejecución de la máquina de estado

Defina 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",
              "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 Lambda

Defina la máquina de estado Lambda.

YAML
MyStateMachine:
    Type: "AWS::StepFunctions::StateMachine"
    Properties:
      DefinitionString:
        !Sub
          - |-
            {
              "Comment": "A Hello World 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
        "MyStateMachine": {
              "Type": "AWS::StepFunctions::StateMachine",
              "Properties": {
                  "DefinitionString": {
                      "Fn::Sub": [
                          "{\n  \"Comment\": \"A Hello World 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: Utilice la CloudFormation plantilla para crear una máquina de estado Lambda

Una vez que comprenda los componentes de la CloudFormation plantilla, podrá unirlos y utilizarla para crear una CloudFormation pila.

Para crear la máquina de estado Lambda

  1. 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"
  
    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: "nodejs12.x"
        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 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",
              "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": "nodejs12.x",
                  "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": "*"
                                  }
                              ]
                          }
                      }
                  ]
              }
          },
          "MyStateMachine": {
              "Type": "AWS::StepFunctions::StateMachine",
              "Properties": {
                  "DefinitionString": {
                      "Fn::Sub": [
                          "{\n  \"Comment\": \"A Hello World 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. Abra la consola de CloudFormation y elija Crear pila.

  3. En la página Seleccionar plantilla, elija Cargar una plantilla en Amazon S3. Elija su archivo MyStateMachine y después elija Siguiente.

  4. En la página Especificar detalles, en Nombre de la pila, escriba MyStateMachine y, a continuación, elija Siguiente.

  5. En la página Opciones, seleccione Siguiente.

  6. En la página Revisar, seleccione Confirmo que CloudFormation puede crear recursos de IAM. y, a continuación, elija Crear.

    CloudFormation comienza a crear la MyStateMachine pila y muestra el estado CREATE_IN_PROGRESS. Cuando el proceso se haya completado, CloudFormation mostrará el estado CREATE_COMPLETE.

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

Paso 3: Iniciar la ejecución de una máquina de estado

Después de crear la máquina de estados Lambda, puede iniciar una ejecución.

Para iniciar la ejecución de la máquina de estado

  1. Abra la consola Step Functions y elija el nombre de la máquina de estados que creó con ella CloudFormation.

  2. En la MyStateMachine-ABCDEFGHIJ1Kpágina, elija Nueva ejecución.

    Aparece la página Nueva ejecución.

  3. (Opcional) Ingrese un nombre de ejecución personalizado para anular el valor predeterminado generado.

    Nombres y registros con caracteres no ASCII

    Step Functions acepta nombres para máquinas de estado, ejecuciones, actividades y etiquetas que contengan caracteres no ASCII. Dado que estos caracteres impedirán que Amazon registre CloudWatch datos, te recomendamos que utilices únicamente caracteres ASCII para poder realizar un seguimiento de las métricas de Step Functions.

  4. Seleccione Iniciar ejecución.

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

  5. (Opcional) En la sección Detalles de la ejecución, examine el Estado de ejecución y las marcas de tiempo Iniciada y Finalizada.

  6. Para ver los resultados de la ejecución, elija Salida.