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 AWS CDK pour créer un flux de travail Express dans Step Functions
<a name="tutorial-step-functions-rest-api-integration-cdk"></a>

Dans ce didacticiel, vous apprendrez à créer une API REST API Gateway avec une machine à états express synchrone comme intégration principale, à l'aide du framework AWS Cloud Development Kit (AWS CDK) Infrastructure as Code (IAC).

Vous allez utiliser la `StepFunctionsRestApi` construction pour connecter la State Machine à l'API Gateway. La `StepFunctionsRestApi` construction configurera un input/output mappage par défaut et l'API REST API Gateway, avec les autorisations requises et une méthode HTTP « ANY ».

 Avec AWS CDK un framework d'infrastructure en tant que code (IAC), vous définissez l' AWS infrastructure à l'aide d'un langage de programmation. Vous définissez une application dans l'un des langages pris en charge par le CDK, vous synthétisez le code dans un CloudFormation modèle, puis vous déployez l'infrastructure sur votre AWS compte.

 Vous allez l'utiliser CloudFormation pour définir une API REST API Gateway, qui est intégrée à Synchronous Express State Machine en tant que backend, puis vous l'utiliserez AWS Management Console pour lancer l'exécution. 

Avant de commencer ce didacticiel, configurez votre environnement de AWS CDK développement comme décrit dans [Getting Started With the AWS CDK - Prerequisites](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_prerequisites), puis installez-le AWS CDK en émettant :

```
npm install -g aws-cdk
```

## Étape 1 : Configurez votre AWS CDK projet
<a name="step-functions-rest-api-integration-cdk-step-1"></a>

Créez d'abord un répertoire pour votre nouvelle AWS CDK application et initialisez le projet.

------
#### [ TypeScript ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language typescript
```

------
#### [ JavaScript ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language javascript
```

------
#### [ Python ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language python
```

Une fois le projet initialisé, activez l'environnement virtuel du projet et installez ses dépendances AWS CDK de base.

```
source .venv/bin/activate
python -m pip install -r requirements.txt
```

------
#### [ Java ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language java
```

------
#### [ C\$1 ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language csharp
```

------
#### [ Go ]

```
mkdir stepfunctions-rest-api
cd stepfunctions-rest-api
cdk init --language go
```

------

**Note**  
Assurez-vous de donner un nom au répertoire`stepfunctions-rest-api`. Le modèle AWS CDK d'application utilise le nom du répertoire pour générer des noms pour les classes et les fichiers sources. Si vous utilisez un nom différent, votre appli ne correspondra pas à ce didacticiel.

Installez maintenant les modules de bibliothèque de construction pour AWS Step Functions Amazon API Gateway.

------
#### [ TypeScript ]

```
npm install @aws-cdk/aws-stepfunctions @aws-cdk/aws-apigateway
```

------
#### [ JavaScript ]

```
npm install @aws-cdk/aws-stepfunctions @aws-cdk/aws-apigateway
```

------
#### [ Python ]

```
python -m pip install aws-cdk.aws-stepfunctions
python -m pip install aws-cdk.aws-apigateway
```

------
#### [ Java ]

Modifiez le `pom.xml` du projet pour ajouter les dépendances suivantes dans le conteneur `<dependencies>` existant.

```
        <dependency>
            <groupId>software.amazon.awscdk</groupId>
            <artifactId>stepfunctions</artifactId>
            <version>${cdk.version}</version>
        </dependency>
        <dependency>
            <groupId>software.amazon.awscdk</groupId>
            <artifactId>apigateway</artifactId>
            <version>${cdk.version}</version>
        </dependency>
