Hay más ejemplos de AWS SDK disponibles en el GitHub repositorio de [ejemplos de AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples).
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.
# Escenarios para el uso de API Gateway AWS SDKs
Los siguientes ejemplos de código muestran cómo implementar escenarios comunes en API Gateway con AWS SDKs. Estos escenarios muestran cómo realizar tareas específicas con llamadas a varias funciones dentro de API Gateway o en combinación con otros Servicios de AWS. En cada escenario se incluye un enlace al código fuente completo, con instrucciones de configuración y ejecución del código.
Los escenarios requieren un nivel intermedio de experiencia para entender las acciones de servicio en su contexto.
**Topics**
+ [Creación de una API REST para realizar un seguimiento de datos de COVID-19](api-gateway_example_cross_ApiGatewayDataTracker_section.md)
+ [Crear una biblioteca de préstamos de API de REST](api-gateway_example_cross_AuroraRestLendingLibrary_section.md)
+ [Creación de una aplicación sin servidor para administrar fotos](api-gateway_example_cross_PAM_section.md)
+ [Creación una aplicación de chat de websocket](api-gateway_example_cross_ApiGatewayWebsocketChat_section.md)
+ [Crear e implementar una API de REST](api-gateway_example_api-gateway_Usage_CreateDeployRest_section.md)
+ [Uso de API Gateway para invocar una función de Lambda](api-gateway_example_cross_LambdaAPIGateway_section.md)
# Creación de una API de REST de API Gateway para realizar un seguimiento de datos de COVID-19
En el siguiente ejemplo se muestra cómo crear una API REST que simule un sistema de seguimiento de los casos diarios de COVID-19 en Estados Unidos, con datos ficticios.
------
#### [ Python ]
**SDK para Python (Boto3)**
Muestra cómo usar AWS Chalice con el AWS SDK para Python (Boto3) para crear una API REST sin servidor que utilice Amazon API Gateway y Amazon DynamoDB. AWS Lambda La API REST simula un sistema que hace el seguimiento de los casos diarios de COVID-19 en Estados Unidos, con datos ficticios. Aprenda cómo:
+ Use AWS Chalice para definir las rutas en las funciones de Lambda que se llaman para gestionar las solicitudes REST que llegan a través de API Gateway.
+ Utilizar funciones de Lambda para recuperar y almacenar datos en una tabla de DynamoDB para atender solicitudes REST.
+ Defina la estructura de la tabla y los recursos de las funciones de seguridad en una plantilla AWS CloudFormation .
+ Usa AWS Chalice CloudFormation para empaquetar y desplegar todos los recursos necesarios.
+ CloudFormation Úselo para limpiar todos los recursos creados.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/apigateway_covid-19_tracker).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ CloudFormation
+ DynamoDB
+ Lambda
------
# Creación de una API de REST de biblioteca de préstamos
En el siguiente ejemplo de código se muestra cómo crear una biblioteca de préstamos en la que los usuarios puedan pedir prestados y devolver libros mediante una API de REST respaldada por una base de datos de Amazon Aurora.
------
#### [ Python ]
**SDK para Python (Boto3)**
Muestra cómo utilizarla AWS SDK para Python (Boto3) con la API de Amazon Relational Database Service (Amazon RDS) y AWS Chalice para crear una API REST respaldada por una base de datos de Amazon Aurora. El servicio web es totalmente sin servidor y representa una biblioteca de préstamos sencilla en la que los usuarios pueden pedir prestados libros y devolverlos. Aprenda cómo:
+ Crear y administrar un clúster de base de datos Aurora sin servidor.
+ Se utiliza para administrar AWS Secrets Manager las credenciales de la base de datos.
+ Implementar una capa de almacenamiento de datos que utilice Amazon RDS para mover datos dentro y fuera de la base de datos.
+ Use AWS Chalice para implementar una API REST sin servidor en Amazon API Gateway y. AWS Lambda
+ Utilice el paquete Requests para enviar solicitudes al servicio web.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarla y ejecutarla, consulte el ejemplo completo en. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/aurora_rest_lending_library)
**Servicios utilizados en este ejemplo**
+ API Gateway
+ Aurora
+ Lambda
+ Secrets Manager
------
# Creación de una aplicación de administración de activos fotográficos que permita a los usuarios administrar las fotos mediante etiquetas
En los siguientes ejemplos de código se muestra cómo crear una aplicación sin servidor que permita a los usuarios administrar fotos mediante etiquetas.
------
#### [ .NET ]
**SDK para .NET**
Muestra cómo desarrollar una aplicación de administración de activos fotográficos que detecte las etiquetas de las imágenes mediante Amazon Rekognition y las almacene para su posterior recuperación.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAssetManager).
Para profundizar en el origen de este ejemplo, consulte la publicación en [Comunidad de AWS](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ C\$1\$1 ]
**SDK para C\$1\$1**
Muestra cómo desarrollar una aplicación de administración de activos fotográficos que detecte las etiquetas de las imágenes mediante Amazon Rekognition y las almacene para su posterior recuperación.
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/cpp/example_code/cross-service/photo_asset_manager).
Para profundizar en el origen de este ejemplo, consulte la publicación en [Comunidad de AWS](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ Java ]
**SDK para Java 2.x**
Muestra cómo desarrollar una aplicación de administración de activos fotográficos que detecte las etiquetas de las imágenes mediante Amazon Rekognition y las almacene para su posterior recuperación.
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/pam_source_files).
Para profundizar en el origen de este ejemplo, consulte la publicación en [Comunidad de AWS](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Muestra cómo desarrollar una aplicación de administración de activos fotográficos que detecte las etiquetas de las imágenes mediante Amazon Rekognition y las almacene para su posterior recuperación.
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/photo-asset-manager).
Para profundizar en el origen de este ejemplo, consulte la publicación en [Comunidad de AWS](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ Kotlin ]
**SDK para Kotlin**
Muestra cómo desarrollar una aplicación de administración de activos fotográficos que detecte las etiquetas de las imágenes mediante Amazon Rekognition y las almacene para su posterior recuperación.
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/usecases/creating_pam).
Para profundizar en el origen de este ejemplo, consulte la publicación en [Comunidad de AWS](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ PHP ]
**SDK para PHP**
Muestra cómo desarrollar una aplicación de administración de activos fotográficos que detecte las etiquetas de las imágenes mediante Amazon Rekognition y las almacene para su posterior recuperación.
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/php/applications/photo_asset_manager).
Para profundizar en el origen de este ejemplo, consulte la publicación en [Comunidad de AWS](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
#### [ Rust ]
**SDK para Rust**
Muestra cómo desarrollar una aplicación de administración de activos fotográficos que detecte las etiquetas de las imágenes mediante Amazon Rekognition y las almacene para su posterior recuperación.
Para ver el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulta el ejemplo completo en [ GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/rustv1/cross_service/photo_asset_management).
Para profundizar en el origen de este ejemplo, consulte la publicación en [Comunidad de AWS](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
------
# Creación una aplicación de chat de websocket con API Gateway
En el siguiente ejemplo se muestra cómo crear una aplicación de chat servida por una API de websocket basada en Amazon API Gateway.
------
#### [ Python ]
**SDK para Python (Boto3)**
Muestra cómo utilizar Amazon API Gateway V2 para crear una API websocket que se integre con Amazon AWS Lambda DynamoDB. AWS SDK para Python (Boto3)
+ Crear una API de websocket servida por API Gateway.
+ Definir un identificador Lambda que almacene las conexiones en DynamoDB y envíe mensajes a otros participantes del chat.
+ Conectar con la aplicación de chat de websocket y enviar mensajes con el paquete Websockets.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en. [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/cross_service/apigateway_websocket_chat)
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
------
# Cree e implemente una API REST mediante un AWS SDK
En el siguiente ejemplo de código, se muestra cómo:
+ Crear una API de REST servida por una puerta de enlace de API.
+ Añadir recursos a la API de REST para representar un perfil de usuario.
+ Añadir métodos de integración para que la API de REST utilice una tabla de DynamoDB para almacenar los datos de perfil de usuario.
+ Enviar solicitudes HTTP a la API de REST para añadir y recuperar perfiles de usuario.
------
#### [ Python ]
**SDK para Python (Boto3)**
Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/api-gateway#code-examples).
Cree una clase que contenga las operaciones de puerta de enlace de API.
```
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
```
Implemente una API de REST y llame a la API con el paquete de recursos.
```
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)
```
+ Para obtener información sobre la API, consulte los siguientes temas en la *Referencia de la API de AWS SDK para 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)
------
# Uso de API Gateway para invocar una función de Lambda
Los siguientes ejemplos de código muestran cómo crear una AWS Lambda función invocada por Amazon API Gateway.
------
#### [ Java ]
**SDK para Java 2.x**
Muestra cómo crear una AWS Lambda función mediante la API Lambda Java Runtime. En este ejemplo, se invocan diferentes AWS servicios para realizar un caso de uso específico. En este ejemplo se indica cómo crear una función de Lambda invocada por Amazon API Gateway que escanea una tabla de Amazon DynamoDB en busca de aniversarios laborales y utiliza Amazon Simple Notification Service (Amazon SNS) para enviar un mensaje de texto a sus empleados que les felicite en la fecha de su primer aniversario.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/creating_lambda_apigateway).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon SNS
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Muestra cómo crear una AWS Lambda función mediante la API de tiempo de JavaScript ejecución de Lambda. En este ejemplo, se invocan diferentes AWS servicios para realizar un caso de uso específico. En este ejemplo se indica cómo crear una función de Lambda invocada por Amazon API Gateway que escanea una tabla de Amazon DynamoDB en busca de aniversarios laborales y utiliza Amazon Simple Notification Service (Amazon SNS) para enviar un mensaje de texto a sus empleados que les felicite en la fecha de su primer aniversario.
Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/lambda-api-gateway).
Este ejemplo también está disponible en la [Guía para desarrolladores de AWS SDK para JavaScript v3](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/api-gateway-invoking-lambda-example.html).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon SNS
------
#### [ Python ]
**SDK para Python (Boto3)**
En este ejemplo se muestra cómo crear y utilizar una API de REST de Amazon API Gateway dirigida a una función AWS Lambda . El controlador Lambda muestra cómo enrutar según los métodos HTTP; cómo obtener datos de la cadena de consulta, el encabezado y el cuerpo; y cómo devolver una respuesta JSON.
+ Implemente una función de Lambda.
+ Cree una API de REST mediante API Gateway.
+ Cree un recurso REST que se dirija a la función de Lambda.
+ Otorgue permiso para permitir que API Gateway invoque la función de Lambda.
+ Utilice el paquete Requests para enviar solicitudes a la API de REST.
+ Limpie todos los recursos creados durante la demostración.
Este ejemplo se ve mejor en GitHub. Para obtener el código fuente completo y las instrucciones sobre cómo configurarlo y ejecutarlo, consulte el ejemplo completo en [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/lambda#readme).
**Servicios utilizados en este ejemplo**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon SNS
------