D'autres exemples de AWS SDK sont disponibles dans le référentiel [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .
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.
# Scénarios d'utilisation d'API Gateway AWS SDKs
Les exemples de code suivants vous montrent comment implémenter des scénarios courants dans API Gateway avec AWS SDKs. Ces scénarios vous montrent comment accomplir des tâches spécifiques en appelant plusieurs fonctions dans API Gateway ou en les combinant avec d’autres Services AWS. Chaque exemple inclut un lien vers le code source complet, où vous trouverez des instructions sur la configuration et l’exécution du code.
Les scénarios ciblent un niveau d’expérience intermédiaire pour vous aider à comprendre les actions de service dans leur contexte.
**Topics**
+ [Créer une API REST pour suivre les données de la COVID-19](api-gateway_example_cross_ApiGatewayDataTracker_section.md)
+ [Créer une API REST de bibliothèque de prêt](api-gateway_example_cross_AuroraRestLendingLibrary_section.md)
+ [Création d’une application sans serveur pour gérer des photos](api-gateway_example_cross_PAM_section.md)
+ [Créer une application de chat WebSocket](api-gateway_example_cross_ApiGatewayWebsocketChat_section.md)
+ [Création et déploiement d’une API REST](api-gateway_example_api-gateway_Usage_CreateDeployRest_section.md)
+ [Utiliser API Gateway pour invoquer une fonction Lambda](api-gateway_example_cross_LambdaAPIGateway_section.md)
# Créer une API REST API Gateway pour suivre les données de la COVID-19
L’exemple de code suivant montre comment créer une API REST qui simule un système pour suivre les cas quotidiens de COVID-19 aux États-Unis, à l’aide de données fictives.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Montre comment utiliser AWS Chalice avec le AWS SDK pour Python (Boto3) pour créer une API REST sans serveur qui utilise Amazon API Gateway et Amazon DynamoDB. AWS Lambda L’API REST simule un système qui suit les cas quotidiens de COVID-19 aux États-Unis à l’aide de données fictives. Découvrez comment :
+ Utilisez AWS Chalice pour définir des routes dans les fonctions Lambda appelées pour gérer les requêtes REST qui passent par API Gateway.
+ Utilisez les fonctions Lambda pour récupérer et stocker des données dans une table DynamoDB afin de répondre aux demandes REST.
+ Définissez la structure des tables et les ressources des rôles de sécurité dans un AWS CloudFormation modèle.
+ Utilisez AWS Chalice CloudFormation pour empaqueter et déployer toutes les ressources nécessaires.
+ CloudFormation À utiliser pour nettoyer toutes les ressources créées.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/apigateway_covid-19_tracker).
**Les services utilisés dans cet exemple**
+ API Gateway
+ CloudFormation
+ DynamoDB
+ Lambda
------
# Créer une API REST de bibliothèque de prêt
L’exemple de code suivant montre comment créer une bibliothèque de prêt dans laquelle les clients peuvent emprunter et retourner des livres à l’aide d’une API REST soutenue par une base de données Amazon Aurora.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Montre comment utiliser l' AWS SDK pour Python (Boto3) API Amazon Relational Database Service (Amazon RDS) et AWS Chalice pour créer une API REST soutenue par une base de données Amazon Aurora. Le service Web est entièrement sans serveur et représente une bibliothèque de prêt simple où les clients peuvent emprunter et retourner des livres. Découvrez comment :
+ Créer et gérer un cluster de bases de données Aurora sans serveur.
+ AWS Secrets Manager À utiliser pour gérer les informations d'identification de base de données.
+ Implémenter une couche de stockage de données qui utilise Amazon RDS pour déplacer des données vers et hors de la base de données.
+ Utilisez AWS Chalice pour déployer une API REST sans serveur sur Amazon API Gateway et. AWS Lambda
+ Utiliser le package Requests (Requêtes) pour envoyer des requêtes au service web.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_rest_lending_library).
**Les services utilisés dans cet exemple**
+ API Gateway
+ Aurora
+ Lambda
+ Secrets Manager
------
# Création d’une application de gestion des ressources photographiques permettant aux utilisateurs de gérer les photos à l’aide d’étiquettes
Les exemples de code suivants montrent comment créer une application sans serveur permettant aux utilisateurs de gérer des photos à l’aide d’étiquettes.
------
#### [ .NET ]
**SDK pour .NET**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAssetManager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ C\$1\$1 ]
**SDK pour C\$1\$1**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/photo_asset_manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/pam_source_files).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/photo-asset-manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ Kotlin ]
**SDK pour Kotlin**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_pam).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ PHP ]
**Kit SDK pour PHP**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ Rust ]
**SDK pour Rust**
Montre comment développer une application de gestion de ressources photographiques qui détecte les étiquettes dans les images à l’aide d’Amazon Rekognition et les stocke pour les récupérer ultérieurement.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/cross_service/photo_asset_management).
Pour explorer en profondeur l’origine de cet exemple, consultez l’article sur [AWS Community](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
# Créer une application de chat Websocket avec API Gateway
L’exemple de code suivant montre comment créer une application de chat desservie par une API Websocket basée sur Amazon API Gateway.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Montre comment utiliser Amazon API Gateway V2 pour créer une API Websocket qui s'intègre à Amazon AWS Lambda DynamoDB. AWS SDK pour Python (Boto3)
+ Créez une API WebSocket dans API Gateway.
+ Définissez un gestionnaire Lambda qui stocke les connexions dans DynamoDB et publie des messages pour d’autres participants au chat.
+ Connectez-vous à l’application de chat Websocket et envoyez des messages avec le package Websockets.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/apigateway_websocket_chat).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
------
# Création et déploiement d'une API REST à l'aide d'un AWS SDK
L’exemple de code suivant illustre comment :
+ créer une API REST dans API Gateway ;
+ ajouter des ressources à l’API REST pour représenter un profil utilisateur ;
+ ajouter des méthodes d’intégration afin que l’API REST utilise une table DynamoDB pour stocker les données de profil utilisateur ;
+ envoyer des requêtes HTTP à l’API REST pour ajouter et extraire des profils utilisateur.
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Il y en a plus à ce sujet GitHub. Trouvez l’exemple complet et découvrez comment le configurer et l’exécuter dans le [référentiel d’exemples de code AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
Créez une classe qui encapsule les opérations API Gateway.
```
import argparse
import json
import logging
from pprint import pprint
import boto3
from botocore.exceptions import ClientError
import requests
logger = logging.getLogger(__name__)
class ApiGatewayToService:
"""
Encapsulates Amazon API Gateway functions that are used to create a REST API that
integrates with another AWS service.
"""
def __init__(self, apig_client):
"""
:param apig_client: A Boto3 API Gateway client.
"""
self.apig_client = apig_client
self.api_id = None
self.root_id = None
self.stage = None
def create_rest_api(self, api_name):
"""
Creates a REST API on API Gateway. The default API has only a root resource
and no HTTP methods.
:param api_name: The name of the API. This descriptive name is not used in
the API path.
:return: The ID of the newly created API.
"""
try:
result = self.apig_client.create_rest_api(name=api_name)
self.api_id = result["id"]
logger.info("Created REST API %s with ID %s.", api_name, self.api_id)
except ClientError:
logger.exception("Couldn't create REST API %s.", api_name)
raise
try:
result = self.apig_client.get_resources(restApiId=self.api_id)
self.root_id = next(
item for item in result["items"] if item["path"] == "/"
)["id"]
except ClientError:
logger.exception("Couldn't get resources for API %s.", self.api_id)
raise
except StopIteration as err:
logger.exception("No root resource found in API %s.", self.api_id)
raise ValueError from err
return self.api_id
def add_rest_resource(self, parent_id, resource_path):
"""
Adds a resource to a REST API.
:param parent_id: The ID of the parent resource.
:param resource_path: The path of the new resource, relative to the parent.
:return: The ID of the new resource.
"""
try:
result = self.apig_client.create_resource(
restApiId=self.api_id, parentId=parent_id, pathPart=resource_path
)
resource_id = result["id"]
logger.info("Created resource %s.", resource_path)
except ClientError:
logger.exception("Couldn't create resource %s.", resource_path)
raise
else:
return resource_id
def add_integration_method(
self,
resource_id,
rest_method,
service_endpoint_prefix,
service_action,
service_method,
role_arn,
mapping_template,
):
"""
Adds an integration method to a REST API. An integration method is a REST
resource, such as '/users', and an HTTP verb, such as GET. The integration
method is backed by an AWS service, such as Amazon DynamoDB.
:param resource_id: The ID of the REST resource.
:param rest_method: The HTTP verb used with the REST resource.
:param service_endpoint_prefix: The service endpoint that is integrated with
this method, such as 'dynamodb'.
:param service_action: The action that is called on the service, such as
'GetItem'.
:param service_method: The HTTP method of the service request, such as POST.
:param role_arn: The Amazon Resource Name (ARN) of a role that grants API
Gateway permission to use the specified action with the
service.
:param mapping_template: A mapping template that is used to translate REST
elements, such as query parameters, to the request
body format required by the service.
"""
service_uri = (
f"arn:aws:apigateway:{self.apig_client.meta.region_name}"
f":{service_endpoint_prefix}:action/{service_action}"
)
try:
self.apig_client.put_method(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
authorizationType="NONE",
)
self.apig_client.put_method_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseModels={"application/json": "Empty"},
)
logger.info("Created %s method for resource %s.", rest_method, resource_id)
except ClientError:
logger.exception(
"Couldn't create %s method for resource %s.", rest_method, resource_id
)
raise
try:
self.apig_client.put_integration(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
type="AWS",
integrationHttpMethod=service_method,
credentials=role_arn,
requestTemplates={"application/json": json.dumps(mapping_template)},
uri=service_uri,
passthroughBehavior="WHEN_NO_TEMPLATES",
)
self.apig_client.put_integration_response(
restApiId=self.api_id,
resourceId=resource_id,
httpMethod=rest_method,
statusCode="200",
responseTemplates={"application/json": ""},
)
logger.info(
"Created integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
except ClientError:
logger.exception(
"Couldn't create integration for resource %s to service URI %s.",
resource_id,
service_uri,
)
raise
def deploy_api(self, stage_name):
"""
Deploys a REST API. After a REST API is deployed, it can be called from any
REST client, such as the Python Requests package or Postman.
:param stage_name: The stage of the API to deploy, such as 'test'.
:return: The base URL of the deployed REST API.
"""
try:
self.apig_client.create_deployment(
restApiId=self.api_id, stageName=stage_name
)
self.stage = stage_name
logger.info("Deployed stage %s.", stage_name)
except ClientError:
logger.exception("Couldn't deploy stage %s.", stage_name)
raise
else:
return self.api_url()
def api_url(self, resource=None):
"""
Builds the REST API URL from its parts.
:param resource: The resource path to append to the base URL.
:return: The REST URL to the specified resource.
"""
url = (
f"https://{self.api_id}.execute-api.{self.apig_client.meta.region_name}"
f".amazonaws.com/{self.stage}"
)
if resource is not None:
url = f"{url}/{resource}"
return url
```
Déployez une API REST et appelez-la avec le package Requests.
```
def usage_demo(table_name, role_name, rest_api_name):
"""
Demonstrates how to used API Gateway to create and deploy a REST API, and how
to use the Requests package to call it.
:param table_name: The name of the demo DynamoDB table.
:param role_name: The name of the demo role that grants API Gateway permission to
call DynamoDB.
:param rest_api_name: The name of the demo REST API created by the demo.
"""
gateway = ApiGatewayToService(boto3.client("apigateway"))
role = boto3.resource("iam").Role(role_name)
print("Creating REST API in API Gateway.")
gateway.create_rest_api(rest_api_name)
print("Adding resources to the REST API.")
profiles_id = gateway.add_rest_resource(gateway.root_id, "profiles")
username_id = gateway.add_rest_resource(profiles_id, "{username}")
# The DynamoDB service requires that all integration requests use POST.
print("Adding integration methods to read and write profiles in Amazon DynamoDB.")
gateway.add_integration_method(
profiles_id,
"GET",
"dynamodb",
"Scan",
"POST",
role.arn,
{"TableName": table_name},
)
gateway.add_integration_method(
profiles_id,
"POST",
"dynamodb",
"PutItem",
"POST",
role.arn,
{
"TableName": table_name,
"Item": {
"username": {"S": "$input.path('$.username')"},
"name": {"S": "$input.path('$.name')"},
"title": {"S": "$input.path('$.title')"},
},
},
)
gateway.add_integration_method(
username_id,
"GET",
"dynamodb",
"GetItem",
"POST",
role.arn,
{
"TableName": table_name,
"Key": {"username": {"S": "$method.request.path.username"}},
},
)
stage = "test"
print(f"Deploying the {stage} stage.")
gateway.deploy_api(stage)
profiles_url = gateway.api_url("profiles")
print(
f"Using the Requests package to post some people to the profiles REST API at "
f"{profiles_url}."
)
requests.post(
profiles_url,
json={"username": "will", "name": "William Shakespeare", "title": "playwright"},
)
requests.post(
profiles_url,
json={
"username": "ludwig",
"name": "Ludwig van Beethoven",
"title": "composer",
},
)
requests.post(
profiles_url,
json={"username": "jane", "name": "Jane Austen", "title": "author"},
)
print("Getting the list of profiles from the REST API.")
profiles = requests.get(profiles_url).json()
pprint(profiles)
print(f"Getting just the profile for username 'jane' (URL: {profiles_url}/jane).")
jane = requests.get(f"{profiles_url}/jane").json()
pprint(jane)
```
+ Pour plus de détails sur l’API, consultez les rubriques suivantes dans la *Référence des API du kit AWS SDK for Python (Boto3)*.
+ [CreateDeployment](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateDeployment)
+ [CreateResource](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateResource)
+ [CreateRestApi](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/CreateRestApi)
+ [DeleteRestApi](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/DeleteRestApi)
+ [GetResources](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/GetResources)
+ [GetRestApis](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/GetRestApis)
+ [PutIntegration](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutIntegration)
+ [PutIntegrationResponse](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutIntegrationResponse)
+ [PutMethod](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutMethod)
+ [PutMethodResponse](https://docs.aws.amazon.com/goto/boto3/apigateway-2015-07-09/PutMethodResponse)
------
# Utiliser API Gateway pour appeler une fonction Lambda
Les exemples de code suivants montrent comment créer une AWS Lambda fonction invoquée par Amazon API Gateway.
------
#### [ Java ]
**SDK pour Java 2.x**
Montre comment créer une AWS Lambda fonction à l'aide de l'API d'exécution Lambda Java. Cet exemple fait appel à différents AWS services pour réaliser un cas d'utilisation spécifique. Cet exemple montre comment créer une fonction Lambda invoquée par Amazon API Gateway qui analyse une table Amazon DynamoDB à la recherche d’anniversaires professionnels et utilise Amazon Simple Notification Service (Amazon SNS) pour envoyer un message texte à vos employés qui les félicitent à leur date d’anniversaire.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_lambda_apigateway).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon SNS
------
#### [ JavaScript ]
**SDK pour JavaScript (v3)**
Montre comment créer une AWS Lambda fonction à l'aide de l'API JavaScript d'exécution Lambda. Cet exemple fait appel à différents AWS services pour réaliser un cas d'utilisation spécifique. Cet exemple montre comment créer une fonction Lambda invoquée par Amazon API Gateway qui analyse une table Amazon DynamoDB à la recherche d’anniversaires professionnels et utilise Amazon Simple Notification Service (Amazon SNS) pour envoyer un message texte à vos employés qui les félicitent à leur date d’anniversaire.
Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway).
Cet exemple est également disponible dans le [AWS SDK pour JavaScript guide du développeur v3](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/api-gateway-invoking-lambda-example.html).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon SNS
------
#### [ Python ]
**Kit SDK for Python (Boto3)**
Cet exemple montre comment créer et utiliser une API REST Amazon API Gateway qui cible une fonction AWS Lambda . Le gestionnaire Lambda explique comment router en fonction des méthodes HTTP, comment obtenir des données à partir de la chaîne de requête, de l’en-tête et du corps, et comment renvoyer une réponse JSON.
+ Déployer une fonction Lambda.
+ Créer une API REST avec API Gateway.
+ Créer une ressource REST qui cible la fonction Lambda.
+ Accorder à API Gateway l’autorisation d’invoquer la fonction Lambda.
+ Utiliser le package Requests (Requêtes) pour envoyer des requêtes à l’API REST.
+ Nettoyer toutes les ressources créées lors de la démonstration.
Il est préférable de visionner cet exemple sur GitHub. Pour obtenir le code source complet et les instructions de configuration et d'exécution, consultez l'exemple complet sur [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/lambda#readme).
**Les services utilisés dans cet exemple**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon SNS
------