```

Maven installe automatiquement ces dépendances lors de la prochaine création de votre appli. Pour créer, émettez `mvn compile` ou utilisez la commande **Build** de votre IDE Java.

------
#### [ C\$1 ]

```
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.Stepfunctions
dotnet add src/StepfunctionsRestApi package Amazon.CDK.AWS.APIGateway
```

Vous pouvez également installer les packages indiqués à l'aide de l' NuGetinterface graphique de Visual Studio, disponible via **Outils** > **Gestionnaire de NuGet packages** > **Gérer les NuGet packages pour la solution**.

------

Une fois les modules installés, vous pouvez les utiliser dans votre AWS CDK application en important les packages suivants.

------
#### [ TypeScript ]

```
@aws-cdk/aws-stepfunctions
@aws-cdk/aws-apigateway
```

------
#### [ JavaScript ]

```
@aws-cdk/aws-stepfunctions
@aws-cdk/aws-apigateway
```

------
#### [ Python ]

```
aws_cdk.aws_stepfunctions
aws_cdk.aws_apigateway
```

------
#### [ Java ]

```
software.amazon.awscdk.services.apigateway.StepFunctionsRestApi
software.amazon.awscdk.services.stepfunctions.Pass
software.amazon.awscdk.services.stepfunctions.StateMachine
software.amazon.awscdk.services.stepfunctions.StateMachineType
```

------
#### [ C\$1 ]

```
Amazon.CDK.AWS.StepFunctions
Amazon.CDK.AWS.APIGateway
```

------
#### [ Go ]

Ajoutez ce qui suit à `import` l'intérieur`stepfunctions-rest-api.go`.

```
"github.com/aws/aws-cdk-go/awscdk/awsapigateway"
"github.com/aws/aws-cdk-go/awscdk/awsstepfunctions"
```

------

## Étape 2 : utilisez le AWS CDK pour créer une API REST API Gateway avec intégration du backend Synchrous Express State Machine
<a name="step-functions-rest-api-integration-cdk-step-2"></a>

Nous allons d'abord présenter les différents éléments de code qui définissent la Synchronous Express State Machine et l'API REST API Gateway, puis nous expliquerons comment les intégrer dans votre AWS CDK application. Vous verrez ensuite comment synthétiser et déployer ces ressources.

**Note**  
La machine à états que nous allons montrer ici sera une simple machine à états avec un `Pass` état.

### Pour créer une machine Express State
<a name="step-functions-rest-api-integration-cdk-create-state-machine"></a>

C'est le AWS CDK code qui définit une machine à états simple avec un `Pass` état.

------
#### [ TypeScript ]

```
const machineDefinition = new stepfunctions.Pass(this, 'PassState', {
    result: {value:"Hello!"},
})

const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {
    definition: machineDefinition,
    stateMachineType: stepfunctions.StateMachineType.EXPRESS,
});
```

------
#### [ JavaScript ]

```
const machineDefinition = new sfn.Pass(this, 'PassState', {
    result: {value:"Hello!"},
})

const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
    definition: machineDefinition,
    stateMachineType: stepfunctions.StateMachineType.EXPRESS,
});
```

------
#### [ Python ]

```
machine_definition = sfn.Pass(self,"PassState", 
                        result = sfn.Result("Hello"))
    
state_machine = sfn.StateMachine(self, 'MyStateMachine', 
        definition = machine_definition, 
        state_machine_type = sfn.StateMachineType.EXPRESS)
```

------
#### [ Java ]

```
Pass machineDefinition = Pass.Builder.create(this, "PassState")
                        .result(Result.fromString("Hello"))
                        .build();

StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
                            .definition(machineDefinition)
                            .stateMachineType(StateMachineType.EXPRESS)
                            .build();
```

------
#### [ C\$1 ]

```
var machineDefinition = new Pass(this, "PassState", new PassProps
{
    Result = Result.FromString("Hello")
});

var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps
{
    Definition = machineDefinition,
    StateMachineType = StateMachineType.EXPRESS
});
```

------
#### [ Go ]

```
var machineDefinition = awsstepfunctions.NewPass(stack, jsii.String("PassState"), &awsstepfunctions.PassProps
{
    Result: awsstepfunctions.NewResult(jsii.String("Hello")),
})

var stateMachine = awsstepfunctions.NewStateMachine(stack, jsii.String("StateMachine"), &awsstepfunctions.StateMachineProps
{    
    Definition: machineDefinition,
    StateMachineType: awsstepfunctions.StateMachineType_EXPRESS,
})
```

------

Vous pouvez voir les éléments suivants dans ce court extrait :
+ La définition de machine nommée`PassState`, qui est un `Pass` État.
+ Le nom logique de State Machine,`MyStateMachine`.
+ La définition de machine est utilisée comme définition de State Machine.
+ Le type de machine à états est défini comme suit : `EXPRESS` il n'`StepFunctionsRestApi`autorisera qu'une machine à état synchrone Express.

### Pour créer l'API REST API Gateway à l'aide de `StepFunctionsRestApi` construct
<a name="step-functions-rest-api-integration-cdk-create-rest-api"></a>

Nous utiliserons `StepFunctionsRestApi` construct pour créer l'API REST API Gateway avec les autorisations requises et le input/output mappage par défaut.

------
#### [ TypeScript ]

```
const api = new apigateway.StepFunctionsRestApi(this, 
  'StepFunctionsRestApi', { stateMachine: stateMachine });
