Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation CloudFormation pour créer un flux de travail dans Step Functions
Dans ce didacticiel, vous allez créer une AWS Lambda fonction en utilisant AWS CloudFormation. Vous allez utiliser la CloudFormation console et un modèle YAML pour créer une *pile* (rôles IAM, fonction Lambda et machine à états). Ensuite, vous utiliserez la console Step Functions pour démarrer l'exécution de la machine à états.
Pour plus d'informations, consultez la section [Utilisation des CloudFormation modèles](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html) et la `[AWS::StepFunctions::StateMachine](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-stepfunctions-statemachine.html)` ressource du *Guide de AWS CloudFormation l'utilisateur*.
## Étape 1 : Configurez votre CloudFormation modèle
Avant d'utiliser les [exemples de modèle](#lambda-state-machine-cfn-step-2), vous devez comprendre comment déclarer les différentes parties d'un modèle CloudFormation .
### Pour créer un rôle IAM pour Lambda
Définissez la politique de confiance associée au rôle IAM pour la fonction Lambda. Les exemples suivants définissent une politique de confiance à l'aide de YAML ou de 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"
}
]
}
}
```
------
### Pour créer une fonction Lambda
Définissez les propriétés suivantes pour une fonction Lambda qui imprimera le message. `Hello World`
**Important**
Assurez-vous que votre fonction Lambda est enregistrée sous le même AWS compte et Région AWS que votre machine à états.
------
#### [ 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"
}
},
```
------
### Pour créer un rôle IAM pour l'exécution de la machine à états
Définissez la politique de confiance associée au rôle IAM pour l'exécution de la machine à états.
------
#### [ 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": "*"
}
]
}
}
]
}
},
```
------
### Pour créer une machine à états Lambda
Définissez la machine à états 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"
]
}
}
}
```
------
## Étape 2 : utiliser le CloudFormation modèle pour créer une machine à états Lambda
Une fois que vous avez compris les composants du CloudFormation modèle, vous pouvez les assembler et utiliser le modèle pour créer une CloudFormation pile.
### Pour créer la machine à états Lambda
1. Copiez l'exemple suivant dans un fichier nommé `MyStateMachine.yaml` pour l'exemple YAML ou `MyStateMachine.json` pour 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. Ouvrez la [console CloudFormation](https://console.aws.amazon.com/cloudformation/home) et choisissez **Créer une pile**.
1. Sur la page **Sélectionner un modèle**, choisissez **Télécharger un modèle sur Amazon S3**. Choisissez votre fichier `MyStateMachine`, puis choisissez **Suivant**.
1. Sur la page **Spécifier les détails**, pour **Nom de la pile**, tapez `MyStateMachine`, puis choisissez **Suivant**.
1. Dans la page **Options**, choisissez **Suivant**.
1. Sur la page de **révision**, choisissez **Je reconnais que cela CloudFormation pourrait créer des ressources IAM**. puis choisissez **Create**.
CloudFormation commence à créer la `MyStateMachine` pile et affiche le statut **CREATE\$1IN\$1PROGRESS**. Lorsque le processus est terminé, CloudFormation affiche l'état **CREATE\$1COMPLETE**.
1. (Facultatif) Pour afficher les ressources de votre pile, sélectionnez la pile et choisissez l'onglet **Ressources**.
## Étape 3 : démarrer une exécution de State Machine
Après avoir créé votre machine d'état Lambda, vous pouvez commencer son exécution.
### Pour démarrer l'exécution de la machine d'état
1. Ouvrez la [console Step Functions](https://console.aws.amazon.com/states/home) et choisissez le nom de la machine à états que vous avez créée avec CloudFormation.
1. Sur la ***MyStateMachine-ABCDEFGHIJ1K***page, sélectionnez **Nouvelle exécution**.
La page **Nouvelle exécution** s'affiche.
1. (Facultatif) Entrez un nom d'exécution personnalisé pour remplacer le nom par défaut généré.
**Noms non ASCII et journalisation**
Step Functions accepte les noms des machines à états, des exécutions, des activités et des étiquettes contenant des caractères non ASCII. Dans la mesure où ces caractères empêcheront Amazon CloudWatch d'enregistrer les données, nous vous recommandons de n'utiliser que des caractères ASCII afin de pouvoir suivre les métriques de Step Functions.
1. Choisissez **Démarrer une exécution**.
Une nouvelle exécution de votre machine d'état commence et une nouvelle page indiquant votre exécution en cours s'affiche.
1. (Facultatif) Dans la section **Execution Details (Détails de l'exécution)**, choisissez **Execution Status (Statut de l'exécution)** et les horodatages **Started (Démarré)** et **Closed (Fermé)**.
1. Pour afficher les résultats de votre exécution, choisissez **Sortie**.