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](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) y el `[AWS::StepFunctions::StateMachine](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)` recurso en la Guía del AWS CloudFormation usuario.*
## Paso 1: Configure la CloudFormation plantilla
Antes de utilizar las [plantillas de ejemplo](#lambda-state-machine-cfn-step-2), 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"
]
}
}
}
}
}
```
------
1. Abra la [consola de CloudFormation](https://console.aws.amazon.com/cloudformation/home) y elija **Crear pila**.
1. En la página **Seleccionar plantilla**, elija **Cargar una plantilla en Amazon S3**. Elija su archivo `MyStateMachine` y después elija **Siguiente**.
1. En la página **Especificar detalles**, en **Nombre de la pila**, escriba `MyStateMachine` y, a continuación, elija **Siguiente**.
1. En la página **Opciones**, seleccione **Siguiente**.
1. 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\$1IN\$1PROGRESS**. Cuando el proceso se haya completado, CloudFormation mostrará el estado **CREATE\$1COMPLETE**.
1. (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](https://console.aws.amazon.com/states/home) y elija el nombre de la máquina de estados que creó con ella CloudFormation.
1. En la ***MyStateMachine-ABCDEFGHIJ1K***página, elija **Nueva ejecución**.
Aparece la página **Nueva ejecución**.
1. (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.
1. 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.
1. (Opcional) En la sección **Detalles de la ejecución**, examine el **Estado de ejecución** y las marcas de tiempo **Iniciada** y **Finalizada**.
1. Para ver los resultados de la ejecución, elija **Salida**.