```

------
#### [ JavaScript ]

```
const api = new apigateway.StepFunctionsRestApi(this, 
  'StepFunctionsRestApi', { stateMachine: stateMachine });
```

------
#### [ Python ]

```
api = apigw.StepFunctionsRestApi(self, "StepFunctionsRestApi",
                            state_machine = state_machine)
```

------
#### [ Java ]

```
StepFunctionsRestApi api = StepFunctionsRestApi.Builder.create(this, "StepFunctionsRestApi")
                           .stateMachine(stateMachine)
                           .build();
```

------
#### [ C\$1 ]

```
var api = new StepFunctionsRestApi(this, "StepFunctionsRestApi", new StepFunctionsRestApiProps
{
    StateMachine = stateMachine
});
```

------
#### [ Go ]

```
awsapigateway.NewStepFunctionsRestApi(stack, jsii.String("StepFunctionsRestApi"), &awsapigateway.StepFunctionsRestApiProps
{
    StateMachine = stateMachine,
})
```

------

### Pour créer et déployer l' AWS CDK application
<a name="step-functions-rest-api-integration-cdk-app"></a>

Dans le AWS CDK projet que vous avez créé, modifiez le fichier contenant la définition de la pile pour qu'il ressemble au code ci-dessous. Vous reconnaîtrez les définitions de la machine à états Step Functions et de l'API Gateway ci-dessus.

------
#### [ TypeScript ]

Mettez à jour ` lib/stepfunctions-rest-api-stack.ts` comme suit.

```
import * as cdk from 'aws-cdk-lib';
import * as stepfunctions from 'aws-cdk-lib/aws-stepfunctions' 
import * as apigateway from 'aws-cdk-lib/aws-apigateway';


export class StepfunctionsRestApiStack extends cdk.Stack {
    constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const machineDefinition = new stepfunctions.Pass(this, 'PassState', {
        result: {value:"Hello!"},
    });
    
    const stateMachine = new stepfunctions.StateMachine(this, 'MyStateMachine', {
        definition: machineDefinition,
        stateMachineType: stepfunctions.StateMachineType.EXPRESS,
    });
    
    const api = new apigateway.StepFunctionsRestApi(this, 
        'StepFunctionsRestApi', { stateMachine: stateMachine });
```

------
#### [ JavaScript ]

Mettez à jour `lib/stepfunctions-rest-api-stack.js` comme suit.

```
const cdk = require('@aws-cdk/core');
const stepfunctions = require('@aws-cdk/aws-stepfunctions');
const apigateway = require('@aws-cdk/aws-apigateway');


class StepfunctionsRestApiStack extends cdk.Stack {
    constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const machineDefinition = new stepfunctions.Pass(this, "PassState", {
        result: {value:"Hello!"},
    })
    
    const stateMachine = new sfn.StateMachine(this, 'MyStateMachine', {
        definition: machineDefinition,
        stateMachineType: stepfunctions.StateMachineType.EXPRESS,
    });
    
    const api = new apigateway.StepFunctionsRestApi(this, 
        'StepFunctionsRestApi', { stateMachine: stateMachine });

    }
}

module.exports = { StepStack }
```

------
#### [ Python ]

Mettez à jour `stepfunctions_rest_api/stepfunctions_rest_api_stack.py` comme suit.

```
from aws_cdk import App, Stack
from constructs import Construct
from aws_cdk import aws_stepfunctions as sfn
from aws_cdk import aws_apigateway as apigw

class StepfunctionsRestApiStack(Stack):

    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)
        
        
        machine_definition = sfn.Pass(self,"PassState", 
                                result = sfn.Result("Hello"))

        state_machine = sfn.StateMachine(self, 'MyStateMachine', 
                definition = machine_definition, 
                state_machine_type = sfn.StateMachineType.EXPRESS)

        api = apigw.StepFunctionsRestApi(self, 
                    "StepFunctionsRestApi",
                    state_machine = state_machine)
```

------
#### [ Java ]

Mettez à jour `src/main/java/com.myorg/StepfunctionsRestApiStack.java` comme suit.

```
package com.myorg;


import software.amazon.awscdk.core.Construct;
import software.amazon.awscdk.core.Stack;
import software.amazon.awscdk.core.StackProps;
import software.amazon.awscdk.services.stepfunctions.Pass;
import software.amazon.awscdk.services.stepfunctions.StateMachine;
import software.amazon.awscdk.services.stepfunctions.StateMachineType;
import software.amazon.awscdk.services.apigateway.StepFunctionsRestApi;

public class StepfunctionsRestApiStack extends Stack {
    public StepfunctionsRestApiStack(final Construct scope, final String id) {
        this(scope, id, null);
    }

    public StepfunctionsRestApiStack(final Construct scope, final String id, final StackProps props) {
        super(scope, id, props);

        Pass machineDefinition = Pass.Builder.create(this, "PassState")
                                .result(Result.fromString("Hello"))
                                .build();
        
        StateMachine stateMachine = StateMachine.Builder.create(this, "MyStateMachine")
                                    .definition(machineDefinition)
                                    .stateMachineType(StateMachineType.EXPRESS)
                                    .build();
                                    
        StepFunctionsRestApi api = StepFunctionsRestApi.Builder.create(this, "StepFunctionsRestApi")
                                   .stateMachine(stateMachine)
                                   .build();
                                   
    }
}
```

------
#### [ C\$1 ]

Mettez à jour `src/StepfunctionsRestApi/StepfunctionsRestApiStack.cs` comme suit.

```
using Amazon.CDK;
using Amazon.CDK.AWS.StepFunctions;
using Amazon.CDK.AWS.APIGateway;

namespace StepfunctionsRestApi
{
    public class StepfunctionsRestApiStack : Stack
    {
        internal StepfunctionsRestApi(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
        {
            var machineDefinition = new Pass(this, "PassState", new PassProps
            {
                Result = Result.FromString("Hello")
            });

            var stateMachine = new StateMachine(this, "MyStateMachine", new StateMachineProps
            {
                Definition = machineDefinition,
                StateMachineType = StateMachineType.EXPRESS
            });
            
            var api = new StepFunctionsRestApi(this, "StepFunctionsRestApi", new StepFunctionsRestApiProps
            {
                StateMachine = stateMachine
            });

        }
    }
}
```

------
#### [ Go ]

Mettez à jour `stepfunctions-rest-api.go` comme suit.

```
package main
import (
    "github.com/aws/aws-cdk-go/awscdk"
    "github.com/aws/aws-cdk-go/awscdk/awsapigateway"
    "github.com/aws/aws-cdk-go/awscdk/awsstepfunctions"
    "github.com/aws/constructs-go/constructs/v3"
    "github.com/aws/jsii-runtime-go"
)


type StepfunctionsRestApiGoStackProps struct {
    awscdk.StackProps
}

func NewStepfunctionsRestApiGoStack(scope constructs.Construct, id string, props *StepfunctionsRestApiGoStackProps) awscdk.Stack {
    var sprops awscdk.StackProps
    if props != nil {
        sprops = props.StackProps
    }
    stack := awscdk.NewStack(scope, &id, &sprops)

    // The code that defines your stack goes here
    var machineDefinition = awsstepfunctions.NewPass(stack, jsii.String("PassState"), &awsstepfunctions.PassProps
    {
        Result: awsstepfunctions.NewResult(jsii.String("Hello")),
    })

    var stateMachine = awsstepfunctions.NewStateMachine(stack, jsii.String("StateMachine"), &awsstepfunctions.StateMachineProps{
        Definition: machineDefinition,
        StateMachineType: awsstepfunctions.StateMachineType_EXPRESS,
    });

    awsapigateway.NewStepFunctionsRestApi(stack, jsii.String("StepFunctionsRestApi"), &awsapigateway.StepFunctionsRestApiProps{
        StateMachine = stateMachine,
    })

    return stack
}

func main() {
    app := awscdk.NewApp(nil)

    NewStepfunctionsRestApiGoStack(app, "StepfunctionsRestApiGoStack", &StepfunctionsRestApiGoStackProps{
        awscdk.StackProps{
            Env: env(),
        },
    })

    app.Synth(nil)
}

// env determines the AWS environment (account+region) in which our stack is to
// be deployed. For more information see: https://docs.aws.amazon.com/cdk/latest/guide/environments.html
func env() *awscdk.Environment {
    // If unspecified, this stack will be "environment-agnostic".
    // Account/Region-dependent features and context lookups will not work, but a
    // single synthesized template can be deployed anywhere.
    //---------------------------------------------------------------------------
    return nil

    // Uncomment if you know exactly what account and region you want to deploy
    // the stack to. This is the recommendation for production stacks.
    //---------------------------------------------------------------------------
    // return &awscdk.Environment{
    //  Account: jsii.String("account-id"),
    //  Region:  jsii.String("us-east-1"),
    // }

    // Uncomment to specialize this stack for the AWS Account and Region that are
    // implied by the current CLI configuration. This is recommended for dev
    // stacks.
    //---------------------------------------------------------------------------
    // return &awscdk.Environment{
    //  Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")),
    //  Region:  jsii.String(os.Getenv("CDK_DEFAULT_REGION")),
    // }
}
```

------

Enregistrez le fichier source, puis émettez `cdk synth` dans le répertoire principal de l'application. AWS CDK Exécute l'application et synthétise un CloudFormation modèle à partir de celle-ci, puis affiche le modèle.

Pour réellement déployer l'Amazon API Gateway et la machine AWS Step Functions d'état sur votre compte AWS, lancez`cdk deploy`. Il vous sera demandé d'approuver les politiques IAM générées. AWS CDK 

## Étape 3 : tester l'API Gateway
<a name="step-functions-rest-api-integration-cdk-step-3"></a>

Après avoir créé votre API REST API Gateway avec Synchronous Express State Machine comme intégration principale, vous pouvez tester l'API Gateway.

### Pour tester l'API Gateway déployée à l'aide de la console API Gateway
<a name="to-test-the-deployed-api-gateway-using-console"></a>

1. Ouvrez la [console Amazon API Gateway](https://console.aws.amazon.com/apigateway/) et connectez-vous.

1. Choisissez le nom de votre API REST`StepFunctionsRestApi`.

1. Dans le volet **Ressources**, choisissez la `ANY` méthode.

1. Choisissez l’onglet **Test**. Vous devrez peut-être choisir la flèche droite pour afficher l’onglet. 

1. Pour **Method** (Méthode), choisissez **POST**.

1. Pour **le corps de la demande**, copiez les paramètres de demande suivants.

   ```
   {
       "key": "Hello"
   }
   ```

1. Sélectionnez **Test**. Les informations suivantes s’affichent alors :
   + **Request** est le chemin de la ressource qui a été appelée pour la méthode. 
   + **Status** est le code d'état HTTP de la réponse.
   + **Latency** correspond au temps entre la réception de la demande de l'appelant et la réponse renvoyée.
   + **Corps de la réponse** correspond au corps de la réponse HTTP.
   + Le paramètre **En-têtes de réponse** correspond aux en-têtes de réponse HTTP.
   + Le **journal** affiche les entrées Amazon CloudWatch Logs simulées qui auraient été écrites si cette méthode avait été appelée en dehors de la console API Gateway.
**Note**  
Bien que les entrées CloudWatch Logs soient simulées, les résultats de l'appel de méthode sont réels.

La sortie **du corps de la réponse** devrait ressembler à ceci :

```
"Hello"
```

**Astuce**  
Essayez l'API Gateway avec différentes méthodes et une entrée non valide pour voir le résultat d'erreur. Vous souhaiterez peut-être modifier la machine d'état pour rechercher une clé particulière et, pendant les tests, fournir la mauvaise clé pour faire échouer l'exécution de la machine à états et générer un message d'erreur dans le **corps de réponse** en sortie.

### Pour tester l'API déployée à l'aide de cURL
<a name="to-test-the-deployed-api-gateway-using-curl"></a>

1. Ouvrez une fenêtre du terminal.

1. Copiez la commande cURL suivante et collez-la dans la fenêtre du terminal, en remplaçant `<api-id>` par l'ID de l'API et `<region>` par la région ou l'API est déployée. 

   ```
   curl -X POST\
    'https://<api-id>.execute-api.<region>.amazonaws.com/prod' \
    -d '{"key":"Hello"}' \
    -H 'Content-Type: application/json'
   ```

La sortie **du Response Body** devrait ressembler à ceci :

```
"Hello"
```

**Astuce**  
Essayez l'API Gateway avec différentes méthodes et une entrée non valide pour voir le résultat d'erreur. Vous souhaiterez peut-être modifier la machine d'état pour rechercher une clé particulière et, pendant les tests, fournir la mauvaise clé pour faire échouer l'exécution de la machine à états et générer un message d'erreur dans la sortie du **corps de réponse**.

## Étape 4 : nettoyage
<a name="step-functions-rest-api-integration-cdk-step-4"></a>

Lorsque vous avez terminé d'essayer votre API Gateway, vous pouvez démonter à la fois la machine d'état et l'API Gateway à l'aide du kit AWS CDK. Émettez `cdk destroy` dans le répertoire principal de votre appli.