Guía para desarrolladores

Amazon API Gateway

Copyright © 2024 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
Amazon API Gateway Guía para desarrolladores

Amazon API Gateway: Guía para desarrolladores

Copyright © 2024 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Las marcas comerciales y la imagen comercial de Amazon no se pueden utilizar en relación con
ningún producto o servicio que no sea de Amazon de ninguna manera que pueda causar confusión
entre los clientes y que menosprecie o desacredite a Amazon. Todas las demás marcas comerciales
que no son propiedad de Amazon son propiedad de sus respectivos propietarios, que pueden o no
estar afiliados, relacionados o patrocinados por Amazon.
Amazon API Gateway Guía para desarrolladores

Table of Contents
¿Qué es Amazon API Gateway? ......................................................................................................... 1
Arquitectura de API Gateway .......................................................................................................... 2
Características de API Gateway ..................................................................................................... 3
Casos de uso de API Gateway ....................................................................................................... 3
Uso de API Gateway para crear API REST .............................................................................. 4
Uso de API Gateway para crear API HTTP .............................................................................. 5
Uso de API Gateway para crear API de WebSocket ................................................................. 5
¿Quiénes utilizan API Gateway? ................................................................................................ 6
Acceso a API Gateway ................................................................................................................... 7
Parte de la infraestructura sin servidor de AWS ............................................................................ 8
Cómo comenzar a usar Amazon API Gateway .............................................................................. 8
Conceptos de API Gateway ............................................................................................................ 8
Elección entre API de REST y API HTTP .................................................................................... 14
................................................................................................................................................... 14
Tipo de punto de conexión ....................................................................................................... 14
Seguridad .................................................................................................................................. 15
Autorización ............................................................................................................................... 15
Administración de API .............................................................................................................. 16
Desarrollo .................................................................................................................................. 16
Supervisión ................................................................................................................................ 17
Integraciones ............................................................................................................................. 18
Introducción a la consola de la API de REST .............................................................................. 19
Paso 1: Crear una función Lambda ......................................................................................... 20
Paso 2: Crear una API de REST ............................................................................................. 20
Paso 3: Crear una integración de proxy de Lambda ............................................................... 21
Paso 4: Implementar la API ...................................................................................................... 21
Paso 5: Invocar la API .............................................................................................................. 22
(Opcional) Paso 6: limpiar ........................................................................................................ 23
Requisitos previos .............................................................................................................................. 25
Registro para obtener una Cuenta de AWS ................................................................................. 25
Crear un usuario administrativo .................................................................................................... 25
Introducción ........................................................................................................................................ 27
Paso 1: Crear una función Lambda .............................................................................................. 28
Paso 2: crear una API HTTP ........................................................................................................ 29

iii
Amazon API Gateway Guía para desarrolladores

Paso 3: probar la API .................................................................................................................... 30

(Opcional) Paso 4: limpiar ............................................................................................................. 31
Pasos siguientes ............................................................................................................................ 32
Tutoriales y talleres ............................................................................................................................ 33
Tutoriales sobre API REST ........................................................................................................... 34
Desarrollo de una API con la integración de Lambda ............................................................. 34
Tutorial: Crear una API de REST importando un ejemplo ....................................................... 59
Desarrollo de una API con integración de HTTP ..................................................................... 67
Tutorial: Creación de una API con integración privada ........................................................... 82
Tutorial: Creación de una API con integración de AWS .......................................................... 85
Tutorial: API Calc con tres integraciones ............................................................................... 91
Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway .................... 120
Tutorial: Creación de una API de REST como proxy de Amazon Kinesis ............................. 166
Crear una API REST privada ................................................................................................. 211
Tutoriales sobre API HTTP ......................................................................................................... 218
API CRUD con Lambda y DynamoDB ................................................................................... 218
Integración privada en Amazon ECS ..................................................................................... 229
Tutoriales de la API de WebSocket ............................................................................................ 236
Aplicación de chat de WebSocket .......................................................................................... 237
Uso de API de REST ....................................................................................................................... 243
Desarrollo ..................................................................................................................................... 243
Crear y configurar ................................................................................................................... 244
Control de acceso ................................................................................................................... 292
Integraciones ........................................................................................................................... 377
Validación de solicitudes ........................................................................................................ 446
Transformaciones de datos .................................................................................................... 480
Respuestas de gateway ......................................................................................................... 566
CORS ...................................................................................................................................... 579
Tipos de medios binarios ....................................................................................................... 592
Invocación ............................................................................................................................... 625
OpenAPI .................................................................................................................................. 659
Publicación ................................................................................................................................... 673
Implementación de una API de REST ................................................................................... 674
Nombres de dominio personalizados ..................................................................................... 721
Optimizar ...................................................................................................................................... 761
Configuración de caché .......................................................................................................... 761

iv
Amazon API Gateway Guía para desarrolladores

Codificación de contenido ...................................................................................................... 771

Distribuir ....................................................................................................................................... 777
Planes de uso ......................................................................................................................... 777
Documentación de la API ....................................................................................................... 800
Generación de SDK ................................................................................................................ 865
Vender sus API como SaaS .................................................................................................. 893
Proteger ....................................................................................................................................... 897
TLS mutua .............................................................................................................................. 898
Certificados de cliente ............................................................................................................ 905
AWS WAF ............................................................................................................................... 946
Limitación controlada .............................................................................................................. 948
API privadas ............................................................................................................................ 951
Monitoreo ..................................................................................................................................... 962
Métricas de CloudWatch ........................................................................................................ 963
CloudWatch Logs .................................................................................................................... 973
Kinesis Data Firehose ............................................................................................................ 979
X-Ray ...................................................................................................................................... 981
Uso de API HTTP ............................................................................................................................ 996
Desarrollo ..................................................................................................................................... 996
Creación de una API HTTP ................................................................................................... 997
Rutas ....................................................................................................................................... 998
Control de acceso ................................................................................................................. 1001
Integraciones ......................................................................................................................... 1016
CORS .................................................................................................................................... 1038
Asignación de parámetros .................................................................................................... 1041
OpenAPI ................................................................................................................................ 1048
Publicación ................................................................................................................................. 1058
Etapas ................................................................................................................................... 1059
Nombres de dominio personalizados ................................................................................... 1062
Proteger ..................................................................................................................................... 1069
Limitación controlada ............................................................................................................ 1070
TLS mutua ............................................................................................................................ 1071
Monitoreo ................................................................................................................................... 1078
Métricas ................................................................................................................................. 1078
Registro de ............................................................................................................................ 1081
Solución de problemas .............................................................................................................. 1092

v
Amazon API Gateway Guía para desarrolladores

Integraciones de Lambda ..................................................................................................... 1092

Autorizadores de JWT .......................................................................................................... 1094
Trabajar con API de WebSocket ................................................................................................... 1096
Acerca de las API de WebSocket ............................................................................................. 1096
Administración de usuarios conectados y aplicaciones cliente ............................................ 1098
Invocación de la integración del backend ............................................................................ 1101
Envío de datos de los servicios de backend a los clientes conectados ............................... 1105
Expresiones de selección de WebSocket ............................................................................ 1105
Desarrollo ................................................................................................................................... 1116
Crear y configurar ................................................................................................................. 1116
Rutas ..................................................................................................................................... 1118
Control de acceso ................................................................................................................. 1127
Integraciones ......................................................................................................................... 1135
Validación de solicitudes ...................................................................................................... 1143
Transformaciones de datos .................................................................................................. 1144
Tipos de medios binarios ..................................................................................................... 1156
Invocación ............................................................................................................................. 1156
Publicación ................................................................................................................................. 1160
Etapas ................................................................................................................................... 1160
Implementación de una API de WebSocket ........................................................................ 1163
Nombres de dominio personalizados ................................................................................... 1166
Proteger ..................................................................................................................................... 1171
Limitaciones de nivel de cuenta por región ......................................................................... 1172
Limitación controlada de nivel de ruta ................................................................................. 1172
Monitoreo ................................................................................................................................... 1173
Métricas ................................................................................................................................. 1174
Registro de ............................................................................................................................ 1176
ARN de API Gateway .................................................................................................................... 1185
Recursos de API de HTTP y API de WebSocket ..................................................................... 1185
Recursos de API de REST ....................................................................................................... 1188
execute-api (API de HTTP, API de WebSocket y API de REST) ........................................ 1193
Extensiones de OpenAPI ............................................................................................................... 1194
x-amazon-apigateway-any-method .................................................................................. 1195
Ejemplos de x-amazon-apigateway-any-method .................................................................. 1196
x-amazon-apigateway-cors ........................................................................................................ 1197
Ejemplo de x-amazon-apigateway-cors ................................................................................ 1197

vi
Amazon API Gateway Guía para desarrolladores

x-amazon-apigateway-api-key-source .......................................................................... 1198

Ejemplo de x-amazon-apigateway-api-key-source ............................................................... 1199
x-amazon-apigateway-auth ............................................................................................... 1200
Ejemplo de x-amazon-apigateway-auth ............................................................................... 1200
x-amazon-apigateway-authorizer .................................................................................. 1201
Ejemplos de x-amazon-apigateway-authorizer para API REST ........................................... 1204
Ejemplos de x-amazon-apigateway-authorizer para API HTTP ........................................... 1208
x-amazon-apigateway-authtype ....................................................................................... 1210
Ejemplo de x-amazon-apigateway-authtype ......................................................................... 1210
Véase también ...................................................................................................................... 1212
x-amazon-apigateway-binary-media-type .................................................................................. 1212
Ejemplo de x-amazon-apigateway-binary-media-types ........................................................ 1212
x-amazon-apigateway-documentation ....................................................................................... 1213
Ejemplo de x-amazon-apigateway-documentation ............................................................... 1213
x-amazon-apigateway-endpoint-configuration ........................................................................... 1214
Ejemplos de x-amazon-apigateway-endpoint-configuration ................................................. 1215
x-amazon-apigateway-gateway-responses ................................................................................ 1215
Ejemplo de x-amazon-apigateway-gateway-responses ....................................................... 1215
x-amazon-apigateway-gateway-responses.gatewayResponse ................................................. 1216
Ejemplo de x-amazon-apigateway-gateway-responses.gatewayResponse ......................... 1217
x-amazon-apigateway-gateway-responses.responseParameters ............................................. 1217
Ejemplo de x-amazon-apigateway-gateway-responses.responseParameters ..................... 1218
x-amazon-apigateway-gateway-responses.responseTemplates ............................................... 1218
Ejemplo de x-amazon-apigateway-gateway-responses.responseTemplates ....................... 1219
x-amazon-apigateway-importexport-version .............................................................................. 1219
Ejemplo de x-amazon-apigateway-importexport-version ...................................................... 1220
x-amazon-apigateway-integration ................................................................................ 1220
Ejemplos de x-amazon-apigateway-integration .................................................................... 1227
x-amazon-apigateway-integrations ............................................................................................ 1229
Ejemplo de x-amazon-apigateway-integrations .................................................................... 1229
x-amazon-apigateway-integration.requestTemplates ................................................................ 1231
Ejemplo de x-amazon-apigateway-integration.requestTemplates ........................................ 1231
x-amazon-apigateway-integration.requestParameters .............................................................. 1232
x-amazon-apigateway-integration.requestParametersEjemplo de .................. 1233
x-amazon-apigateway-integration.responses ............................................................................ 1234
x-amazon-apigateway-integration.responsesEjemplo de .................................... 1235

vii
Amazon API Gateway Guía para desarrolladores

x-amazon-apigateway-integration.response .............................................................................. 1236

x-amazon-apigateway-integration.responseEjemplo de ...................................... 1237
x-amazon-apigateway-integration.responseTemplates ............................................................. 1238
Ejemplo de x-amazon-apigateway-integration.responseTemplate ....................................... 1238
x-amazon-apigateway-integration.responseParameters ........................................................... 1239
x-amazon-apigateway-integration.responseParametersEjemplo de ................ 1239
x-amazon-apigateway-integration.tlsConfig ............................................................................... 1239
Ejemplos de x-amazon-apigateway-integration.tlsConfig ..................................................... 1242
x-amazon-apigateway-minimum-compression-size ................................................................... 1242
Ejemplo de x-amazon-apigateway-minimum-compression-size ........................................... 1243
x-amazon-apigateway-policy ...................................................................................................... 1243
x-amazon-apigateway-policyEjemplo de .................................................................... 1243
x-amazon-apigateway-request-validator .................................................................................... 1244
x-amazon-apigateway-request-validatorEjemplo de ............................................ 1244
x-amazon-apigateway-request-validators .................................................................................. 1245
x-amazon-apigateway-request-validatorsEjemplo de .......................................... 1246
x-amazon-apigateway-request-validators.requestValidator ....................................................... 1246
x-amazon-apigateway-request-validators.requestValidatorEjemplo de ..... 1247
x-amazon-apigateway-tag-value ................................................................................................ 1247
x-amazon-apigateway-tag-valueEjemplo de ............................................................. 1247
Seguridad ........................................................................................................................................ 1249
Protección de los datos ............................................................................................................. 1250
Cifrado de datos ................................................................................................................... 1251
Privacidad del tráfico entre redes ......................................................................................... 1252
Administración de identidades y accesos ................................................................................. 1252
Público ................................................................................................................................... 1252
Autenticación con identidades .............................................................................................. 1253
Administración de acceso mediante políticas ...................................................................... 1257
Cómo funciona Amazon API Gateway con IAM .................................................................. 1259
Ejemplos de políticas basadas en identidades .................................................................... 1265
Ejemplos de políticas basadas en recursos ......................................................................... 1273
Solución de problemas ......................................................................................................... 1274
Uso de roles vinculados a servicios ..................................................................................... 1276
Registro y monitorización .......................................................................................................... 1281
Trabajo con AWS CloudTrail ................................................................................................ 1282
Trabajo con AWS Config ...................................................................................................... 1285

viii
Amazon API Gateway Guía para desarrolladores

Validación de conformidad ........................................................................................................ 1288

Resiliencia .................................................................................................................................. 1290
Seguridad de infraestructuras ................................................................................................... 1290
Configuración y análisis de vulnerabilidades ............................................................................ 1291
Prácticas recomendadas ........................................................................................................... 1291
Etiquetado ....................................................................................................................................... 1294
Recursos de API Gateway que se pueden etiquetar ................................................................ 1295
Herencia de etiquetas en la API V1 de Amazon API Gateway ............................................ 1296
Restricciones de etiquetas y convenciones de uso ............................................................. 1297
Control de acceso basado en atributos .................................................................................... 1298
Limitar acciones en función de etiquetas de recursos ......................................................... 1298
Permitir acciones en función de las etiquetas de recursos .................................................. 1299
Denegar operaciones de etiquetado .................................................................................... 1300
Permitir operaciones de etiquetado ...................................................................................... 1301
Referencias de API ........................................................................................................................ 1303
Cuotas y notas importantes ........................................................................................................... 1304
Cuotas de nivel de cuenta de API Gateway, por región ........................................................... 1304
Cuotas de API HTTP ................................................................................................................. 1305
.............................................................................................................................................. 1305
Cuotas de API Gateway para configurar y ejecutar una API de WebSocket ............................ 1308
Cuotas de API Gateway para configurar y ejecutar una API REST ......................................... 1310
Cuotas de API Gateway para crear, implementar y administrar una API ................................. 1314
Notas importantes ...................................................................................................................... 1317
Notas importantes para las API de REST y WebSocket ..................................................... 1317
Notas importantes para las API WebSocket ........................................................................ 1318
Notas importantes para las API de REST ........................................................................... 1318
Historial de revisión ........................................................................................................................ 1325
Actualizaciones anteriores ......................................................................................................... 1338
Glosario de AWS ............................................................................................................................ 1349

ix
Amazon API Gateway Guía para desarrolladores

¿Qué es Amazon API Gateway?

Note
La experiencia de consola de API Gateway rediseñada ya está disponible. Para ver un
tutorial sobre cómo usar la consola para crear una API de REST, consulte Introducción a la
consola de la API de REST.

Amazon API Gateway es un servicio de AWS para la creación, la publicación, el mantenimiento,

el monitoreo y la protección de las API REST, HTTP y de WebSocket a cualquier escala. Los
desarrolladores de API pueden crear API que obtengan acceso a AWS o a otros servicios web, así
como los datos almacenados en la nube de AWS. Como desarrollador de API de API Gateway,
puede crear API para su uso en sus propias aplicaciones de cliente. También puede ofrecer sus API
a otros desarrolladores de aplicaciones externos. Para obtener más información, consulte the section
called “¿Quiénes utilizan API Gateway?”.

API Gateway crea API RESTful que:

• Se basan en HTTP.
• Habilitan la comunicación entre cliente y servidor sin estado.
• Implementan métodos HTTP estándar como, por ejemplo, GET, POST, PUT, PATCH y DELETE.

Para obtener más información acerca de las API REST de API Gateway y las API HTTP, consulte the
section called “Elección entre API de REST y API HTTP ”, Uso de API HTTP, the section called “Uso
de API Gateway para crear API REST” y the section called “Crear y configurar”.

API Gateway crea API de WebSocket que:

• Cumplen el protocolo WebSocket, que permite la comunicación entre el cliente y el servidor de

dúplex completo con estado.
• Dirigen mensajes entrantes en función del contenido de los mensajes.

Para obtener más información sobre las API de WebSocket de API Gateway, consulte the section
called “Uso de API Gateway para crear API de WebSocket” y the section called “Acerca de las API
de WebSocket”.

1
Amazon API Gateway Guía para desarrolladores

Temas
• Arquitectura de API Gateway
• Características de API Gateway
• Casos de uso de API Gateway
• Acceso a API Gateway
• Parte de la infraestructura sin servidor de AWS
• Cómo comenzar a usar Amazon API Gateway
• Conceptos de Amazon API Gateway
• Elección entre API de REST y API HTTP
• Introducción a la consola de la API de REST

Arquitectura de API Gateway

En el siguiente diagrama se muestra la arquitectura de API Gateway.

Este diagrama ilustra cómo las API que crea en Amazon API Gateway le proporcionan a usted o
a sus clientes desarrolladores una experiencia de desarrollador integrada y coherente para crear
aplicaciones sin servidor de AWS. API Gateway gestiona todas las tareas relacionadas con la
aceptación y el procesamiento de centenares de miles de llamadas simultáneas a la API. Estas
tareas incluyen la administración del tráfico, el control de la autorización y el acceso, el monitoreo y la
administración de versiones de la API.

Arquitectura de API Gateway 2

Amazon API Gateway Guía para desarrolladores

API Gateway actúa como una "puerta principal" para que las aplicaciones accedan a datos, lógica
empresarial o funcionalidad desde sus servicios de backend, como cargas de trabajo que se
ejecutan en Amazon Elastic Compute Cloud (Amazon EC2), código que se ejecuta en AWS Lambda,
cualquier aplicación web o aplicaciones de comunicación en tiempo real.

Características de API Gateway

Amazon API Gateway ofrece características como las siguientes:

• Compatibilidad con las API con estado (WebSocket) y las API (HTTP y REST).
• Mecanismos de autenticación eficaces y flexibles, como políticas de AWS Identity and Access
Management, funciones de autorizador de Lambda y grupos de usuarios de Amazon Cognito.
• Implementaciones de la versión Canary para el despliegue de cambios de forma segura.
• Registro de CloudTrail y monitoreo del uso y de los cambios en las API.
• Registro de acceso y registro de ejecución de CloudWatch, que incluye la posibilidad de establecer
alarmas. Para obtener más información, consulte the section called “Métricas de CloudWatch” y
the section called “Métricas”.
• Posibilidad de utilizar plantillas de AWS CloudFormation para habilitar la creación de las API. Para
obtener más información, consulte Referencia de tipos de recursos de Amazon API Gateway y
Referencia de tipos de recursos de Amazon API Gateway V2.
• Soporte para los nombres de dominio personalizados.
• Integración con AWS WAF para la protección de sus API frente a ataques web comunes.
• Integración con AWS X-Ray para comprender y cribar latencias de rendimiento.

Para obtener una lista completa de lanzamientos de características de API Gateway, consulte
Historial de revisión.

Casos de uso de API Gateway

Temas
• Uso de API Gateway para crear API REST
• Uso de API Gateway para crear API HTTP
• Uso de API Gateway para crear API de WebSocket

Características de API Gateway 3

Amazon API Gateway Guía para desarrolladores

• ¿Quiénes utilizan API Gateway?

Uso de API Gateway para crear API REST

Una API REST de API Gateway está formada por recursos y métodos. Un recurso es una entidad
lógica a la que una aplicación puede acceder a través de una ruta de recursos. Un método se
corresponde con una solicitud de la API de REST enviada por el usuario de la API y la respuesta
devuelta al usuario.

Por ejemplo, /incomes podría ser la ruta de un recurso que representa los ingresos del usuario de
la aplicación. Un recurso puede tener una o varias operaciones, las cuales definen los verbos HTTP
correspondientes, por ejemplo, GET, POST PUT, PATCH y DELETE. Una combinación de una ruta
de recurso y una operación identifica un método de la API. Por ejemplo, un método POST /incomes
podría añadir una ganancia devengada por el intermediario y un método GET /expenses podría
consultar los gastos en los que ha incurrido el intermediario.

La aplicación no necesita saber dónde se almacenan y de dónde se obtienen los datos solicitados
en el backend. En las API REST de API Gateway, el frontend se encapsula mediante solicitudes de
métodos y respuestas de métodos. La API se conecta con el backend por medio de solicitudes de
integración y respuestas de integración.

Por ejemplo, con DynamoDB como backend, el desarrollador de la API configura la solicitud de
integración para reenviar la solicitud del método de entrada al backend elegido. La configuración
incluye las especificaciones de acción de DynamoDB adecuadas y los roles y políticas de IAM
necesarios, así como la transformación de los datos de entrada correcta. El backend devuelve el
resultado a API Gateway como una respuesta de integración.

Para dirigir la respuesta de integración a una respuesta de método adecuada (de un determinado
código de estado HTTP) al cliente, puede configurar la respuesta de integración para que mapee
los parámetros de respuesta necesarios desde la integración del método. A continuación, si fuera
necesario, convierta el formato de los datos de salida del backend al del frontend. API Gateway le
permite definir un esquema o modelo de carga para facilitar la configuración de la plantilla de mapeo
de cuerpo.

API Gateway proporciona funcionalidad de administración de la API REST, como a siguiente:

• Soporte para generar SDK y crear la documentación de API mediante extensiones de OpenAPI de
API Gateway

Uso de API Gateway para crear API REST 4

Amazon API Gateway Guía para desarrolladores

• Limitación controlada de solicitudes HTTP

Uso de API Gateway para crear API HTTP

Las API HTTP le permiten crear API de RESTful con menor latencia y menor costo que las API de
REST.

Puede utilizar las API HTTP para enviar solicitudes a funciones de AWS Lambda o a cualquier punto
de enlace HTTP públicamente direccionable.

Por ejemplo, puede crear una API HTTP que se integre con una función de Lambda en el backend.
Cuando un cliente llama a la API, API Gateway envía la solicitud a la función de Lambda y devuelve
la respuesta de la función al cliente.

Las API HTTP son compatibles con la autorización de OpenID Connect y OAuth 2.0. Vienen con
soporte integrado para el uso compartido de recursos entre orígenes (CORS) y las implementaciones
automáticas.

Para obtener más información, consulte the section called “Elección entre API de REST y API HTTP
”.

Uso de API Gateway para crear API de WebSocket

En una API de WebSocket, el cliente y el servidor pueden enviarse mensajes entre sí en cualquier
momento. Los servidores de backend pueden enviar fácilmente datos a los usuarios y dispositivos
conectados, lo que evita la necesidad de implementar complejos mecanismos de sondeo.

Por ejemplo, podría crear una aplicación sin servidor mediante una API de WebSocket de API
Gateway y AWS Lambda para enviar y recibir mensajes entre usuarios individuales o grupos de
usuarios de una sala de conversación. También puede invocar servicios de backend como por
ejemplo AWS Lambda, Amazon Kinesis o un punto de enlace HTTP en función del contenido de los
mensajes.

Puede utilizar la API de WebSocket de API Gateway para crear aplicaciones seguras de
comunicación en tiempo real sin tener que aprovisionar ni administrar servidores para administrar
las conexiones o los intercambios de datos a gran escala. Los casos de uso focalizados incluyen
aplicaciones en tiempo real, como la siguiente:

• Aplicaciones de chat

Uso de API Gateway para crear API HTTP 5

Amazon API Gateway Guía para desarrolladores

• Paneles en tiempo real como los de cotizaciones bursátiles

• Alertas y notificaciones en tiempo real

API Gateway proporciona funcionalidad de administración de la API de WebSocket, como la

siguiente:

• Monitoreo y limitación controlada de las conexiones y los mensajes

• Uso de AWS X-Ray para rastrear los mensajes que se transfieren a través de las API a los
servicios de backend
• Integración sencilla con puntos de enlace HTTP/HTTPS

¿Quiénes utilizan API Gateway?

Existen dos tipos de desarrolladores que utilizan API Gateway: los desarrolladores de API y los
desarrolladores de aplicaciones.

Un desarrollador de API crea e implementa una API para habilitar la funcionalidad necesaria en API
Gateway. El desarrollador de API debe ser un usuario en la cuenta de AWS que posee la API.

Un desarrollador de aplicaciones diseña una aplicación funcional que llama a los servicios de AWS
mediante la invocación de una API de WebSocket o REST creada por un desarrollador de API en
API Gateway.

El desarrollador de aplicaciones es el cliente del desarrollador de API. El desarrollador de

aplicaciones no necesita tener una cuenta de AWS, siempre que la API no requiera permisos de
IAM, o bien admita la autorización de usuarios a través proveedores de identidad federada de
terceros admitidos por la Federación de identidades de grupos de usuarios de Amazon Cognito. Los
proveedores de identidad incluyen a Amazon, el grupo de usuarios de Amazon Cognito, Facebook y
Google.

Creación y administración de una API de API Gateway

Para crear, configurar e implementar una API, un desarrollador de API trabaja con el componente del
servicio de API Gateway para administración de la API, denominado apigateway.

Como desarrollador de API, puede crear y administrar una API mediante la consola de API Gateway
tal y como se describe en Introducción a la API de API Gateway o llamando a la Referencias de API.

¿Quiénes utilizan API Gateway? 6

Amazon API Gateway Guía para desarrolladores

Existen varias maneras de llamar a esta API. Incluyen el uso de AWS Command Line Interface (AWS
CLI), o mediante un SDK de AWS. Además, puede habilitar la creación de la API con Plantillas de
AWS CloudFormation o, en el caso de las API REST y HTTP, con Trabajar con extensiones de API
Gateway para OpenAPI.

Para obtener una lista de las regiones en las que API Gateway está disponible, así como los puntos
de enlace del servicio de control asociados, consulte Cuotas y puntos de enlace de Amazon API
Gateway.

Llamadas a un API de API Gateway

Un desarrollador de aplicaciones trabaja con el componente de servicio de API Gateway para

ejecución de la API, denominado execute-api, para invocar una API que se ha creado o
implementado en API Gateway. La API creada expone las entidades de programación subyacentes.
Existen varias maneras de llamar a dicha API. Para obtener más información, consulte Invocación de
una API REST en Amazon API Gateway y Invocación de una API de WebSocket.

Acceso a API Gateway

Puede obtener acceso a Amazon API Gateway de las siguientes formas:

• AWS Management Console: la AWS Management Console proporciona una interfaz web que
permite crear y administrar las API. Una vez completados los pasos que se indican en Requisitos
previos, puede acceder a la consola de API Gateway en https://console.aws.amazon.com/
apigateway.
• AWS SDK: si utiliza un lenguaje de programación para el que AWS proporciona un SDK, puede
usar un SDK para obtener acceso a API Gateway. Los SDK simplifican la autenticación, se
integran fácilmente con su entorno de desarrollo y proporcionan acceso a los comandos de API
Gateway. Para obtener más información, consulte Herramientas para Amazon Web Services.
• API de API Gateway V1 y V2: si utiliza un lenguaje de programación para el que no haya un SDK
disponible, consulte la Referencia de la API de Amazon API Gateway versión 1 y la Referencia de
la API de Amazon API Gateway versión 2.
• AWS Command Line Interface: para obtener más información, consulte Configuración inicial de la
AWS Command Line Interface en la Guía del usuario de AWS Command Line Interface.
• AWS Tools for Windows PowerShell: para obtener más información, consulte Configuración
de AWS Tools for Windows PowerShell en la Guía del usuario de AWS Tools for Windows
PowerShell.

Acceso a API Gateway 7

Amazon API Gateway Guía para desarrolladores

Parte de la infraestructura sin servidor de AWS

Junto con AWS Lambda, API Gateway es la parte de la infraestructura sin servidor de AWS orientada
a la aplicación. Para obtener más información sobre cómo empezar a usar la tecnología sin servidor,
consulte Guía para desarrolladores de tecnología sin servidor.

Para que una aplicación llame a los servicios de AWS disponibles públicamente, puede utilizar
Lambda para interactuar con los servicios necesarios y exponer las funciones de Lambda a través
de los métodos de API de API Gateway. AWS Lambda ejecuta el código en una infraestructura
informática de alta disponibilidad. Realiza todos los procesos de ejecución y administración que
necesitan los recursos informáticos. Para habilitar las aplicaciones sin servidor, API Gateway es
compatible con las integraciones de proxy optimizadas con puntos de enlace de AWS Lambda y
HTTP.

Cómo comenzar a usar Amazon API Gateway

Para obtener una introducción a Amazon API Gateway, consulte lo siguiente:

• Introducción, que proporciona una explicación para crear una API HTTP.

• Serverless land, que proporciona videos instructivos.

• Happy Little API Shorts, que es una serie de breves vídeos instructivos.

Conceptos de Amazon API Gateway

API Gateway

API Gateway es un servicio de AWS que admite lo siguiente:

• Crear, implementar y administrar una interfaz de programación de aplicaciones (API) RESTful

para exponer los puntos de enlace HTTP del backend, funciones de AWS Lambda u otros
servicios de AWS.

• Crear, implementar y administrar una API de WebSocket para exponer funciones de AWS
Lambda u otros servicios de AWS.

• Invocar los métodos de API expuestos a través de los puntos de enlace HTTP y WebSocket del
frontend.

Parte de la infraestructura sin servidor de AWS 8

Amazon API Gateway Guía para desarrolladores

API REST de API Gateway

Una colección de recursos y métodos HTTP que se integran con puntos de enlace HTTP de
backend, funciones de Lambda u otros servicios de AWS. Puede implementar esta colección
en una o más etapas. Normalmente, los recursos de la API están organizados en un árbol de
recursos de acuerdo con la lógica de la aplicación. Cada recurso de la API puede exponer uno
o varios métodos de la API que tienen verbos HTTP únicos admitidos por API Gateway. Para
obtener más información, consulte the section called “Elección entre API de REST y API HTTP ”.
API HTTP de API Gateway

Colección de rutas y métodos integrados con los puntos de enlace HTTP de backend o funciones
de Lambda. Puede implementar esta colección en una o más etapas. Cada ruta puede exponer
uno o varios métodos de la API que tienen verbos HTTP únicos admitidos por API Gateway. Para
obtener más información, consulte the section called “Elección entre API de REST y API HTTP ”.
API de WebSocket de API Gateway

Una colección de rutas y claves de ruta de WebSocket que se integran en puntos de enlace
HTTP de backend, funciones de Lambda u otros servicios de AWS. Puede implementar esta
colección en una o más etapas. Los métodos de la API se invocan a través de conexiones
WebSocket del frontend que se pueden asociar a un nombre de dominio personalizado
registrado.
Implementación de API

Una instantánea de un momento dado de la API de API Gateway. Para que los clientes puedan
utilizar la implementación, esta debe asociarse a una o más etapas de API.
Desarrollador de la API

Su cuenta de AWS que es propietaria de una implementación de API Gateway (por ejemplo, un
proveedor de servicios que también admite el acceso mediante programación).
Punto de enlace de la API

Un nombre de host para una API de API Gateway que se implementa en una región específica.
El nombre de host tiene el formato {api-id}.execute-api.{region}.amazonaws.com. Se
admiten los siguientes tipos de puntos de enlace de API:
• Punto de enlace de API optimizada para límites
• Punto de enlace de API privada
• Punto de enlace de API regional

Conceptos de API Gateway 9

Amazon API Gateway Guía para desarrolladores

Clave de API

Cadena alfanumérica que API Gateway utiliza para identificar a un desarrollador de aplicaciones
que utiliza su API REST o de WebSocket. API Gateway puede generar claves de API en su
nombre o usted puede importarlas desde un archivo CSV. Puede utilizar claves de API junto con
autorizadores de Lambda o planes de uso para controlar el acceso a sus API.

Consulte los puntos de enlace de API.

Propietario de API

Consulte Desarrollador de la API.

Etapa de API

Una referencia lógica a un estado del ciclo de vida de la API (por ejemplo, 'dev', 'prod', 'beta', 'v2').
Las etapas de API se identifican por un ID y un nombre de etapa de API.
Desarrolladores de aplicaciones

Un creador de aplicaciones que puede tener o no una cuenta de AWS y que interactúa con la API
que usted, el desarrollador de API, ha implementado. Los desarrolladores de aplicaciones son
sus clientes. Un desarrollador de aplicaciones suele identificarse por una clave de API.
URL de devolución de llamada

Cuando un cliente nuevo se conecta a través de una conexión WebSocket, se puede llamar a una
integración en API Gateway para almacenar la URL de devolución de llamada del cliente. Esa
URL de devolución de llamada se puede utilizar para enviar mensajes al cliente desde el sistema
backend.
Portal para desarrolladores

Una aplicación que permite a los clientes registrarse, encontrar y suscribirse a los productos de
API (planes de uso de API Gateway) ofrecidos por usted, administrar sus claves de API y ver sus
métricas de uso para las API.
Punto de enlace de API optimizada para límites

El nombre de host predeterminado de una API de API Gateway implementada en la región

especificada, mientras se utiliza una distribución de CloudFront para facilitar el acceso de los
clientes, normalmente, desde otras regiones de AWS. Las solicitudes de API se dirigen al punto
de presencia de CloudFront más cercano, que normalmente mejora el tiempo de conexión para
clientes en distintas ubicaciones geográficas.

Conceptos de API Gateway 10

Amazon API Gateway Guía para desarrolladores

Consulte los puntos de enlace de API.

Solicitud de integración

La interfaz interna de una ruta de API de WebSocket o un método de API REST en API Gateway,
en la que se asignará el cuerpo de una solicitud de ruta o los parámetros y el cuerpo de una
solicitud de método a los formatos requeridos por el backend.
Respuesta de integración

La interfaz interna de una ruta de API de WebSocket o un método de API REST en API Gateway,
en la que se asignarán los códigos de estado, los encabezados y la carga que se reciben del
backend al formato de respuesta que se devuelve a una aplicación cliente.
Plantilla de asignación

Un script escrito en Velocity Template Language (VTL), que transforma un cuerpo de la solicitud
del formato de datos del frontend al formato de datos del backend o viceversa (en el caso del
cuerpo de la respuesta). Las plantillas de asignación se pueden especificar en la solicitud de
integración o en la respuesta de integración. Pueden hacer referencia a datos disponibles en
tiempo de ejecución como contexto y variables de etapa.

La asignación puede ser tan sencilla como una transformación de identidad que transfiere los
encabezados o el cuerpo a través de la integración tal cual desde el cliente al backend para una
solicitud. Lo mismo sucede con la respuesta, en la que la carga se transmite desde el backend al
cliente.
Solicitud de método

La interfaz pública de un método de una API de API Gateway que define los parámetros y el
cuerpo que un desarrollador de aplicaciones debe enviar en las solicitudes para acceder al
backend a través de la API.
Respuesta de método

La interfaz pública de una API de REST que define los códigos de estado, los encabezados y los
modelos de cuerpo que un desarrollador de aplicaciones debería esperar en las respuestas de la
API.
Integración simulada

En una integración simulada, las respuestas de la API se generan directamente a partir de API
Gateway, sin necesidad de un backend de integración. Como desarrollador de una API, puede
decidir cómo API Gateway responde a una solicitud de integración simulada. Para ello, configura

Conceptos de API Gateway 11

Amazon API Gateway Guía para desarrolladores

la solicitud de integración y la respuesta de integración del método para asociar una respuesta a
un código de estado determinado.
Modelo

Un esquema de datos que especifica la estructura de datos de una solicitud o carga de respuesta.
Es necesario un modelo para generar un SDK con establecimiento inflexible de tipos de una
API. También se utiliza para validar cargas. Un modelo es cómodo para generar una plantilla
de asignación de muestra para iniciar la creación de una plantilla de asignación de producción.
Aunque es útil, no se requiere para crear una plantilla de asignación.
API privado

Consulte Punto de enlace de API privada

Punto de enlace de API privada

Un punto de enlace de API que se expone a través de puntos de enlace de la VPC de tipo interfaz
y permite que un cliente obtenga acceso seguro a los recursos de una API privada dentro de
una VPC. Las API privadas están aisladas de la red pública de Internet y solo se puede obtener
acceso a ellas a través de los puntos de enlace de la VPC de API Gateway a los que se les ha
concedido acceso.
Integración privada

Tipo de integración de API Gateway que permite que un cliente tenga acceso a los recursos que
se encuentran en la VPC de un usuario a través de un punto de enlace de una API REST privada
sin exponerlos a la red pública de Internet.
Integración de proxy

Una configuración simplificada de integración de API Gateway. Puede configurar una integración
de proxy como una integración de proxy HTTP o como una integración de proxy de Lambda.

En el caso de la integración de proxy HTTP, API Gateway transmite toda la solicitud y la

respuesta entre el frontend y un backend HTTP. Para la integración de proxy Lambda, API
Gateway envía toda la solicitud como entrada a una función de Lambda de backend. A
continuación, API Gateway transforma el resultado de la función de Lambda en una respuesta
HTTP del frontend.

En las API de REST, la integración de proxy se utiliza normalmente con un recurso de proxy, que
se representa mediante una variable de ruta expansiva (por ejemplo, {proxy+}) combinada con
un método catch-all ANY.

Conceptos de API Gateway 12

Amazon API Gateway Guía para desarrolladores

Creación rápida

Puede utilizar la creación rápida para simplificar la creación de una API HTTP. La creación
rápida crea una API con una integración de Lambda o HTTP, una ruta de método catch-all
predeterminada y una etapa predeterminada configurada para implementar automáticamente
los cambios. Para obtener más información, consulte the section called “Crear una API HTTP
mediante la AWS CLI”.
Punto de enlace de API regional

El nombre de host de una API implementada en la región especificada y pensada para prestar
servicio a clientes, como, por ejemplo, instancias EC2, de la misma región de AWS. Las
solicitudes de API se dirigen directamente a la API de API Gateway específica de la región
sin pasar por ninguna distribución de CloudFront. Para las solicitudes destinadas a la misma
región, existe un punto de enlace regional que evita el trayecto innecesario de ida y vuelta a una
distribución de CloudFront.

Además, puede aplicar el direccionamiento basado en latencia a los puntos de enlace regionales
para implementar una API en varias regiones con la misma configuración de punto de enlace de
API regional, establecer el mismo nombre de dominio personalizado para cada API implementada
y configurar registros de DNS basados en latencia en Route 53 para dirigir las solicitudes de los
clientes a la región que tiene la mínima latencia.

Consulte los puntos de enlace de API.

Ruta

Se utiliza una ruta de WebSocket en API Gateway para dirigir los mensajes entrantes a una
integración específica, como una función de AWS Lambda, según el contenido de los mensajes.
Al definir la API de WebSocket, se especifica un clave de ruta y un backend de integración. La
clave de ruta es un atributo del cuerpo del mensaje. Cuando se encuentra una coincidencia para
la clave de ruta en un mensaje entrante, se invoca el backend de integración.

También se puede establecer una ruta predeterminada para las claves de ruta no coincidentes
o para especificar un modelo de proxy que transfiera el mensaje tal cual a los componentes del
backend que realizan el direccionamiento y procesan la solicitud.
Solicitud de ruta

La interfaz pública de un método de API de WebSocket en API Gateway que define el cuerpo que
un desarrollador de aplicaciones debe enviar en las solicitudes para obtener acceso al backend a
través de la API.

Conceptos de API Gateway 13

Amazon API Gateway Guía para desarrolladores

Respuesta de ruta

La interfaz pública de una API de WebSocket que define los códigos de estado, los encabezados
y los modelos de cuerpo que un desarrollador de aplicaciones debería esperar de API Gateway.
Plan de uso

Un plan de uso ofrece a determinados clientes de la API acceso a una o varias API de
WebSocket o de REST implementadas. Puede utilizar un plan de uso para configurar la limitación
controlada y los límites de cuota que se ejecutarán en claves de API de cliente individual.
Conexión WebSocket

API Gateway mantiene una conexión persistente entre los clientes y API Gateway. No hay
conexión persistente entre API Gateway y las integraciones de backend, como las funciones de
Lambda. Los servicios de backend se invocan según sea necesario, en función del contenido de
los mensajes recibidos de los clientes.

Elección entre API de REST y API HTTP

Las API de REST y las API HTTP son productos API de RESTful. Las API de REST admiten más
funciones que las API HTTP, mientras que las API HTTP están diseñadas con características
mínimas para que puedan ofrecerse a un precio más bajo. Elija las API de REST si necesita
características como claves de API, limitación por cliente, validación de solicitudes, integración de
AWS WAF o puntos de conexión de API privados. Elija las API de HTTP si no necesita las funciones
incluidas con las API de REST.

En las siguientes secciones se resumen las características principales disponibles en las API de
REST y las API HTTP.

Tipo de punto de conexión

El tipo de punto de conexión hace referencia al punto de conexión que API Gateway crea para su
API. Para obtener más información, consulte the section called “Elección de un tipo de punto de
enlace de API” .

Tipo de punto de enlace API REST API HTTP

Optimizada para la periferia ✓

Elección entre API de REST y API HTTP 14

Amazon API Gateway Guía para desarrolladores

Tipo de punto de enlace API REST API HTTP

Regional ✓ ✓

Private ✓

Seguridad
API Gateway proporciona una serie de formas de proteger su API de ciertas amenazas, como
actores malintencionados o picos de tráfico. Para obtener más información, consulte the section
called “Proteger” y the section called “Proteger”.

Características de seguridad API REST API HTTP

Autenticación TLS mutua ✓ ✓

Certificados para autentica ✓

ción de backend

AWS WAF ✓

Autorización
API Gateway admite varios mecanismos para controlar y administrar el acceso a la API. Para obtener
más información, consulte the section called “Control de acceso” y the section called “Control de
acceso”.

Opciones de autorización API REST API HTTP

IAM ✓ ✓

Políticas de recursos ✓

1
Amazon Cognito ✓ ✓

Autorización personalizada ✓ ✓
con una función AWS Lambda

Seguridad 15
Amazon API Gateway Guía para desarrolladores

Opciones de autorización API REST API HTTP

2
Token web JSON (JWT) ✓

1
Puede utilizar Amazon Cognito con un autorizador de JWT.
2
Puede utilizar un autorizador de Lambda para validar JWT para las API de REST.

Administración de API
Elija las API de REST si necesita capacidades de administración de API, como claves de API
y limitación de velocidad por cliente. Para obtener más información, consulte the section called
“Distribuir”, the section called “Nombres de dominio personalizados” y the section called “Nombres de
dominio personalizados”.

Características API REST API HTTP

Dominios personalizados ✓ ✓

Claves de API ✓

Limitación de velocidad por ✓

cliente

Limitación de uso por cliente ✓

Desarrollo
A medida que se desarrolla la API de API Gateway, se decide sobre una serie de características de
la API. Estas características dependen del uso de la API. Para obtener más información, consulte the
section called “Desarrollo” y the section called “Desarrollo”.

Características API REST API HTTP

Configuración de CORS ✓ ✓

Invocaciones de prueba ✓

Administración de API 16
Amazon API Gateway Guía para desarrolladores

Características API REST API HTTP

Almacenamiento en caché ✓

Implementaciones controladas ✓ ✓
por el usuario

Implementaciones automátic ✓
as

Respuestas de gateway ✓
personalizadas

Implementación de la versión ✓
de valor controlado

Validación de solicitudes ✓

Transformación de los ✓ ✓
parámetros de solicitud

Transformación del cuerpo de ✓

la solicitud

Supervisión

API Gateway admite varias opciones para registrar solicitudes de API y supervisar las API. Para
obtener más información, consulte the section called “Monitoreo” y the section called “Monitoreo”.

Característica API REST API HTTP

Métricas de Amazon ✓ ✓
CloudWatch

Registros de acceso a ✓ ✓
Amazon CloudWatch Logs

Supervisión 17
Amazon API Gateway Guía para desarrolladores

Característica API REST API HTTP

Registros de acceso a ✓
Amazon Kinesis Data
Firehose

Registros de ejecución ✓

Rastreo de AWS X-Ray ✓

Integraciones

Las integraciones conectan la API de API Gateway a los recursos de backend. Para obtener más
información, consulte the section called “Integraciones” y the section called “Integraciones”.

Característica API REST API HTTP

Puntos de conexión HTTP ✓ ✓

públicos

Servicios de AWS ✓ ✓

Funciones de AWS Lambda ✓ ✓

Integraciones privadas con ✓ ✓

equilibradores de carga de red

Integraciones privadas con ✓

equilibradores de carga de
aplicaciones

Integraciones privadas con ✓

AWS Cloud Map

Integraciones simuladas ✓

Integraciones 18
Amazon API Gateway Guía para desarrolladores

Introducción a la consola de la API de REST

En este ejercicio de introducción, debe crear una API de REST sin servidor con la consola de API
de REST de API Gateway. Las API sin servidor permiten centrarse en las aplicaciones, en lugar de
dedicar el tiempo a aprovisionar y administrar servidores. Se debe completar este ejercicio en menos
de 20 minutos y se debe realizar dentro del nivel gratuito de AWS.

En primer lugar, crea una función de Lambda con la consola de Lambda. A continuación, debe crear
una API de REST mediante la consola de API de REST de la API Gateway. A continuación, se crea
un método de API y se integra con una función de Lambda mediante una integración de proxy de
Lambda. Por último, debe implementar e invocar la API.

Cuando invoca la API de REST, API Gateway enruta la solicitud a la función de Lambda. Lambda
ejecuta la función y devuelve una respuesta a API Gateway. API Gateway, a continuación, le
devuelve una respuesta.

Para completar este ejercicio, necesita una Cuenta de AWS y un usuario de AWS Identity and
Access Management (IAM) con acceso a la consola. Para obtener más información, consulte
Requisitos previos para comenzar con API Gateway.

Temas

• Paso 1: Crear una función Lambda

• Paso 2: Crear una API de REST

• Paso 3: Crear una integración de proxy de Lambda

• Paso 4: Implementar la API

• Paso 5: Invocar la API

• (Opcional) Paso 6: limpiar

Introducción a la consola de la API de REST 19

Amazon API Gateway Guía para desarrolladores

Paso 1: Crear una función Lambda

Usa una función de Lambda para el backend de su API. Lambda ejecuta su código solo cuando es
necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por
segundo.

Para este ejercicio, debe usar la función Node.js predeterminada en la consola de Lambda.

Para crear una función Lambda

1. Inicie sesión en la consola de Lambda en https://console.aws.amazon.com/lambda/.

2. Elija Create function (Crear función).
3. En Basic information (Información básica), para Function name (Nombre de función), escriba
my-function.
4. Elija Crear función.

El código predeterminado de la función de Lambda debe ser similar al siguiente:

export const handler = async (event) => {

const response = {
statusCode: 200,
body: JSON.stringify('The API Gateway REST API console is great!'),
};
return response;
};

Puede modificar la función de Lambda para este ejercicio, siempre y cuando la respuesta de la
función se alinee con el formato que requiere API Gateway.

Sustituya el cuerpo de respuesta predeterminado (Hello from Lambda!) por The API Gateway
REST API console is great!. Al invocar la función de ejemplo, devuelve una respuesta 200 a
los clientes, junto con la respuesta actualizada.

Paso 2: Crear una API de REST

A continuación, debe crear una API de REST con un recurso raíz (/).

Para crear una API de REST

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

Paso 1: Crear una función Lambda 20

Amazon API Gateway Guía para desarrolladores

2. Haga una de las siguientes acciones:

• Para crear la primera API, para API de REST, elija Crear.
• Si ha creado una API antes, elija Crear API y, a continuación, elija Crear para API de REST.
3. En API name (Nombre de la API), escribamy-rest-api.
4. (Opcional) En Description (Descripción), introduzca una descripción.
5. Mantenga Tipo de punto de conexión de la API establecido en Regional.
6. Seleccione Create API (Crear API).

Paso 3: Crear una integración de proxy de Lambda

A continuación, debe crear un método de API para la API de REST en el recurso raíz (/) e integrar
el método con la función de Lambda mediante una integración de proxy. En una integración de proxy
de Lambda, API Gateway pasa la solicitud entrante del cliente directamente a la función de Lambda.

Para crear una integración de proxy de Lambda

1. Seleccione el recurso / y, a continuación, elija Crear método.

2. En Tipo de método, seleccione ANY.
3. En Tipo de integración, seleccione Lambda.
4. Active Integración de proxy de Lambda.
5. En Función de Lambda, ingrese my-function y, continuación, seleccione la función de
Lambda.
6. Elija Crear método.

Paso 4: Implementar la API

Después, debe crear una implementación de la API y asociarla con una etapa.

Para implementar su API

1. Elija Deploy API (Implementar API).

2. En Etapa, seleccione Nueva etapa.
3. En Stage name (Nombre de etapa), escriba Prod.
4. (Opcional) En Description (Descripción), introduzca una descripción.

Paso 3: Crear una integración de proxy de Lambda 21

Amazon API Gateway Guía para desarrolladores

5. Elija Deploy (Implementar).

Ahora los clientes pueden llamar a la API. Para probar la API antes de implementarla, puede elegir,
si lo desea, el método ANY, ir a la pestaña Probar y, a continuación, elegir Probar.

Paso 5: Invocar la API

Para invocar la API

1. En el panel de navegación principal, elija Etapa.

2. En Detalles de la etapa, elija el icono de copia para copiar la URL de invocación de la API.

3. Ingrese la URL de invocación en un navegador web.

La URL completa debería ser https://abcdef123.execute-api.us-

east-2.amazonaws.com/Prod.

Su navegador envía una GET solicitud a la API.

4. Verifique la respuesta de la API. Debería ver el texto "The API Gateway REST API
console is great!" en el navegador.

Paso 5: Invocar la API 22

Amazon API Gateway Guía para desarrolladores

(Opcional) Paso 6: limpiar

Para evitar acumular costos innecesarios en la Cuenta de AWS, elimine los recursos creados como
parte de este ejercicio. Los siguientes pasos eliminan la API de REST, la función de Lambda y los
recursos asociados.

Para eliminar la API de REST

1. En el panel Recursos, elija Acciones de la API y Eliminar API.

2. En el cuadro de diálogo Eliminar API, escriba confirmar y después elija Eliminar.

Para eliminar la función de Lambda

1. Inicie sesión en la consola de Lambda en https://console.aws.amazon.com/lambda/.

2. En la página Funciones, seleccione la función. Elija Actions (Acciones), Delete (Eliminar).

3. En el cuadro de diálogo Eliminar 1 función, escriba delete y, a continuación, elija Eliminar.

Para eliminar el grupo de registro de la función de Lambda

1. Abra la página Log grouls (Grupos de registro) de la consola Amazon CloudWatch.

2. En la página Grupos de registro, seleccione el grupo de registro de la función (/aws/lambda/

my-function). A continuación, en Acciones, elija Eliminar grupos de registros.

3. En el cuadro de diálogo Delete log group(s), Eliminar grupo(s) de registro(s) elija Delete
(Eliminar).

Para eliminar el rol de ejecución de una función de Lambda

1. Abra la página Roles en la consola de IAM.

2. (Opcional) En la página Roles, en el cuadro de búsqueda, ingrese my-function.

3. Seleccione el rol de la función (por ejemplo, my-function-31exxmpl) y, a continuación, elija

Eliminar.

4. En el cuadro de diálogo ¿Eliminar my-function-31exxmpl?, escriba el nombre del rol y, a

continuación, elija Eliminar.

(Opcional) Paso 6: limpiar 23

Amazon API Gateway Guía para desarrolladores

Tip
Puede automatizar la creación y la limpieza de los recursos de AWS mediante el uso de
AWS CloudFormation o AWS Serverless Application Model (AWS SAM). Para ver algunas
plantillas de ejemplo de AWS CloudFormation, consulte las plantillas de ejemplo de API
Gateway en el repositorio GitHub de awsdocs.

(Opcional) Paso 6: limpiar 24

Amazon API Gateway Guía para desarrolladores

Requisitos previos para comenzar con API Gateway

Antes de usar Amazon API Gateway por primera vez, complete las siguientes tareas.

Registro para obtener una Cuenta de AWS

Si no dispone de una Cuenta de AWS, siga estos pasos para crear una.

Cómo registrarse en una Cuenta de AWS

1. Abra https://portal.aws.amazon.com/billing/signup.
2. Siga las instrucciones que se le indiquen.

Parte del procedimiento de registro consiste en recibir una llamada telefónica e indicar un código
de verificación en el teclado del teléfono.

Al registrarse en una Cuenta de AWS, se crea un Usuario raíz de la cuenta de AWS. El usuario
raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica
recomendada de seguridad, asigne acceso administrativo a un usuario administrativo y utilice
únicamente el usuario raíz para realizar tareas que requieran acceso de usuario raíz.

AWS le enviará un correo electrónico de confirmación luego de completar el proceso de registro.

Puede ver la actividad de la cuenta y administrar la cuenta en cualquier momento entrando en https://
aws.amazon.com/ y seleccionando Mi cuenta.

Crear un usuario administrativo

Después de registrarse para obtener una Cuenta de AWS, proteja su Usuario raíz de la cuenta de
AWS, habilite AWS IAM Identity Center y cree un usuario administrativo para no utilizar el usuario
raíz en las tareas cotidianas.

Protección de su Usuario raíz de la cuenta de AWS

1. Inicie sesión en la AWS Management Console como propietario de cuenta, elija Usuario raíz e
ingrese el email de su Cuenta de AWS. En la siguiente página, escriba su contraseña.

Para obtener ayuda para iniciar sesión con el usuario raíz, consulte Iniciar sesión como usuario
raíz en la Guía del usuario de AWS Sign-In.

Registro para obtener una Cuenta de AWS 25

Amazon API Gateway Guía para desarrolladores

2. Active la autenticación multifactor (MFA) para el usuario raíz.

Para obtener instrucciones, consulte Habilitar un dispositivo MFA virtual para el usuario raíz de
la Cuenta de AWS (consola) en la Guía del usuario de IAM.

Creación de un usuario administrativo

1. Activar IAM Identity Center

Para ver las instrucciones, consulte Enabling AWS IAM Identity Center en la Guía del usuario de
AWS IAM Identity Center.
2. En IAM Identity Center, conceda acceso administrativo a un usuario administrativo.

Para ver un tutorial sobre el uso del Directorio de IAM Identity Center como origen de
identidades, consulte Configure user access with the default Directorio de IAM Identity Center en
la Guía del usuario de AWS IAM Identity Center.

Cómo iniciar sesión como usuario administrativo

• Para iniciar sesión con el usuario del IAM Identity Center, utilice la URL de inicio de sesión que
se envió a la dirección de correo electrónico cuando creó el usuario del IAM Identity Center.

Para obtener ayuda para iniciar sesión con un usuario del IAM Identity Center, consulte Iniciar
sesión en el portal de acceso de AWS en la Guía del Usuario de AWS Sign-In.

Crear un usuario administrativo 26

Amazon API Gateway Guía para desarrolladores

Introducción a la API de API Gateway

Note
La experiencia de consola de API Gateway rediseñada ya está disponible. Para ver un
tutorial sobre cómo usar la consola para crear una API de REST, consulte Introducción a la
consola de la API de REST.

En este ejercicio introductorio, creará una API sin servidor. Las API sin servidor permiten centrarse
en las aplicaciones, en lugar de dedicar tiempo a aprovisionar y administrar servidores. Puede
completar este ejercicio en menos de 20 minutos y realizarlo dentro del nivel gratuito de AWS.

En primer lugar, crea una función de Lambda con la consola de AWS Lambda. A continuación, crea
una API HTTP mediante la consola de API Gateway. Luego, invoca su API.

Note
En este ejercicio se utiliza una API HTTP para simplificar. API Gateway también es
compatible con las API de REST, que incluyen más funciones. Para obtener más
información, consulte the section called “Elección entre API de REST y API HTTP ”.

Cuando invoca su API HTTP, API Gateway enruta la solicitud a su función de Lambda. Lambda
ejecuta la función de Lambda y devuelve una respuesta a API Gateway. API Gateway, a
continuación, le devuelve una respuesta.

Para completar este ejercicio, necesita una cuenta de AWS y un usuario de AWS Identity and Access
Management con acceso a la consola. Para obtener más información, consulte Requisitos previos.

Temas

27
Amazon API Gateway Guía para desarrolladores

• Paso 1: Crear una función Lambda

• Paso 2: crear una API HTTP

• Paso 3: probar la API

• (Opcional) Paso 4: limpiar

• Pasos siguientes

Paso 1: Crear una función Lambda

Usa una función de Lambda para el backend de su API. Lambda ejecuta su código solo cuando es
necesario y escala de manera automática, desde unas pocas solicitudes por día hasta miles por
segundo.

Para este ejemplo, utilice la función Node.js predeterminada de la consola de Lambda.

Para crear una función Lambda, realice el siguiente procedimiento:

1. Inicie sesión en la consola de Lambda en https://console.aws.amazon.com/lambda/.

2. Elija Create function (Crear función).

3. En Function name (Nombre de función), introduzca my-function.

4. Elija Create function (Crear función).

La función de ejemplo devuelve una 200 respuesta a los clientes y el texto Hello from Lambda!.

Puede modificar su función de Lambda, siempre y cuando la respuesta de la función se alinea con el
formato que requiere API Gateway.

El código predeterminado de la función de Lambda debe ser similar al siguiente:

export const handler = async (event) => {

const response = {
statusCode: 200,
body: JSON.stringify('Hello from Lambda!'),
};
return response;
};

Paso 1: Crear una función Lambda 28

Amazon API Gateway Guía para desarrolladores

Paso 2: crear una API HTTP

A continuación, cree una API HTTP. API Gateway también admite API REST y API WebSocket,
pero una API HTTP es la mejor opción para este ejercicio. Las API de REST son compatibles con
más funciones que las API HTTP, pero no las necesitamos para este ejercicio. Las API HTTP
están diseñadas con características mínimas para que puedan ofrecerse a un precio más bajo. Las
API WebSocket mantienen conexiones persistentes con los clientes para la comunicación dúplex
completo, lo cual no es necesario para este ejemplo.

La API HTTP proporciona un punto de enlace HTTP para su función de Lambda. API Gateway enruta
las solicitudes a su función de Lambda y, a continuación, devuelve la respuesta de la función a los
clientes.

Para crear una API HTTP

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Aplique alguna de las siguientes acciones:

• Para crear su primera API, para HTTP API (API HTTP), elija Build (Crear).

• Si ha creado una API antes, elija Create API (Crear API) y, a continuación, elija Build
(Crear) para HTTP API (API HTTP).

3. Para Integrations (Integraciones), elija Add integration (Agregar integración).

4. Elija Lambda.

5. En Función Lambda, introduzca my-function.

6. En API name (Nombre de la API), escribamy-http-api.

7. Elija Next (Siguiente).

8. Revise la ruta que API Gateway crea para usted y, a continuación, elija Next (Siguiente).

9. Revise la etapa que API Gateway crea para usted y, a continuación, elija Next (Siguiente).

10. Seleccione Create (Crear).

Ahora ha creado una API HTTP con una integración de Lambda que está lista para recibir solicitudes
de clientes.

Paso 2: crear una API HTTP 29

Amazon API Gateway Guía para desarrolladores

Paso 3: probar la API

A continuación, pruebe su API para asegurarse de que se encuentra en funcionamiento. Para mayor
simplicidad, utilice un navegador web para invocar la API.

Para probar la API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.

3. Tenga en cuenta la URL de invocación de la API.

4. Copie la URL de invocación de la API y escríbala en un navegador web. Agregue el nombre de

la función de Lambda a la URL de invocación para llamar a su función de Lambda. De forma
predeterminada, la consola de API Gateway crea una ruta con el mismo nombre que su función
de Lambda, my-function.

La URL completa debería ser https://abcdef123.execute-api.us-

east-2.amazonaws.com/my-function.

Su navegador envía una GET solicitud a la API.

5. Verifique la respuesta de la API. Debería ver el texto "Hello from Lambda!" en el

navegador.

Paso 3: probar la API 30

Amazon API Gateway Guía para desarrolladores

(Opcional) Paso 4: limpiar

Para evitar costos innecesarios, elimine los recursos creados como parte de este ejercicio
introductorio. Los siguientes pasos eliminan la API HTTP, la función de Lambda y los recursos
asociados.

Para eliminar una API HTTP

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. En la página API, seleccione una API. Seleccione Actions y, luego, Delete.

3. Elija Eliminar.

Para eliminar una función de Lambda

1. Inicie sesión en la consola de Lambda en https://console.aws.amazon.com/lambda/.

2. En la página Functions (Funciones), seleccione una función. Seleccione Actions y, luego, Delete.

3. Elija Eliminar.

Para eliminar el grupo de registro de una función de Lambda

1. En la consola de Amazon CloudWatch, abra la página de grupos de registro.

2. En la página Grupos de registro, seleccione el grupo de registro de la función (/aws/lambda/

my-function). Elija Actions (Acciones) y, a continuación, elija Delete log group (Eliminar grupo
de registro).

3. Elija Eliminar.

Para eliminar el rol de ejecución de una función de Lambda

1. En la consola de AWS Identity and Access Management, abra la página Roles (Roles).

2. Seleccione el rol de la función, por ejempl, my-function-31exxmpl.

3. Elija Delete role (Eliminar rol).

4. Elija Sí, eliminar.

(Opcional) Paso 4: limpiar 31

Amazon API Gateway Guía para desarrolladores

Puede automatizar la creación y la limpieza de los recursos de AWS mediante el uso de AWS
CloudFormation o AWS SAM. Para obtener plantillas de AWS CloudFormation de ejemplo, consulte
las plantillas de AWS CloudFormation de ejemplo.

Pasos siguientes
Para este ejemplo, se utilizó la AWS Management Console para crear una API HTTP simple. La API
HTTP invoca una función de Lambda y devuelve una respuesta a los clientes.

A continuación, se indican los pasos siguientes a medida que continúa trabajando con API Gateway.

• Configure tipos adicionales de integraciones de API, entre los que se incluyen:

• Puntos de enlace HTTP
• Recursos privados en una VPC, como los servicios Amazon ECS
• Servicios de AWS como Amazon Simple Queue Service, AWS Step Functions y Kinesis Data
Streams
• Controlar el acceso a las API
• Habilitar el registro de las API
• Configurar la limitación de las API
• Configurar dominios personalizados para las API

Para obtener ayuda de la comunidad con Amazon API Gateway, consulte el foro de debate de API
Gateway. Cuando ingrese a este foro, es posible que AWS requiera que inicie sesión.

Para obtener ayuda sobre API Gateway directamente de AWS, consulte las distintas opciones de
soporte que se ofrecen en la página de AWS Support.

Consulte también nuestras preguntas frecuentes o contacte con nosotros directamente.

Pasos siguientes 32
Amazon API Gateway Guía para desarrolladores

Tutoriales y talleres sobre Amazon API Gateway

Los siguientes tutoriales y talleres proporcionan ejercicios prácticos para ayudar a obtener
información sobre API Gateway.

Tutoriales sobre API REST

• Desarrollo de una API de REST de API Gateway con integración Lambda

• Tutorial: Crear una API de REST importando un ejemplo
• Desarrollo de una API de REST de API Gateway con integración HTTP
• Tutorial: Crear una API REST con la integración privada de API Gateway
• Tutorial: creación de una API REST de API Gateway con integración de AWS
• Tutorial: creación de una API REST Calc con dos integraciones de servicios de AWS y una
integración de Lambda sin proxy
• Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway
• Tutorial: Creación de una API de REST como proxy de Amazon Kinesis en API Gateway
• Tutorial: creación de una API REST privada

Tutoriales sobre API HTTP

• Tutorial: crear una API CRUD con Lambda y DynamoDB

• Tutorial: creación de una API HTTP con una integración privada en un Servicio Amazon ECS

Tutoriales de la API de WebSocket

• Tutorial: Creación de una aplicación de chat sin servidor con una API de WebSocket, Lambda y
DynamoDB

Talleres

• Desarrollar una aplicación web sin servidor

• CI/CD para aplicaciones sin servidor
• Taller sobre seguridad sin servidor

33
Amazon API Gateway Guía para desarrolladores

• Administración, autenticación y autorización de identidades sin servidor

• Taller sobre Amazon API Gateway

Tutoriales sobre API REST de Amazon API Gateway

Los siguientes tutoriales proporcionan ejercicios prácticos para ayudar a saber más sobre las API
REST de API Gateway.

Temas
• Desarrollo de una API de REST de API Gateway con integración Lambda
• Tutorial: Crear una API de REST importando un ejemplo
• Desarrollo de una API de REST de API Gateway con integración HTTP
• Tutorial: Crear una API REST con la integración privada de API Gateway
• Tutorial: creación de una API REST de API Gateway con integración de AWS
• Tutorial: creación de una API REST Calc con dos integraciones de servicios de AWS y una
integración de Lambda sin proxy
• Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway
• Tutorial: Creación de una API de REST como proxy de Amazon Kinesis en API Gateway
• Tutorial: creación de una API REST privada

Desarrollo de una API de REST de API Gateway con integración Lambda

Para desarrollar una API con integraciones de Lambda puede utilizar la integración de proxy de
Lambda o la integración de Lambda no de proxy.

Con la integración de proxy de Lambda, la entrada para la función de Lambda integrada se puede
expresar como cualquier combinación de encabezados de solicitud, variables de ruta, parámetros
de cadena de consulta y cuerpo. Además, la función de Lambda puede utilizar los valores de
configuración de la API para influir en su lógica de ejecución. Para un desarrollador de API, la
configuración de una integración de proxy de Lambda es sencilla. Además de elegir una función
de Lambda específica en una región determinada, no hay mucho que pueda hacer. API Gateway
configura la solicitud de integración y la respuesta de integración por usted. Una vez configurado, el
método de API integrado puede evolucionar con el backend sin modificar la configuración existente.
Esto es posible porque el desarrollador de la función de Lambda del backend analiza los datos de

Tutoriales sobre API REST 34

Amazon API Gateway Guía para desarrolladores

la solicitud entrante y responde al cliente con los resultados deseados cuando todo va bien o con
mensajes de error cuando algo va mal.

En la integración de Lambda no de proxy, debe asegurarse de que la entrada a la función de

Lambda se proporcione como la carga de solicitud de integración. Esto implica que usted, como
desarrollador de la API, debe asignar los datos de entrada que el cliente proporcionó como
parámetros de solicitud en el cuerpo de solicitud de integración adecuado. Puede que también tenga
que traducir el cuerpo de la solicitud proporcionado por el cliente a un formato reconocido por la
función de Lambda.

Temas

• Tutorial: Desarrollo de una API de REST Hello World con integración de proxy de Lambda

• Tutorial: Desarrollo de una API de REST de API Gateway con integración de proxy de Lambda
entre cuentas

• Tutorial: Desarrollo de una API de REST de API Gateway con integración no de proxy de Lambda

Tutorial: Desarrollo de una API de REST Hello World con integración de proxy de
Lambda

La integración de proxy de Lambda es un tipo de integración de API de API Gateway ligera y flexible
que le permite integrar un método de API, o la totalidad de la API, con una función de Lambda. La
función de Lambda se puede escribir en cualquier lenguaje que admitida Lambda. Debido a que se
trata de una integración de proxy, puede cambiar la implementación de la función de Lambda en
cualquier momento sin tener que volver a implementar la API.

En este tutorial, aprenderá a hacer lo siguiente:

• Creación de una función Hello, World! Función de Lambda para que sea el backend de la API.

• Creación y prueba de una función "Hello, World!" API con integración de proxy de Lambda.

Temas

• Creación de una función Hello, World! Función de Lambda

• Creación de una función Hello, World! API

• Implementación y pruebas de API

Desarrollo de una API con la integración de Lambda 35

Amazon API Gateway Guía para desarrolladores

Creación de una función Hello, World! Función de Lambda

Para crear un "Hello, World!" Función de Lambda en la consola de Lambda

1. Inicie sesión en la consola de Lambda en https://console.aws.amazon.com/lambda/.

2. En la barra de navegación de AWS, elija una Región (por ejemplo, Este de EE. UU. (Norte de
Virginia)).

Note
Anote la región en la que ha creado la función de Lambda. La necesitará al crear la API.

3. Elija Functions (Funciones) en el panel de navegación.

4. Elija Create function (Crear función).
5. Elija Author from scratch (Crear desde cero).
6. Bajo Basic information (Información básica), haga lo siguiente:

a. Bajo Function name (Nombre de función), escriba

GetStartedLambdaProxyIntegration.
b. En Tiempo de ejecución, elija el último tiempo de ejecución de Node.js o Python compatible.
c. En Permissions (Permisos), expanda Change default execution role(Cambiar rol de
ejecución predeterminado). En Rol de ejecución, elija Crear un nuevo rol desde las plantillas
de políticas de AWS.
d. En Role name (Nombre del rol), escriba GetStartedLambdaBasicExecutionRole.
e. Deje el campo Policy templates (Plantillas de política) en blanco.
f. Elija Create function (Crear función).
7. En Function code (Código de la función), en el editor de código integrado, copie/pegue el código
siguiente:

Node.js

export const handler = function(event, context, callback) {

console.log('Received event:', JSON.stringify(event, null, 2));
var res ={
"statusCode": 200,
"headers": {
"Content-Type": "*/*"
Desarrollo de una API con la integración de Lambda 36
Amazon API Gateway Guía para desarrolladores

}
};
var greeter = 'World';
if (event.greeter && event.greeter!=="") {
greeter = event.greeter;
} else if (event.body && event.body !== "") {
var body = JSON.parse(event.body);
if (body.greeter && body.greeter !== "") {
greeter = body.greeter;
}
} else if (event.queryStringParameters &&
event.queryStringParameters.greeter && event.queryStringParameters.greeter !==
"") {
greeter = event.queryStringParameters.greeter;
} else if (event.multiValueHeaders && event.multiValueHeaders.greeter &&
event.multiValueHeaders.greeter != "") {
greeter = event.multiValueHeaders.greeter.join(" and ");
} else if (event.headers && event.headers.greeter && event.headers.greeter !
= "") {
greeter = event.headers.greeter;
}

res.body = "Hello, " + greeter + "!";

callback(null, res);
};

Python

import json

def lambda_handler(event, context):

print(event)
greeter = 'World'
try:
if (event['queryStringParameters']) and (event['queryStringParameters']
['greeter']) and (event['queryStringParameters']['greeter'] != None):
greeter = event['queryStringParameters']['greeter']
except KeyError:
print('No greeter')
try:
if (event['multiValueHeaders']) and (event['multiValueHeaders']
['greeter']) and (event['multiValueHeaders']['greeter'] != None):
greeter = " and ".join(event['multiValueHeaders']['greeter'])

Desarrollo de una API con la integración de Lambda 37

Amazon API Gateway Guía para desarrolladores

except KeyError:
print('No greeter')
try:
if (event['headers']) and (event['headers']['greeter']) and
(event['headers']['greeter'] != None):
greeter = event['headers']['greeter']
except KeyError:
print('No greeter')
if (event['body']) and (event['body'] != None):
body = json.loads(event['body'])
try:
if (body['greeter']) and (body['greeter'] != None):
greeter = body['greeter']
except KeyError:
print('No greeter')

res = {
'statusCode': 200,
'headers': {
'Content-Type': '*/*'
},
'body': 'Hello, '+greeter+'!'
}
return res

8. Elija Deploy (Implementar).

Creación de una función Hello, World! API

Ahora cree una API para la función de Lamba "Hello, World!" La función de Lambda utilizando la
consola de API Gateway.

Para crear un "Hello, World!" API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las
características del servicio. En REST API, elija Build (Compilación). Cuando aparezca el menú
emergente Create Example API (Crear API de ejemplo), elija OK (Aceptar).

Si esta no es la primera vez que utiliza API Gateway, elija Create API (Crear API). En REST API,
elija Build (Compilación).
3. En API name (Nombre de la API), escribaLambdaProxyAPI.

Desarrollo de una API con la integración de Lambda 38

Amazon API Gateway Guía para desarrolladores

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Mantenga Tipo de punto de conexión de la API establecido en Regional.
6. Elija Crear API.

Después de crear una API, se crea un recurso. Normalmente, los recursos de la API están
organizados en un árbol de recursos de acuerdo con la lógica de la aplicación. Para este ejemplo,
creará un recurso /helloworld.

Para crear un recurso

1. Seleccione el recurso / y, a continuación, elija Crear recurso.

2. Mantenga Recurso proxy desactivado.
3. Mantenga Ruta del recurso en /.
4. En Nombre del recurso, escriba helloworld.
5. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
6. Elija Crear recurso.

En una integración de proxy, toda la solicitud se envía a la función de Lambda del backend tal y
como está, a través de un método catch-all ANY que representa cualquier método HTTP. El método
HTTP real lo especifica el cliente en tiempo de ejecución. El método ANY le permite usar una sola
configuración de métodos de API para todos los métodos HTTP admitidos: DELETE, GET, HEAD,
OPTIONS, PATCH, POST y PUT.

Para crear un método ANY

1. Seleccione el recurso /helloworld y, a continuación, elija Crear método.

2. En Tipo de método, seleccione CUALQUIERA.
3. En Tipo de integración, seleccione Función de Lambda.
4. Active Integración de proxy de Lambda.
5. En Función de Lambda, seleccione la Región de AWS en la que creó la función de Lambda y, a
continuación, introduzca el nombre de la función.
6. Si desea utilizar el valor predeterminado del tiempo de espera, que es de 29 segundos,
mantenga activado el Tiempo de espera predeterminado. Para establecer un tiempo de espera
personalizado, elija Tiempo de espera predeterminado e ingrese un valor de tiempo de espera
comprendido entre 50 y 29000 milisegundos.

Desarrollo de una API con la integración de Lambda 39

Amazon API Gateway Guía para desarrolladores

7. Elija Crear método.

Implementación y pruebas de API

Para implementar su API

1. Elija Deploy API (Implementar API).

2. En Etapa, seleccione Nueva etapa.

3. En Stage name (Nombre de etapa), escriba test.

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Elija Implementar.

6. En Detalles de la etapa, elija el icono de copia para copiar la URL de invocación de la API.

Uso del navegador y cURL para probar una API con integración de proxy de Lambda

Puede utilizar un navegador o cURL para probar la API.

Para probar solicitudes GET utilizando solo los parámetros de cadenas de consulta, puede
escribir la URL para el recurso helloworld de la API en la barra de direcciones del navegador.
Por ejemplo: https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?
name=John&city=Seattle

Para otros métodos, debe utilizar utilidades de prueba de la API de REST más avanzadas, tales
como POSTMAN o cURL. En este tutorial se utiliza cURL. Los ejemplos de comandos de cURL que
aparecen a continuación se presupone que cURL está instalado en su equipo.

Para probar la API implementada mediante cURL:

1. Abra una ventana de terminal.

2. Copie el siguiente comando cURL y péguelo en la ventana de terminal. Sustituya la URL de

invocación por la que copió en el paso anterior y añada /helloworld al final de la URL.

Note
Si está ejecutando el comando en Windows, utilice esta sintaxis:

Desarrollo de una API con la integración de Lambda 40

Amazon API Gateway Guía para desarrolladores

curl -v -X POST "https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/

test/helloworld" -H "content-type: application/json" -d "{ \"greeter\":
\"John\" }"

a. Para llamar a la API con el parámetro de cadena de consulta de ?greeter=John:

curl -X GET 'https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/

helloworld?greeter=John'

b. Para llamar a la API con el parámetro de encabezado de greeter:John:

curl -X GET https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/

helloworld \
-H 'content-type: application/json' \
-H 'greeter: John'

c. Para llamar a la API con un cuerpo de {"greeter":"John"}:

curl -X POST https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/

helloworld \
-H 'content-type: application/json' \
-d '{ "greeter": "John" }'

En todos estos casos, la salida es una respuesta 200 con el siguiente cuerpo de respuesta:

Hello, John!

Tutorial: Desarrollo de una API de REST de API Gateway con integración de proxy de
Lambda entre cuentas

Ahora puede utilizar una función AWS Lambda desde otra cuenta de AWS como backend de
integración de API. Cada cuenta puede estar en cualquier región en la que Amazon API Gateway
esté disponible. Esto permite administrar y compartir de forma centralizada funciones de backend de
Lambda en varias API.

Desarrollo de una API con la integración de Lambda 41

Amazon API Gateway Guía para desarrolladores

En esta sección mostramos cómo configurar una integración de proxy de Lambda entre cuentas con
la consola de Amazon API Gateway.

Creación de una API de API Gateway para la integración de Lambda entre cuentas

Para crear un API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las
características del servicio. En REST API, elija Build (Compilación). Cuando aparezca el menú
emergente Create Example API (Crear API de ejemplo), elija OK (Aceptar).

Si esta no es la primera vez que utiliza API Gateway, elija Create API (Crear API). En REST API,
elija Build (Compilación).
3. En API name (Nombre de la API), escribaCrossAccountLambdaAPI.
4. (Opcional) En Description (Descripción), introduzca una descripción.
5. Mantenga Tipo de punto de conexión de la API establecido en Regional.
6. Elija Crear API.

Creación de una función de integración de Lambda en otra cuenta

Ahora, creará una función de Lambda en una cuenta distinta de la que usó para crear la API de
ejemplo.

Creación de una función de Lambda en otra cuenta

1. Inicie sesión en la consola de Lambda de una cuenta distinta de la que utilizó para crear la API
de API Gateway.
2. Elija Create function (Crear función).
3. Elija Author from scratch.
4. En Author from scratch (Crear desde cero), haga lo siguiente:

a. En Function name (Nombre de función), escriba un nombre.

b. En la lista desplegable Runtime (Tiempo de ejecución), elija un tiempo de ejecución de
Node.js compatible.
c. En Permissions (Permisos), expanda Choose or create an execution role (Seleccionar o
crear un rol de ejecución). Puede crear un rol o elegir uno existente.

Desarrollo de una API con la integración de Lambda 42

Amazon API Gateway Guía para desarrolladores

d. Elija Create function (Crear función) para continuar.

5. Desplácese hacia abajo en el panel Function code (Código de la función).

6. Introduzca la implementación de la función de Node.js desde the section called “Tutorial: API
Hello World con integración de proxy de Lambda”.

7. Elija Deploy (Implementar).

8. Anote el ARN completo de la función (se encuentra en la esquina superior derecha del panel de
la función de Lambda). Lo necesitará al crear la integración de Lambda entre cuentas.

Configuración de la integración de Lambda entre cuentas

Una vez que tenga una función de integración de Lambda en otra cuenta, puede utilizar la consola
de API Gateway para agregarla a la API de la primera cuenta.

Note
Si está configurando un autorizador entre regiones y cuentas, el valor sourceArn que se
agrega a la función de destino debe utilizar la región de la función, no la región de la API.

Después de crear una API, se crea un recurso. Normalmente, los recursos de la API están
organizados en un árbol de recursos de acuerdo con la lógica de la aplicación. Para este ejemplo,
creará un recurso /helloworld.

Para crear un recurso

1. Seleccione el recurso / y, a continuación, elija Crear recurso.

2. Mantenga Recurso proxy desactivado.

3. Mantenga Ruta del recurso en /.

4. En Nombre del recurso, escriba helloworld.

5. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).

6. Elija Crear recurso.

Después de crear un recurso, se crea un método GET. El método GET se integra con una función de
Lambda en otra cuenta.

Desarrollo de una API con la integración de Lambda 43

Amazon API Gateway Guía para desarrolladores

Para crear un método GET

1. Seleccione el recurso /helloworld y, a continuación, elija Crear método.

2. En Tipo de método, seleccione GET.

3. En Tipo de integración, seleccione Función de Lambda.

4. Active Integración de proxy de Lambda.

5. En Función de Lambda, introduzca el ARN completo de la función de Lambda del paso 1.

En la consola de Lambda, puede encontrar el ARN de la función en la esquina superior derecha

de la ventana de la consola.

6. Al introducir el ARN, aparecerá una cadena de comandos aws lambda add-permission.

Esto concederá a su primera cuenta acceso a la función de Lambda de la segunda cuenta.
Copie y pegue la cadena de comandos aws lambda add-permission en una ventana de la
AWS CLI configurada para la segunda cuenta.

7. Elija Crear método.

Para ver la política actualizada para la función en la consola de Lambda.

(Opcional) Para ver la política actualizada

1. Inicie sesión en AWS Management Console y abra la consola de AWS Lambda en https://
console.aws.amazon.com/lambda/.

2. Elija su función de Lambda.

3. Elija Permissions.

Debería ver una política Allow con una cláusula Condition en la que AWS:SourceArn es el
ARN del método GET de la API.

Tutorial: Desarrollo de una API de REST de API Gateway con integración no de proxy
de Lambda

En este tutorial utilizaremos la consola de API Gateway para crear una API que permita a un cliente
llamar a funciones de Lambda a través de la integración de Lambda no de proxy (conocida también
como integración personalizada). Para obtener más información acerca de las funciones de AWS
Lambda y de Lambda, consulte la Guía para desarrolladores de AWS Lambda.

Desarrollo de una API con la integración de Lambda 44

Amazon API Gateway Guía para desarrolladores

Para facilitar el aprendizaje, elegimos una función de Lambda sencilla con una configuración de
API mínima para guiarlo para desarrollar una API de API Gateway con la integración de Lambda
personalizada. Cuando sea necesario, describiremos parte de la lógica. Para ver un ejemplo más
detallado de la integración de Lambda personalizada, consulte Tutorial: creación de una API REST
Calc con dos integraciones de servicios de AWS y una integración de Lambda sin proxy.

Antes de crear la API, configure el backend de Lambda mediante la creación de una función de
Lambda en AWS Lambda, lo cual se describe a continuación.

Temas
• Creación de una función de Lambda para la integración de Lambda no de proxy
• Creación de una API con la integración de Lambda no de proxy
• Prueba que invoca el método de API
• Implementar la API
• Pruebe la API en una etapa de implementación
• Eliminar recursos

Creación de una función de Lambda para la integración de Lambda no de proxy

Note
La creación de funciones de Lambda puede suponer cargos en su cuenta de AWS.

En este paso creará una función de Lambda del tipo "Hello, World!" para la integración personalizada
de Lambda. En esta tutorial, la función se denomina GetStartedLambdaIntegration.

La implementación de esta función de Lambda GetStartedLambdaIntegration es la siguiente:

Node.js

'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
'Saturday'];
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];

console.log('Loading function');

Desarrollo de una API con la integración de Lambda 45

Amazon API Gateway Guía para desarrolladores

export const handler = function(event, context, callback) {

// Parse the input for the name, city, time and day property values
let name = event.name === undefined ? 'you' : event.name;
let city = event.city === undefined ? 'World' : event.city;
let time = times.indexOf(event.time)<0 ? 'day' : event.time;
let day = days.indexOf(event.day)<0 ? null : event.day;

// Generate a greeting
let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
if (day) greeting += 'Happy ' + day + '!';

// Log the greeting to CloudWatch

console.log('Hello: ', greeting);

// Return a greeting to the caller

callback(null, {
"greeting": greeting
});
};

Python

import json

days = {'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',

'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}

def lambda_handler(event, context):

print(event)
# parse the input for the name, city, time, and day property values
try:
if event['name']:
name = event['name']
except KeyError:
name = 'you'
try:
if event['city']:
city = event['city']
except KeyError:
city = 'World'
try:
if event['time'] in times:

Desarrollo de una API con la integración de Lambda 46

Amazon API Gateway Guía para desarrolladores

time = event['time']
else:
time = 'day'
except KeyError:
time = 'day'
try:
if event['day'] in days:
day = event['day']
else:
day = ''
except KeyError:
day = ''

# Generate a greeting
greeting = 'Good ' + time + ', ' + name + ' of ' + city + '.' + ['', ' Happy '+
day + '!'][day !='']

# Log the greeting to CloudWatch

print(greeting)

#Return a greeting to the caller

return {'greeting': greeting}

Para la integración de Lambda personalizada, API Gateway transmite la entrada a la función de

Lambda del cliente como cuerpo de solicitud de integración. El objeto event de gestión de la función
de Lambda es la entrada.

Nuestra función de Lambda es simple. Analiza el objeto de entrada event para las
propiedades name, city, time y day. Entonces, devuelve un saludo, como un objeto JSON
de {"message":greeting}, al intermediario. El mensaje se encuentra en el patrón "Good
[morning|afternoon|day], [name|you] in [city|World]. Happy day!". Se supone
que la entrada a la función de Lambda es del siguiente objeto JSON:

{
"city": "...",
"time": "...",
"day": "...",
"name" : "..."
}

Para obtener más información, consulte AWS Lambda Developer Guide.

Desarrollo de una API con la integración de Lambda 47

Amazon API Gateway Guía para desarrolladores

Además, la función registra su ejecución en Amazon CloudWatch llamando a console.log(...).

Esto es útil para rastrear llamadas cuando se depura la función. Para permitir que la función
GetStartedLambdaIntegration registre la llamada, establezca un rol de IAM con las políticas
apropiadas para la función de Lambda para crear los flujos de CloudWatch y agregar entradas de
registro a los flujos. La consola de Lambda lo guía para crear los roles y políticas de IAM requeridos.

Si configura la API sin utilizar la consola de API Gateway (por ejemplo, si importa una API de un
archivo de OpenAPI), tendrá que crear de forma explícita, si es necesario, y configurar un rol y una
política de invocación para que API Gateway invoque las funciones de Lambda. Para obtener más
información sobre cómo configurar los roles de ejecución e invocación de Lambda para una API de
API Gateway, consulte Control del acceso a una API con permisos de IAM.

En comparación con GetStartedLambdaProxyIntegration, la función de Lambda para la

integración de proxy de Lambda, la función de Lambda GetStartedLambdaIntegration para la
integración personalizada de Lambda solo toma entradas del cuerpo de solicitud de integración de
API de API Gateway. La función puede devolver una salida de cualquier objeto JSON, una cadena,
un número, un booleano o incluso un blob binario. Por el contrario, la función de Lambda de la
integración de proxy de Lambda puede tomar la entrada de cualquier dato solicitado, pero debe
devolver una salida de un objeto JSON específico. La función GetStartedLambdaIntegration
de la integración de Lambda personalizada puede tener los parámetros de solicitud de API como
entrada, siempre que API Gateway asigne los parámetros de solicitud de API requeridos al cuerpo de
solicitud de la integración antes de reenviar la solicitud del cliente al backend. Para que esto ocurra,
el desarrollador de la API debe crear una plantilla de mapeo y debe configurarla en el método de API
durante la creación de la API.

Ahora, cree la función de Lambda GetStartedLambdaIntegration.

Para crear la función de Lambda GetStartedLambdaIntegration para la integración

personalizada de Lambda

1. Abra la consola de AWS Lambda en https://console.aws.amazon.com/lambda/.

2. Aplique alguna de las siguientes acciones:

• Si aparece la página de bienvenida, elija Get Started Now (Empezar ahora) y, a continuación,
elija Create function (Crear función).
• Si aparece la página de lista Lambda > Functions (Lambda > Funciones), elija Create function
(Crear función).
3. Elija Author from scratch.

Desarrollo de una API con la integración de Lambda 48

Amazon API Gateway Guía para desarrolladores

4. En el panel Author from scratch (Crear desde cero), haga lo siguiente:

a. En Name (Nombre), escriba GetStartedLambdaIntegration como nombre de la

función de Lambda.

b. En Tiempo de ejecución, elija el último tiempo de ejecución de Node.js o Python compatible.

c. En Permissions (Permisos), expanda Change default execution role(Cambiar rol de

ejecución predeterminado). En Rol de ejecución, elija Crear un nuevo rol desde las plantillas
de políticas de AWS.

d. En Role name (Nombre de la función), escriba un nombre para la función (por ejemplo,
GetStartedLambdaIntegrationRole).

e. En Policy templates (Plantillas de política), elija Simple microservice permissions (Permisos

para microservicios sencillos).

f. Elija Create function (Crear función).

5. En el panel Configure function (Configurar función), en Function code (Código de función),

configure los campos siguientes:

a. Copie el código de la función de Lambda que aparece al comienzo de esta sección y

péguelo en el editor del código en línea.

b. Deje las opciones predeterminadas para todos los demás campos en esta sección.

c. Elija Deploy (Implementar).

6. Para probar la función recién creada, seleccione la pestaña Probar.

a. En Nombre del evento, escriba HelloWorldTest.

b. En JSON de evento, sustituya el código predeterminado por lo siguiente.

{
"name": "Jonny",
"city": "Seattle",
"time": "morning",
"day": "Wednesday"
}

c. Elija Test (Probar) para invocar la función. Se muestra la sección Execution result:
succeeded (Resultado de ejecución: realizada correctamente). Expanda Detalles y verá el
siguiente resultado.

{
Desarrollo de una API con la integración de Lambda 49
Amazon API Gateway Guía para desarrolladores

"greeting": "Good morning, Jonny of Seattle. Happy Wednesday!"

}

La salida también se escribe en CloudWatch Logs.

Como ejercicio secundario, puede utilizar la consola de IAM para ver el rol de IAM
(GetStartedLambdaIntegrationRole) que fue creado como parte de la creación de la función
de Lambda. Este rol de IAM posee dos políticas en línea asociadas. Una de ellas estipula los
permisos más básicos para la ejecución de Lambda. Permite llamar a CreateLogGroup de
CloudWatch para cualquier recurso de CloudWatch de su cuenta en la región donde se crea la
función de Lambda. Esta política también permite crear flujos de CloudWatch y registrar eventos para
la función de Lambda HelloWorldForLambdaIntegration.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "logs:CreateLogGroup",
"Resource": "arn:aws:logs:region:account-id:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:region:account-id:log-group:/aws/lambda/
GetStartedLambdaIntegration:*"
]
}
]
}

El documento de la otra política se aplica para invocar otro servicio de AWS que no se utiliza en este
ejemplo. Puede omitirla por ahora.

Asociada con el rol de IAM hay una entidad de confianza, que es lambda.amazonaws.com. Aquí se
encuentra la relación de confianza:

Desarrollo de una API con la integración de Lambda 50

Amazon API Gateway Guía para desarrolladores

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}

La combinación de esta relación de confianza y la política en línea hace que sea posible para la
función de Lambda invocar una función console.log() para registrar los eventos en CloudWatch
Logs.

Si no utilizó la AWS Management Console para crear la función de Lambda, deberá seguir estos
ejemplos para crear el rol y las políticas de IAM requeridas y, a continuación, adjuntar manualmente
el rol a su función.

Creación de una API con la integración de Lambda no de proxy

Con la función de Lambda (GetStartedLambdaIntegration) creada y probada, está listo para

exponer la función a través de una API de API Gateway. Para fines ilustrativos, expondremos la
función de Lambda con un método HTTP genérico. Utilizamos el cuerpo de solicitud, una variable
de ruta de la URL, una cadena de consulta y un encabezado para recibir los datos de entrada
requeridos del cliente. Activamos el validador de la solicitud de API Gateway para que la API asegure
que todos los datos requeridos se definen y especifican de forma adecuada. Configuramos una
plantilla de mapeo para que API Gateway transforme los datos de solicitud proporcionados por el
cliente a un formato válido, según lo requiera la función de Lambda del backend.

Para crear una API con la integración de Lambda no de proxy

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las
características del servicio. En REST API, elija Build (Compilación). Cuando aparezca el menú
emergente Create Example API (Crear API de ejemplo), elija OK (Aceptar).

Desarrollo de una API con la integración de Lambda 51

Amazon API Gateway Guía para desarrolladores

Si esta no es la primera vez que utiliza API Gateway, elija Create API (Crear API). En REST API,
elija Build (Compilación).
3. En API name (Nombre de la API), escribaLambdaNonProxyAPI.
4. (Opcional) En Description (Descripción), introduzca una descripción.
5. Mantenga Tipo de punto de conexión de la API establecido en Regional.
6. Elija Crear API.

Tras crear su API, cree un recurso /{city}. Este es un ejemplo de un recurso con una variable de ruta
que toma una entrada del cliente. Más adelante, mapeará esta variable de ruta en la entrada de la
función de Lambda mediante una plantilla de mapeo.

Para crear un recurso

1. Elija Crear recurso.

2. Mantenga Recurso proxy desactivado.
3. Mantenga Ruta del recurso en /.
4. En Nombre del recurso, escriba {city}.
5. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
6. Elija Crear recurso.

Tras crear su recurso /{city}, cree un método ANY. El verbo ANY de HTTP es un marcador para un
método HTTP válido que un cliente envía en el tiempo de ejecución. Este ejemplo muestra que el
método ANY se puede utilizar para la integración de Lambda personalizada y para la integración de
proxy de Lambda.

Para crear un método ANY

1. Seleccione el recurso /{city} y, a continuación, elija Crear método.

2. En Tipo de método, seleccione CUALQUIERA.
3. En Tipo de integración, seleccione Función de Lambda.
4. Mantenga desactivada la Integración de proxy Lambda.
5. En Función de Lambda, seleccione la Región de AWS en la que creó la función de Lambda y, a
continuación, introduzca el nombre de la función.

Desarrollo de una API con la integración de Lambda 52

Amazon API Gateway Guía para desarrolladores

6. Si desea utilizar el valor predeterminado del tiempo de espera, que es de 29 segundos,

mantenga activado el Tiempo de espera predeterminado. Para establecer un tiempo de espera
personalizado, elija Tiempo de espera predeterminado e ingrese un valor de tiempo de espera
comprendido entre 50 y 29000 milisegundos.
7. Elija Crear método.

Después de crear el método ANY, se activa un validador de la solicitud para una variable de ruta de
la URL, una cadena de consulta y un encabezado para garantizar que todos los datos requeridos se
hayan definido y especificado de la forma adecuada. Para este ejemplo, se crea un parámetro de
cadena de consulta time y un encabezado day.

Para activar un validador de solicitudes

1. En la sección Solicitud de método, elija Editar.

2. En Validador de solicitud, seleccione Validar parámetros de cadena de consulta y encabezados.
3. Elija Parámetros de cadenas de consulta de URL y haga lo siguiente:

a. Elija Add query string (Añadir cadena de consulta).

b. En Nombre, ingrese time.
c. Active la opción Obligatorio.
d. Mantenga Almacenamiento en caché desactivado.
4. Elija Encabezados de solicitudes HTTP y haga lo siguiente:

a. Elija Add header (Añadir encabezado).

b. En Nombre, ingrese day.
c. Active la opción Obligatorio.
d. Mantenga Almacenamiento en caché desactivado.
5. Elija Guardar.

Tras activar un validador de solicitudes, se configura la solicitud de integración para el método

ANYañadiendo una plantilla body-mapping para transformar la solicitud entrante en una carga JSON,
tal y como exige la función de Lambda de backend.

Para configurar la solicitud de integración

1. En la sección Solicitud de integración, elija Editar.

Desarrollo de una API con la integración de Lambda 53

Amazon API Gateway Guía para desarrolladores

2. En Acceso directo de cuerpo de la solicitud, elija Cuando no haya plantillas definidas

(recomendado).
3. Elija Plantillas de mapeo.
4. Elija Add mapping template (Añadir plantilla de asignación).
5. En Tipo de contenido, ingrese application/json.
6. En Cuerpo de la plantilla, introduzca el siguiente código:

#set($inputRoot = $input.path('$'))
{
"city": "$input.params('city')",
"time": "$input.params('time')",
"day": "$input.params('day')",
"name": "$inputRoot.callerName"
}

7. Elija Guardar.

Prueba que invoca el método de API

La consola de API Gateway proporciona un servicio de pruebas para que pueda probar la invocación
a la API antes de que se implemente. Puede utilizar la característica Prueba de la consola para
probar la API mediante el envío de la siguiente solicitud:

POST /Seattle?time=morning
day:Wednesday

{
"callerName": "John"
}

En esta solicitud de prueba, configurará ANY en POST, establecerá {city} en Seattle, asignará
Wednesday como el valor del encabezado day y asignará "John" como el valor callerName.

Para probar el método ANY

1. Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para
mostrar la pestaña.
2. En Tipo de método, seleccione POST.

Desarrollo de una API con la integración de Lambda 54

Amazon API Gateway Guía para desarrolladores

3. En Ruta, debajo de ciudad, introduzca Seattle.

4. En Cadenas de consulta, escriba time=morning.
5. En Encabezados, escriba day:Wednesday.
6. En Cuerpo de la solicitud, introduzca { "callerName": "John" }.
7. Seleccione Test (Probar).

Compruebe que la carga de respuesta devuelta sea la siguiente:

{
"greeting": "Good morning, John of Seattle. Happy Wednesday!"
}

También puede ver los registros para ver cómo API Gateway procesa la solicitud y la respuesta.

Execution log for request test-request

Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations:
{ "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type
application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://
lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-
west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-
tag=test-request,
Authorization=********************************************************************************
X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-
Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/
{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid,
X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw
+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/
YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/
yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs+
+ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/
EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
"city": "Seattle",

Desarrollo de una API con la integración de Lambda 55

Amazon API Gateway Guía para desarrolladores

"time": "morning",
"day": "Wednesday",
"name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-
west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-
west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations:
{"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-
Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-
alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-
Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations:
{"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-
Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200

Los registros muestran la solicitud entrante antes del mapeo y la solicitud de integración después
del mapeo. Cuando una prueba falla, los registros son útiles para evaluar si la entrada original es
correcta o si la plantilla de mapeo funciona correctamente.

Implementar la API

La invocación de prueba es una simulación que tiene limitaciones. Por ejemplo, elude cualquier
mecanismo de autorización promulgado en la API. Para probar la ejecución de la API en tiempo real,
primero debe implementar la API. Para implementar una API, usted crea una etapa para crear una
snapshot de la API en ese momento. El nombre de etapa también define la ruta de base después del
nombre de host predeterminado de la API. El recurso raíz de la API se agrega después del nombre
de la etapa. Al modificar la API, debe volver a implementarla a una etapa nueva o existente antes de
que los cambios surtan efecto.

Para implementar la API en una etapa

1. Elija Deploy API (Implementar API).

2. En Etapa, seleccione Nueva etapa.
3. En Stage name (Nombre de etapa), escriba test.

Desarrollo de una API con la integración de Lambda 56

Amazon API Gateway Guía para desarrolladores

Note
La entrada debe tener texto cifrado UTF-8 (es decir, no localizado).

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Elija Implementar.

En Detalles de la etapa, elija el icono de copia para copiar la URL de invocación de la API. El patrón
general de esta URL base de la API es https://api-id.region.amazonaws.com/stageName.
Por ejemplo, la URL base de la API (beags1mnid) creada en la región us-west-2 e implementada
en la etapa test es https://beags1mnid.execute-api.us-west-2.amazonaws.com/test.

Pruebe la API en una etapa de implementación

Puede probar una API implementada de diferentes maneras. Para las solicitudes GET que solo
utilizan variables de ruta de URL o parámetros de cadena de consulta, puede escribir la URL del
recurso de la API en un explorador. Para otros métodos, debe utilizar utilidades de prueba de la API
de REST más avanzadas, tales como POSTMAN o cURL.

Para probar la API mediante cURL

1. Abra una ventana de la terminal en su equipo local conectado a Internet.

2. Para probar POST /Seattle?time=evening:

Copie el siguiente comando cURL y péguelo en la ventana de la terminal.

curl -v -X POST \
'https://beags1mnid.execute-api.us-west-2.amazonaws.com/test/Seattle?
time=evening' \
-H 'content-type: application/json' \
-H 'day: Thursday' \
-H 'x-amz-docs-region: us-west-2' \
-d '{
"callerName": "John"
}'

Debería recibir una respuesta correcta con la siguiente carga:

Desarrollo de una API con la integración de Lambda 57

Amazon API Gateway Guía para desarrolladores

{"greeting":"Good evening, John of Seattle. Happy Thursday!"}

Si cambia POST a PUT en esta solicitud de método, recibe la misma respuesta.

Eliminar recursos

Si ya no necesita las funciones de Lambda que ha creado para este tutorial, puede eliminarlas ahora.
También puede eliminar los recursos de IAM asociados.

Warning
Si tiene previsto completar el resto de tutoriales de esta serie, no elimine el rol de ejecución
de Lambda ni el rol de invocación de Lambda. Si elimina una función de Lambda que usan
sus API, esas API dejarán de funcionar. La eliminación de una función de Lambda no se
puede deshacer. Si desea utilizar la función de Lambda de nuevo, debe volver a crearla.
Si elimina un recurso IAM que usa una función de Lambda, esa función de Lambda dejará
de funcionar y las API que dependen de esa función tampoco funcionarán. La eliminación de
un recurso de IAM no se puede deshacer. Si desea utilizar el recurso de IAM de nuevo, debe
volver a crearlo.

Para eliminar las funciones de Lambda

1. Inicie sesión en la AWS Management Console y abra la consola de AWS Lambda en https://
console.aws.amazon.com/lambda/.
2. En la lista de funciones, elija GetHelloWorld, elija Actions (Acciones) y, a continuación, Delete
function (Eliminar función). Cuando se le pregunte, elija Delete (Eliminar) otra vez.
3. En la lista de funciones, elija GetHelloWithName, Actions (Acciones) y, a continuación, Delete
function (Eliminar función). Cuando se le pregunte, elija Delete (Eliminar) otra vez.

Para eliminar los recursos de IAM asociados

1. Abra la consola de IAM en https://console.aws.amazon.com/iam/.

2. En Details (Detalles), elija Roles (Roles).
3. En la lista de roles, elija APIGatewayLambdaExecRole, elija Role Actions (Acciones del rol) y
luego elija Delete Role (Eliminar rol). Cuando se le pregunte, elija Yes, Delete.

Desarrollo de una API con la integración de Lambda 58

Amazon API Gateway Guía para desarrolladores

4. En Details (Detalles), elija Policies (Política).

5. En la lista de políticas, elija APIGatewayLambdaExecPolicy, elija Policy Actions (Acciones de la
política) y luego elija Delete (Eliminar). Cuando se le pregunte, elija Delete (Eliminar).

Tutorial: Crear una API de REST importando un ejemplo

Puede utilizar la consola de Amazon API Gateway para crear y probar una API REST sencilla con
integración HTTP para un sitio web PetStore. La definición de la API está preconfigurada como un
archivo de OpenAPI 2.0. Después de cargar la definición de API en API Gateway, puede utilizar la
consola de API Gateway para examinar la estructura básica de API o simplemente implementar y
probar la API.

La API de ejemplo de PetStore admite los siguientes métodos para que un cliente obtenga acceso
al sitio web de backend HTTP de http://petstore-demo-endpoint.execute-api.com/
petstore/pets.

Note
En este tutorial se utiliza un punto de conexión HTTP como ejemplo. Cuando cree sus
propias API, le recomendamos que utilice puntos de conexión HTTPS para las integraciones
HTTP.

• GET /: para leer el acceso del recurso raíz de la API que no se integra con ningún punto de
enlace de backend. API Gateway responde con información general del sitio web PetStore. Este es
un ejemplo del tipo de integración MOCK.
• GET /pets: para obtener acceso de lectura al recurso /pets de la API que se integra con el
recurso /pets de backend asignado. El backend devuelve una página de mascotas disponibles
en PetStore. Este es un ejemplo del tipo de integración HTTP. La URL del punto de enlace de
integración es http://petstore-demo-endpoint.execute-api.com/petstore/pets.
• POST /pets: para obtener acceso de escritura al recurso /pets de la API que se integra con
el recurso /petstore/pets de backend. Tras recibir una solicitud correcta, el backend agrega
la mascota especificada a PetStore y devuelve el resultado al autor de la llamada. La integración
también es HTTP.
• GET /pets/{petId}: para obtener acceso de lectura a una mascota identificada por un valor
petId tal como se especifica en una ruta variable de la URL de solicitud de entrada. Este método

Tutorial: Crear una API de REST importando un ejemplo 59

Amazon API Gateway Guía para desarrolladores

también tiene el tipo de integración HTTP. El backend devuelve la mascota especificada que se
encuentra en PetStore. La URL del punto de enlace HTTP del backend es http://petstore-
demo-endpoint.execute-api.com/petstore/pets/n, donde n es un entero como
identificador de la mascota consultada.

La API admite el acceso a CORS a través de los métodos OPTIONS del tipo de integración MOCK.
API Gateway devuelve los encabezados solicitados que admiten el acceso a CORS.

El siguiente procedimiento le guiará por los pasos para crear y probar una API a partir de un ejemplo
mediante la consola de API Gateway.

Para importar, desarrollar y probar la API de ejemplo

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Realice una de las siguientes acciones:

• Para crear la primera API, para API de REST, elija Crear.

• Si ha creado una API antes, elija Crear API y, a continuación, elija Crear para API de REST.

3. En Crear API de REST, elija API de ejemplo y, a continuación, elija Crear API para crear la API
de ejemplo.

Tutorial: Crear una API de REST importando un ejemplo 60

Amazon API Gateway Guía para desarrolladores

Puede desplazarse por la definición de OpenAPI para obtener información detallada sobre esta
API de ejemplo antes de elegir Crear API.

4. En el panel de navegación principal, elija Recursos. La API recién creada se muestra de la

siguiente forma:

Tutorial: Crear una API de REST importando un ejemplo 61

Amazon API Gateway Guía para desarrolladores

El panel Resources (Recursos) muestra la estructura de la API creada como un árbol de

nodos. Los métodos de API definidos en cada recurso son los extremos del árbol. Cuando
se selecciona un recurso, todos sus métodos se muestran en el panel Métodos situado a la
derecha. Junto a cada método se muestran el tipo de método, el tipo de integración, el tipo de
autorización y el requisito de clave de API.

5. Para ver los detalles de un método, para modificar su configuración o para probar la invocación
del método, elija el nombre del método en la lista de métodos o en el árbol de recursos. A
continuación, elegimos el POST /pets método como ejemplo:

Tutorial: Crear una API de REST importando un ejemplo 62

Amazon API Gateway Guía para desarrolladores

El panel de Ejecución de método resultante presenta una vista lógica de la estructura y el

comportamiento del método elegido (POST /pets).

La Solicitud de método y la Respuesta de método representan la interfaz de la API con el

frontend, y la Solicitud de integración y la Respuesta de integración representan la interfaz de la
API con el backend.

El cliente utiliza la API para obtener acceso a una característica del backend a través de
Solicitud de método. API Gateway traduce la solicitud del cliente, si fuera necesario, a un
formato aceptable por el backend en Solicitud de integración antes de reenviar la solicitud
entrante al backend. La solicitud transformada se conoce como la solicitud de integración. Del
mismo modo, el backend devuelve la respuesta a API Gateway en Respuesta de integración.
A continuación, API Gateway la dirige a Method Response (Respuesta de método) antes de
enviarla al cliente. De nuevo, si fuera necesario, API Gateway puede asignar los datos de la
respuesta del backend a un formulario previsto por el cliente.

En el caso del método POST de recurso de API, la carga de la solicitud del método puede
transmitirse a través de la solicitud de integración sin modificación si la carga de la solicitud de
método está en el mismo formato que la carga de la solicitud de integración.

La solicitud del método GET / usa el tipo de integración MOCK y no está vinculada a ningún
punto de enlace de backend real. La Respuesta de integración correspondiente está
configurada para devolver una página HTML estática. Cuando se llama al método, API Gateway
simplemente acepta la solicitud e inmediatamente devuelve la respuesta a la integración
configurada al cliente a través de Respuesta de método. Puede utilizar la integración simulada
para probar una API sin requerir un punto de enlace del backend. También puede utilizarla para
servir una respuesta local generada partir de una plantilla de asignación de cuerpo de respuesta.

Como desarrollador de la API, puede controlar los comportamientos de las interacciones

del frontend de la API mediante la configuración de la solicitud de método y una respuesta
de método. Puede controlar los comportamientos de las interacciones del backend de la
API mediante la configuración de la solicitud de integración y la respuesta de integración.
Estos comportamientos implican asignaciones de datos entre un método y su integración
correspondiente. Por el momento, nos centraremos en probar la API para proporcionar una
experiencia de usuario completa.

6. Seleccione la pestaña Pruebas. Puede que tenga que elegir el botón de flecha hacia la derecha
para mostrar la pestaña.

Tutorial: Crear una API de REST importando un ejemplo 63

Amazon API Gateway Guía para desarrolladores

7. Por ejemplo, para probar el método POST /pets, escriba la siguiente carga {"type":
"dog","price": 249.99} en el Cuerpo de la solicitud antes de elegir el botón Pruebas.

La entrada especifica los atributos de la mascota que deseamos añadir a la lista de mascotas en
el sitio web PetStore.

8. El resultado es el siguiente:

Tutorial: Crear una API de REST importando un ejemplo 64

Amazon API Gateway Guía para desarrolladores

La entrada Registros de la salida muestra los cambios de estado de la solicitud del método a la
solicitud de integración y de la respuesta de integración a la respuesta del método. Esto puede
resultar útil para la resolución de errores de asignación que impidan que la solicitud se realice
correctamente. En este ejemplo, la asignación no se aplica: la carga de la solicitud de método se
transfiere a través de la solicitud integración al backend y, de forma parecida, la respuesta del
backend se transfiere a través de la respuesta de integración al método de respuesta.

Para probar la API con un cliente distinto de la característica test-invoke-request de API

Gateway, primero debe implementar la API en una etapa.

9. Elija Implementar API para implementar la API de ejemplo.

Tutorial: Crear una API de REST importando un ejemplo 65

Amazon API Gateway Guía para desarrolladores

10. En Etapa, seleccione Nueva etapa y, a continuación, ingrese test.

11. (Opcional) En Description (Descripción), introduzca una descripción.

12. Elija Desplegar.
13. En el panel Etapas resultante, en Detalles de la etapa, la URL de invocación muestra la
dirección URL para invocar la solicitud del método GET / de la API.

14. Elija el icono de copiar para copiar la URL de invocación de la API y, a continuación, ingrese
la URL de invocación de la API en un navegador web. Una respuesta correcta devuelve el
resultado, generado a partir de la plantilla de asignación de la respuesta de integración.
15. En el panel de navegación Stages (Etapas), expanda la etapa test (prueba), seleccione GET
en /pets/{petId} y, a continuación, copie el valor Invoke URL (URL de invocación) de

Tutorial: Crear una API de REST importando un ejemplo 66

Amazon API Gateway Guía para desarrolladores

https://api-id.execute-api.region.amazonaws.com/test/pets/{petId}.
{petId} hace referencia a una variable de ruta.

Pegue el valor de Invoke URL (URL de invocación) (obtenido en el paso anterior) en la barra de
direcciones de un navegador, sustituyendo {petId} por, por ejemplo, 1 y, a continuación, pulse
Intro para enviar la solicitud. Debería devolverse una respuesta 200 OK con la siguiente carga
JSON:

{
"id": 1,
"type": "dog",
"price": 249.99
}

La invocación del método de la API tal como se muestra es posible porque su tipo Authorization
(Autorización) está establecido en NONE. Si se ha utilizado la autorización de AWS_IAM, firmaría
la solicitud con los protocolos Signature Version 4 (SigV4). Para ver un ejemplo de una solicitud
de este tipo, consulte the section called “Tutorial: Desarrollo de una API con integración HTTP
no de proxy”.

Desarrollo de una API de REST de API Gateway con integración HTTP

Para desarrollar una API con integración HTTP, puede utilizar la integración de proxy HTTP o la
integración HTTP personalizada. Le recomendamos utilizar la integración de proxy HTTP cada vez
que sea posible, para una configuración de API simplificada, al mismo tiempo que se proporcionan
características versátiles y potentes. La integración HTTP personalizada puede resultar atractiva si
es necesario transformar los datos de la solicitud el cliente para el backend o transformar los datos
de respuesta del backend para el cliente.

Temas
• Tutorial: Desarrollo de una API de REST con integración de proxy HTTP
• Tutorial: Desarrollo de una API de REST con integración HTTP no de proxy

Tutorial: Desarrollo de una API de REST con integración de proxy HTTP

La integración de proxy HTTP es un mecanismo sencillo, potente y versátil para desarrollar una API
que permita que una aplicación web obtenga acceso a múltiples recursos o características del punto

Desarrollo de una API con integración de HTTP 67

Amazon API Gateway Guía para desarrolladores

de enlace HTTP integrado, por ejemplo, el sitio web completo, con una configuración simplificada
de un único método de API. En la integración de proxy HTTP, API Gateway transmite la solicitud
de método enviada por el cliente al backend. Los datos de la solicitud transmitida incluyen los
encabezados de solicitud, los parámetros de cadena de consulta, las variables de ruta de la URL y
la carga. El punto de enlace de HTTP del backend o del servidor web analiza los datos de la solicitud
entrante para determinar la respuesta que devuelve. La integración de proxy HTTP permite que el
cliente y el backend interactúen directamente sin intervención de API Gateway después de haber
configurado el método de API, salvo cuando se producen problemas conocidos, como caracteres no
admitidos, que se indican en the section called “Notas importantes”.

Con el amplio recurso de proxy {proxy+} y el verbo catch-all ANY para el método HTTP, puede
utilizar una integración de proxy HTTP para crear una API de un único método de API. El método
expone el conjunto completo de recursos y operaciones HTTP de acceso público de un sitio web.
Cuando el servidor web del backend abre más recursos para acceso público, el cliente puede utilizar
estos nuevos recursos con la misma configuración de API. Para habilitar esto, el desarrollador del
sitio web debe comunicar con claridad al desarrollador del cliente cuáles son los nuevos recursos y
cuáles son las operaciones aplicables para cada uno de ellos.

Como una introducción rápida, el siguiente tutorial demuestra la integración de proxy HTTP. En
el tutorial creamos una API que utiliza la consola de API Gateway para integrarse con el sitio web
PetStore mediante un recurso de proxy genérico {proxy+} y creamos el marcador de posición del
método HTTP de ANY.

Temas

• Creación de una API con integración de proxy HTTP con la consola de API Gateway
• Probar una API con la integración de proxy HTTP

Creación de una API con integración de proxy HTTP con la consola de API Gateway

El siguiente procedimiento le guiará por los pasos para crear y probar una API con un recurso
de proxy para un backend HTTP mediante la consola de API Gateway. El backend HTTP es el
PetStore sitio web (http://petstore-demo-endpoint.execute-api.com/petstore/
pets) de Tutorial: Desarrollo de una API de REST con integración HTTP no de proxy, en el que
las capturas de pantalla se utilizan como ayudas visuales para ilustrar los elementos de IU de
API Gateway. Si es la primera vez que utiliza la consola de API Gateway para crear una API, le
recomendamos seguir esa sección en primer lugar.

Desarrollo de una API con integración de HTTP 68

Amazon API Gateway Guía para desarrolladores

Para crear un API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las
características del servicio. En REST API, elija Build (Compilación). Cuando aparezca el menú
emergente Create Example API (Crear API de ejemplo), elija OK (Aceptar).

Si esta no es la primera vez que utiliza API Gateway, elija Create API (Crear API). En REST API,
elija Build (Compilación).

3. En API name (Nombre de la API), escribaHTTPProxyAPI.

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Mantenga Tipo de punto de conexión de la API establecido en Regional.

6. Elija Crear API.

En este paso, creará una ruta de recursos de proxy de {proxy+}. Este es el marcador de posición
de cualquier punto de conexión del backend bajo http://petstore-demo-endpoint.execute-
api.com/. Por ejemplo, puede ser petstore, petstore/pets y petstore/pets/{petId}. API
Gateway crea el método ANY al crear el recurso {proxy+} y actúa como un marcador de posición
para cualquiera de los verbos HTTP admitidos en tiempo de ejecución.

Para crear un recurso /{proxy+}

1. Elija la API.

2. En el panel de navegación principal, elija Recursos.

3. Elija Crear recurso.

4. Active Recurso proxy.

5. Mantenga Ruta del recurso en /.

6. En Nombre del recurso, escriba {proxy+}.

7. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).

8. Elija Crear recurso.

Desarrollo de una API con integración de HTTP 69

Amazon API Gateway Guía para desarrolladores

En este paso, integrará el método ANY con un punto de conexión HTTP de backend mediante una
integración de proxy. En la integración de proxy, API Gateway transmite la solicitud de método
enviada por el cliente al backend sin la intervención de API Gateway.

Para crear un método ANY

1. Elija el recurso /{proxy+}.

2. Elija el método ANY.
3. Bajo el símbolo de advertencia, seleccione Editar integración. No puede implementar una API
que tenga un método sin una integración.
4. En Tipo de integración, seleccione HTTP.
5. Active Integración de proxy HTTP.
6. En Método HTTP, seleccione ANY.
7. En URL del punto de conexión, introduzca http://petstore-demo-endpoint.execute-
api.com/{proxy}.
8. Elija Guardar.

Probar una API con la integración de proxy HTTP

El éxito de una solicitud de cliente específica dependerá de lo siguiente:

• Si el backend ha puesto a disposición el punto de enlace del backend correspondiente y, si lo ha

hecho, si ha concedido los permisos de acceso requeridos.
• Si el cliente proporciona la entrada correcta.

Desarrollo de una API con integración de HTTP 70

Amazon API Gateway Guía para desarrolladores

Por ejemplo, la API de PetStore aquí utilizada no expone el recurso /petstore. Por lo tanto,
obtendrá una respuesta 404 Resource Not Found que contiene el mensaje de error de Cannot
GET /petstore.

Además, el cliente debe tener la posibilidad de gestionar el formato de salida del backend para
analizar los resultados correctamente. API Gateway no realiza mediaciones para facilitar las
interacciones entre el cliente y el backend.

Para probar una API integrada con el sitio web PetStore utilizando la integración de proxy HTTP a
través del recurso de proxy

1. Seleccione la pestaña Pruebas. Puede que tenga que elegir el botón de flecha hacia la derecha
para mostrar la pestaña.

2. En Tipo de método, seleccione GET.

3. En Ruta, debajo de proxy, introduzca petstore/pets.

4. En Cadenas de consulta, escriba type=fish.

5. Seleccione Probar.

Desarrollo de una API con integración de HTTP 71

Amazon API Gateway Guía para desarrolladores

Como que el sitio web del backend admite la solicitud GET /petstore/pets?type=fish,
devuelve una respuesta correcta similar a la siguiente:

[
{
"id": 1,
"type": "fish",
"price": 249.99
},
{
"id": 2,
"type": "fish",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99

Desarrollo de una API con integración de HTTP 72

Amazon API Gateway Guía para desarrolladores

}
]

Si intenta llamar a GET /petstore, obtendrá una respuesta 404 con un mensaje de error
Cannot GET /petstore. Esto se debe a que el backend no es compatible con la operación
especificada. Si llama a GET /petstore/pets/1, obtendrá una respuesta 200 OK con la
siguiente carga, ya que la solicitud admite el sitio web PetStore.

{
"id": 1,
"type": "dog",
"price": 249.99
}

También puede utilizar un navegador para probar la API. Implemente su API y asóciela a una etapa
para crear la URL de invocación de su API.

Para implementar su API

1. Elija Deploy API (Implementar API).

2. En Etapa, seleccione Nueva etapa.

3. En Stage name (Nombre de etapa), escriba test.

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Elija Implementar.

Ahora los clientes pueden llamar a la API.

Para invocar la API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.

3. En el panel de navegación principal, elija Etapa.

4. En Detalles de la etapa, elija el icono de copia para copiar la URL de invocación de la API.

Introduzca la URL de invocación de la API en un navegador web.

Desarrollo de una API con integración de HTTP 73

Amazon API Gateway Guía para desarrolladores

La URL completa debería ser https://abcdef123.execute-api.us-

east-2.amazonaws.com/test/petstore/pets?type=fish.

Su navegador envía una GET solicitud a la API.

5. El resultado debe ser el mismo que el que se devuelve cuando utiliza Prueba desde la consola
de API Gateway.

Tutorial: Desarrollo de una API de REST con integración HTTP no de proxy

En este tutorial creará una API desde cero utilizando la consola de Amazon API Gateway. La consola
se puede considerar como un estudio de diseño de la API y se puede utilizar para definir el ámbito de
las características de API, para probar su comportamiento, para crear la API y para implementar la
API en etapas.

Temas
• Crear una API con integración de HTTP personalizada
• (Opcional) Parámetros de la solicitud de mapeo

Crear una API con integración de HTTP personalizada

Esta sección le guía por los pasos para crear recursos, exponer métodos en un recurso, configurar
un método para lograr los comportamientos de la API deseados y probar e implementar la API.

En este paso, se crea una API vacía. En los siguientes pasos, debe crear recursos y métodos para
conectar la API al punto de conexión http://petstore-demo-endpoint.execute-api.com/
petstore/pets mediante una integración HTTP sin proxy.

Para crear un API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las
características del servicio. En REST API, elija Build (Compilación). Cuando aparezca el menú
emergente Create Example API (Crear API de ejemplo), elija OK (Aceptar).

Si esta no es la primera vez que utiliza API Gateway, elija Create API (Crear API). En REST API,
elija Build (Compilación).
3. En API name (Nombre de la API), escribaHTTPNonProxyAPI.

Desarrollo de una API con integración de HTTP 74

Amazon API Gateway Guía para desarrolladores

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Mantenga Tipo de punto de conexión de la API establecido en Regional.

6. Elija Crear API.

El árbol Resources (Recursos) muestra el recurso raíz (/) sin métodos. En este ejercicio, vamos a
desarrollar la API con la integración HTTP personalizada del sitio web de PetStore (http://petstore-
demo-endpoint.execute-api.com/petstore/pets). Con fines ilustrativos, crearemos un recurso /pets
como un elemento secundario de la raíz y expondremos un método GET en este recurso para que un
cliente pueda recuperar una lista de los elementos Pets disponibles en el sitio web de PetStore.

Para crear un recurso /pets

1. Seleccione el recurso / y, a continuación, elija Crear recurso.

2. Mantenga Recurso proxy desactivado.

3. Mantenga Ruta del recurso en /.

4. En Nombre del recurso, escriba pets.

5. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).

6. Elija Crear recurso.

En este paso, se crea un método GET en el recurso /pets. El método GET está integrado con el sitio
web http://petstore-demo-endpoint.execute-api.com/petstore/pets. Otras opciones
para un método de API incluyen las siguientes:

• POST, que se utiliza principalmente para crear recursos secundarios.

• PUT, que se utiliza principalmente para actualizar los recursos existentes (y, aunque no es
recomendable, puede utilizarse para crear recursos secundarios).

• DELETE, que se utiliza para eliminar recursos.

• PATCH, que se utiliza para actualizar los recursos.

• HEAD, que se utiliza principalmente en escenarios de pruebas. Es igual que GET, pero no
devuelve la representación de los recursos.

• OPTIONS, que pueden usar los intermediarios para obtener la información sobre las opciones de
comunicación disponibles para el servicio de destino.

Desarrollo de una API con integración de HTTP 75

Amazon API Gateway Guía para desarrolladores

En el caso del HTTP method (Método HTTP) de la solicitud de integración, debe elegir uno de los
métodos compatibles con el backend. Para HTTP o Mock integration, es razonable que la
solicitud del método y la solicitud de integración usen el mismo verbo HTTP. Para otros tipos de
integración, la solicitud del método usará probablemente un verbo HTTP diferente del de la solicitud
de integración. Por ejemplo, para llamar a una función de Lambda, la solicitud de integración debe
utilizar POST para invocar la función, mientras que la solicitud del método puede utilizar cualquier
verbo HTTP en función de la lógica de la función de Lambda.

Para crear un método GET en el recurso /pets

1. Seleccione el recurso /pets.

2. Elija Crear método.
3. En Tipo de método, seleccione GET.
4. En Tipo de integración, seleccione Integración HTTP.
5. Mantenga desactivada Integración de proxy HTTP.
6. En Método HTTP, seleccione GET.
7. En URL del punto de conexión, introduzca http://petstore-demo-endpoint.execute-
api.com/petstore/pets.
8. En Tratamiento de contenido, seleccione Acceso directo.
9. Mantenga activado Tiempo de espera predeterminado.
10. Elija Crear método.

El sitio web de PetStore le permite recuperar una lista de elementos Pet por tipo de mascota (por
ejemplo, "Dog" o "Cat") en una determinada página. Utiliza los parámetros de cadena de consulta
type y page para aceptar esta entrada. Por tanto, tenemos que añadir los parámetros de cadena
de consulta a la solicitud del método y asignarlos a las cadenas de consulta correspondientes de la
solicitud de integración.

Para añadir parámetros de cadena de consulta al método GET

1. En la sección Solicitud de método, elija Editar.

2. Elija Parámetros de cadenas de consulta de URL y luego haga lo siguiente:

a. Elija Add query string (Añadir cadena de consulta).

b. En Nombre, introduzca type.

Desarrollo de una API con integración de HTTP 76

Amazon API Gateway Guía para desarrolladores

c. Mantenga desactivados Obligatorio y Almacenamiento en caché.

Repita los pasos anteriores para crear una cadena de consulta adicional con el nombre page.

3. Seleccione Guardar.

El cliente ahora puede proporcionar un tipo de mascota y un número de página como parámetros de
cadena de consulta cuando envíe una solicitud. Estos parámetros de entrada deben mapearse a los
parámetros de cadena de consulta de la integración para reenviar los valores de entrada a nuestro
sitio web de PetStore en el backend.

Para mapear los parámetros de entrada a la solicitud de integración

1. Elija Solicitud de integración y, a continuación, Editar.

2. Elija Parámetros de cadenas de consulta de URL y luego haga lo siguiente:

a. Seleccione Añadir parámetro de cadena de consulta.

b. En Name (Nombre), ingrese type.

c. En Mapeado de, introduzca method.request.querystring.type.

d. Mantenga Almacenamiento en caché desactivado.

e. Seleccione Añadir parámetro de cadena de consulta.

f. En Name (Nombre), ingrese page.

g. En Mapeado de, introduzca method.request.querystring.page.

h. Mantenga Almacenamiento en caché desactivado.

3. Seleccione Guardar.

Para probar el API

1. Elija la pestaña Test (Prueba). Puede que tenga que elegir el botón de flecha hacia la derecha
para mostrar la pestaña.

2. En Cadenas de consulta, escriba type=Dog&page=2.

3. Seleccione Test (Probar).

El resultado es similar al siguiente:

Desarrollo de una API con integración de HTTP 77

Amazon API Gateway Guía para desarrolladores

Ahora que la prueba se ha realizado correctamente, podemos implementar la API para ponerla a
disposición del público en general.

4. Elija Deploy API (Implementar API).

5. En Etapa, seleccione Nueva etapa.

6. En Stage name (Nombre de etapa), escriba Prod.

7. (Opcional) En Description (Descripción), introduzca una descripción.

Desarrollo de una API con integración de HTTP 78

Amazon API Gateway Guía para desarrolladores

8. Elija Desplegar.
9. (Opcional) En Detalles de la etapa, para URL de invocación, puede elegir el icono de copia para
copiar la URL de invocación de su API. Puede utilizar esto con herramientas como Postman y
cURL para probar la API.

Si utiliza un SDK para crear un cliente, puede llamar a los métodos expuestos por el SDK para firmar
la solicitud. Para obtener más información, consulte los AWSSDK que desee.

Note
Cuando se realicen cambios en la API, deberá volver a implementar la API para que las
características nuevas o actualizadas estén disponibles antes de volver a invocar la URL de
la solicitud.

(Opcional) Parámetros de la solicitud de mapeo

Asignación de parámetros de solicitudes para una API de API Gateway

En este tutorial, se enseña a crear un parámetro de ruta {petId} en la URL de solicitud de método
de la API para especificar un ID de elemento, mapearlo al parámetro de ruta {id} de la URL de la
solicitud de integración y enviar la solicitud al punto de conexión HTTP

Note
Si introduce una letra con las mayúsculas o minúsculas incorrectas (por ejemplo, una letra
minúscula en lugar de una mayúscula), se producirán errores más adelante en el tutorial.

Paso 1: Crear recursos

En este paso, se crea un recurso con un parámetro de ruta {petId}.

Para crear el recurso {petID}

1. Seleccione el recurso /pets y, a continuación, elija Crear recurso.

2. Mantenga Recurso proxy desactivado.
3. En Ruta de recurso, seleccione /pets/.
4. En Nombre del recurso, escriba {petId}.

Desarrollo de una API con integración de HTTP 79

Amazon API Gateway Guía para desarrolladores

Utilice llaves ({ }) alrededor de petId para que aparezca /pets/{petId}.

5. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
6. Elija Crear recurso.

Paso 2: Crear y probar los métodos

En este paso, se crea un método GET con un parámetro de ruta {petId}.

Para configurar el método GET

1. Seleccione el recurso /{petId} y, a continuación, elija Crear método.

2. En Tipo de método, seleccione GET.
3. En Tipo de integración, seleccione Integración HTTP.
4. Mantenga desactivada Integración de proxy HTTP.
5. En Método HTTP, seleccione GET.
6. En URL del punto de conexión, introduzca http://petstore-demo-endpoint.execute-
api.com/petstore/pets/{id}
7. En Tratamiento de contenido, seleccione Acceso directo.
8. Mantenga activado Tiempo de espera predeterminado.
9. Elija Crear método.

Ahora mapee el parámetro de ruta {petId} al parámetro de ruta {id} en el punto de conexión
HTTP.

Para mapear el parámetro de ruta {petId}

1. En la sección Configuración de la solicitud de integración, elija Editar.

2. Elija los Parámetros de la ruta URL.
3. API Gateway crea un parámetro de ruta para la solicitud de integración denominado petId. Esto
no funcionará para su backend. El punto de conexión HTTP utiliza {id} como parámetro de
ruta. Cambie el nombre de petId por id.

Esto asigna el parámetro de ruta de la solicitud del método de petId al parámetro de ruta de la
solicitud de integración de id.
4. Seleccione Guardar.

Desarrollo de una API con integración de HTTP 80

Amazon API Gateway Guía para desarrolladores

Ahora pruebe el método.

Para probar el método

1. Elija la pestaña Test (Prueba). Puede que tenga que elegir el botón de flecha hacia la derecha
para mostrar la pestaña.
2. En Ruta, en petId, introduzca 4.
3. Seleccione Test (Probar).

Si todo sale bien, en Cuerpo de la respuesta se mostrará lo siguiente:

{
"id": 4,
"type": "bird",
"price": 999.99
}

Paso 3: Implementar la API

En este paso, implementará la API para que pueda empezar a llamarla fuera de la consola de API
Gateway.

Para implementar la API

1. Elija Deploy API (Implementar API).

2. En Etapa, seleccione Prod.
3. (Opcional) En Description (Descripción), introduzca una descripción.
4. Elija Deploy (Implementar).

Paso 4: Probar la API

En este paso, saldrá de la consola de API Gateway y utilizará la API para obtener acceso al punto de
enlace HTTP.

1. En el panel de navegación principal, elija Etapa.

2. En Detalles de la etapa, elija el icono de copia para copiar la URL de invocación de la API.

Debe tener un aspecto similar al siguiente:

Desarrollo de una API con integración de HTTP 81

Amazon API Gateway Guía para desarrolladores

https://my-api-id.execute-api.region-id.amazonaws.com/prod

3. Introduzca esta URL en el cuadro de dirección de una nueva pestaña del navegador y añada /
pets/4 a la URL antes de enviar su solicitud.
4. El navegador devolverá lo siguiente:

{
"id": 4,
"type": "bird",
"price": 999.99
}

Siguientes pasos

Puede personalizar aún más su API activando la validación de solicitudes, transformando los datos o
creando respuestas de puerta de enlace personalizadas.

Para explorar más formas de personalizar su API, consulte los siguientes tutoriales:

• Para obtener más información sobre la validación de solicitud, consulte Configuración de la

validación básica de solicitudes en API Gateway.
• Para obtener información sobre cómo transformar las cargas de solicitudes y respuestas, consulte
Configuración de las transformaciones de datos en API Gateway.
• Para obtener información sobre cómo crear respuestas de puerta de enlace personalizadas
consulte Configurar una respuesta de gateway para una API REST mediante la consola de API
Gateway.

Tutorial: Crear una API REST con la integración privada de API Gateway
Puede crear una API de API Gateway con integración privada para proporcionar a sus clientes
acceso a recursos HTTP/HTTPS dentro de su Amazon Virtual Private Cloud (Amazon VPC). Estos
recursos de VPC son puntos de enlace HTTP/HTTPS de una instancia EC2 situada detrás de un
balanceador de carga de red de la VPC. El balanceador de carga de red encapsula el recurso de la
VPC y direcciona las solicitudes entrantes al recurso correspondiente.

Cuando un cliente llama a la API, API Gateway se conecta al balanceador de carga de red a través
del enlace de VPC preconfigurado. El recurso VpcLink de API Gateway encapsula un enlace de la

Tutorial: Creación de una API con integración privada 82

Amazon API Gateway Guía para desarrolladores

VPC. Este es responsable de reenviar las solicitudes del método de API a los recursos de la VPC y
devuelve las respuestas del backend al intermediario. Para los desarrolladores de API, VpcLink es
funcionalmente equivalente a un punto de enlace de integración.

Para crear una API con integración privada, debe crear un nuevo VpcLink (o elegir uno existente)
que esté conectado a un balanceador de carga de red que tenga como destino los recursos de la
VPC deseados. Debe disponer de los permisos adecuados para crear y administrar un VpcLink.
A continuación, deberá configurar un método de la API e integrarlo con VpcLink estableciendo
HTTP o HTTP_PROXY como tipo de integración, VPC_LINK como tipo de conexión de integración y el
identificador VpcLink en el campo connectionId de la integración.

Note
El equilibrador de carga de red y la API deben pertenecer a la misma cuenta de AWS.

Si desea empezar a crear rápidamente una API que tenga acceso a los recursos de la VPC, le
guiaremos por los pasos esenciales para crear una API con integración privada a través de la
consola de API Gateway. Antes de crear la API, haga lo siguiente:

1. Cree un recurso de la VPC, cree o elija un balanceador de carga de red en una cuenta de la
misma región y agregue la instancia EC2 que aloja el recurso como destino del balanceador de
carga de red. Para obtener más información, consulte Configuración de un Network Load Balancer
para integraciones privadas de API Gateway.

2. Conceda los permisos necesarios para crear los enlaces VPC para integraciones privadas. Para
obtener más información, consulte Concesión de permisos para crear un enlace VPC.

Después de crear el recurso de VPC y el balanceador de carga de red con dicho recurso configurado
en sus grupos de destino, siga las instrucciones que se indican a continuación para crear una API e
integrarla con el recurso de la VPC a través de un VpcLink de una integración privada.

para crear una API con una integración privada

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las
características del servicio. En REST API, elija Build (Compilación). Cuando aparezca el menú
emergente Create Example API (Crear API de ejemplo), elija OK (Aceptar).

Tutorial: Creación de una API con integración privada 83

Amazon API Gateway Guía para desarrolladores

Si esta no es la primera vez que utiliza API Gateway, elija Create API (Crear API). En REST API,
elija Build (Compilación).
3. Cree una API de REST regional u optimizada para la periferia.
4. Seleccione la API.

5. Elija Crear método y luego haga lo siguiente:

a. En Tipo de método, seleccione GET.

b. En Tipo de integración, seleccione Enlace de VPC.

c. Active Integración de proxy de VPC.

d. En Método HTTP, seleccione GET.

e. En Enlace de VPC, seleccione [Usar variable de etapa] e introduzca

${stageVariables.vpcLinkId} en el cuadro de texto siguiente.

Puede definir la variable de etapa vpcLinkId después de implementar la API en una etapa
y establecer su valor en el ID del VpcLink.

f. En URL de punto de conexión, introduzca una URL, por ejemplo, http://

myApi.example.com.

Aquí, utilizaremos el nombre de host (por ejemplo, myApi.example.com) para definir el

encabezado Host de la solicitud de integración.

g. Elija Crear método.

Con la integración del proxy, la API está lista para implementarse. De lo contrario, debe
configurar las respuestas del método y las respuestas de integración apropiadas.
6. Elija Implementar API y, a continuación, haga lo siguiente:

a. En Etapa, seleccione Nueva etapa.

b. En Nombre de etapa, ingrese un nombre de etapa.

c. (Opcional) En Description (Descripción), introduzca una descripción.

d. Elija Implementar.

7. En la sección Detalles de la etapa, anote la URL de la invocación resultante. Lo necesitará para

invocar la API. Antes de eso, debe configurar la variable de etapa vpcLinkId.

8. En el panel Etapas, seleccione la pestaña Variables de etapa y, a continuación, haga lo

siguiente:
Tutorial: Creación de una API con integración privada 84
Amazon API Gateway Guía para desarrolladores

a. Elija Administrar variables y, a continuación, elija Agregar variable de etapa.

b. En Nombre, ingrese vpcLinkId.

c. En Valor, introduzca el ID de VPC_LINK; por ejemplo, gix6s7.

d. Elija Guardar.

Si utiliza la variable de etapa, podrá cambiar fácilmente entre los diferentes enlaces VPC de
la API; solo tendrá que modificar el valor de esta variable.

Tutorial: creación de una API REST de API Gateway con integración de

AWS

Tanto los temas Tutorial: Desarrollo de una API de REST Hello World con integración de proxy de
Lambda como Desarrollo de una API de REST de API Gateway con integración Lambda describen
cómo se debe crear una API de API Gateway para exponer la función de Lambda integrada.
Además, puede crear una API de API Gateway para exponer otros servicios de AWS, como Amazon
SNS, Amazon S3, Amazon Kinesis e incluso AWS Lambda. Esto es posible mediante la integración
de AWS. La integración de Lambda o la integración de proxy de Lambda es un caso especial, donde
la invocación de la función de Lambda se expone a través de la API de API Gateway.

Todos los servicios de AWS admiten API dedicadas para exponer sus características. Sin embargo,
los protocolos de la aplicación o las interfaces de programación probablemente difieren entre un
servicio y otro. Una API de API Gateway con la integración de AWS tiene la ventaja de proporcionar
un protocolo de aplicación coherente para que su cliente tenga acceso a diferentes servicios de
AWS.

En este tutorial, vamos a crear una API para exponer Amazon SNS. Para ver más ejemplos de
integración de una API con otros servicios de AWS, consulte Tutoriales y talleres sobre Amazon API
Gateway.

A diferencia de la integración de proxy de Lambda, no existe una integración de proxy

correspondiente para otros servicios de AWS. Por lo tanto, un método de API se integra con
una única acción de AWS. Para mayor flexibilidad, similar a la de la integración de proxy, puede
configurar una integración de proxy de Lambda. Entonces, la función de Lambda analiza y procesa
solicitudes para otras acciones de AWS.

Tutorial: Creación de una API con integración de AWS 85

Amazon API Gateway Guía para desarrolladores

API Gateway no vuelve a intentar las operaciones cuando se agota el tiempo de espera del punto
de enlace. El intermediario de la API debe implementar una lógica de reintentos para administrar los
tiempos de espera del punto de enlace.

Este tutorial se basa en las instrucciones y conceptos en Desarrollo de una API de REST de API
Gateway con integración Lambda. Si aún no ha completado ese tutorial, le sugerimos que lo haga
primero.

Temas
• Requisitos previos
• Paso 1: Crear el rol de ejecución del proxy de servicio de AWS
• Paso 2: Crear el recurso
• Paso 3: Crear el método GET
• Paso 4: Especificar la configuración del método y probar el método
• Paso 5: Implementar la API
• Paso 6: Probar la API
• Paso 7: Limpieza

Requisitos previos

Antes de empezar este tutorial, haga lo siguiente:

1. Realice los pasos que se indican en Requisitos previos para comenzar con API Gateway.
2. Cree una nueva API llamada MyDemoAPI. Para obtener más información, consulte Tutorial:
Desarrollo de una API de REST con integración HTTP no de proxy.
3. Implemente la API al menos una vez en una etapa denominada test. Para obtener más
información, consulte Implementar la API en Desarrollo de una API de REST de API Gateway
con integración Lambda.
4. Realice el resto de los pasos de Desarrollo de una API de REST de API Gateway con
integración Lambda.
5. Cree al menos un tema en Amazon Simple Notification Service (Amazon SNS). Utilizará la API
implementada para obtener una lista de temas de Amazon SNS asociados a su cuenta de AWS.
Para obtener información sobre cómo crear un tema en Amazon SNS, consulte Creación de un
tema. (No es necesario que copie el ARN del tema mencionado en el paso 5).

Tutorial: Creación de una API con integración de AWS 86

Amazon API Gateway Guía para desarrolladores

Paso 1: Crear el rol de ejecución del proxy de servicio de AWS

Para permitir que la API invoque acciones de Amazon SNS, debe tener las políticas de IAM
adecuadas asociadas a un rol de IAM.

Para crear el rol de ejecución del proxy de servicio de AWS

1. Inicie sesión en AWS Management Console y abra la consola de IAM en https://

console.aws.amazon.com/iam/.
2. Elija Roles.
3. Elija Crear rol.
4. Elija Servicio de AWS en Seleccionar el tipo de entidad de confianza y, a continuación, elija API
Gateway y seleccione Permite que API Gateway envíe registros a CloudWatch Logs.
5. Seleccione Siguiente y de nuevo Siguiente.
6. En Role name (Nombre de rol), escriba APIGatewaySNSProxyPolicy y luego elija Create role
(Crear rol).
7. En la lista Roles (Roles), elija el rol que acaba de crear. Puede que tenga que desplazarse o
usar la barra de búsqueda para encontrar el rol.
8. Para el rol seleccionado, seleccione la pestaña Agregar permisos.
9. Elija Adjuntar políticas en la lista desplegable.
10. En la barra de búsqueda, escriba AmazonSNSReadOnlyAccess y, a continuación, elija Añadir
permisos.

Note
Para simplificar el proceso, este tutorial utiliza una política administrada. Como práctica
recomendada, se deben crear políticas de IAM propias para otorgar los permisos
mínimos requeridos.

11. Anote el ARN del rol recién creado, ya que lo usará más adelante.

Paso 2: Crear el recurso

En este paso, creará un recurso que permitirá al proxy de servicio de AWS interactuar con el servicio
de AWS.

Tutorial: Creación de una API con integración de AWS 87

Amazon API Gateway Guía para desarrolladores

Para crear el recurso

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.

3. Seleccione el recurso raíz, /, representado por una única barra oblicua (/), y después elija Crear
recurso.

4. Mantenga Recurso proxy desactivado.

5. Mantenga Ruta del recurso en /.

6. En Nombre del recurso, escriba mydemoawsproxy.

7. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).

8. Elija Crear recurso.

Paso 3: Crear el método GET

En este paso, creará un método GET que permitirá al proxy de servicio de AWS interactuar con el
servicio de AWS.

Para crear el método GET

1. Seleccione el recurso /mydemoawsproxy y, a continuación, elija Crear método.

2. En el tipo de método, seleccione GET.

3. En Tipo de integración, seleccione Servicio de AWS.

4. En Región de AWS, seleccione la Región de AWS en la que ha creado el tema de Amazon SNS.
5. En Servicio de AWS, seleccione Amazon SNS.

6. Deje Subdominio de AWS en blanco.

7. En Método HTTP, seleccione GET.

8. En Tipo de acción, elija Usar nombre de acción.

9. En Nombre de la función, introduzca ListTopics.

10. En Rol de ejecución, escriba el ARN del rol para APIGatewaySNSProxyPolicy.

11. Elija Crear método.

Tutorial: Creación de una API con integración de AWS 88

Amazon API Gateway Guía para desarrolladores

Paso 4: Especificar la configuración del método y probar el método

Ahora puede probar el método GET para verificar que se ha configurado correctamente para
enumerar los temas de Amazon SNS.

Para probar el método GET

1. Elija la pestaña Test (Prueba). Puede que tenga que elegir el botón de flecha hacia la derecha
para mostrar la pestaña.

2. Seleccione Test (Probar).

El resultado muestra una respuesta similar a la siguiente:

{
"ListTopicsResponse": {
"ListTopicsResult": {
"NextToken": null,
"Topics": [
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-1"
},
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-2"
},
...
{
"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-N"
}
]
},
"ResponseMetadata": {
"RequestId": "abc1de23-45fa-6789-b0c1-d2e345fa6b78"
}
}
}

Paso 5: Implementar la API

En este paso, implementará la API para que pueda llamarla desde fuera de la consola de API
Gateway.

Tutorial: Creación de una API con integración de AWS 89

Amazon API Gateway Guía para desarrolladores

Para implementar la API

1. Elija Deploy API (Implementar API).

2. En Etapa, seleccione Nueva etapa.

3. En Stage name (Nombre de etapa), escriba test.

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Elija Deploy (Implementar).

Paso 6: Probar la API

En este paso, salga de la consola de API Gateway y utilice el proxy de servicio de AWS para
interactuar con el se rvicio de Amazon SNS.

1. En el panel de navegación principal, elija Etapa.

2. En Detalles de la etapa, elija el icono de copia para copiar la URL de invocación de la API.

Debería tener un aspecto similar al siguiente:

https://my-api-id.execute-api.region-id.amazonaws.com/test

3. Introduzca la URL en el cuadro de direcciones de una nueva pestaña del navegador.

4. Añada /mydemoawsproxy para que la URL tenga el siguiente aspecto:

https://my-api-id.execute-api.region-id.amazonaws.com/test/mydemoawsproxy

Desplácese hasta la dirección URL. Se debe mostrar información similar a la siguiente:

{"ListTopicsResponse":{"ListTopicsResult":{"NextToken": null,"Topics":
[{"TopicArn": "arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-1"},{"TopicArn":
"arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-2"},...{"TopicArn":
"arn:aws:sns:us-east-1:80398EXAMPLE:MySNSTopic-N}]},"ResponseMetadata":
{"RequestId":"abc1de23-45fa-6789-b0c1-d2e345fa6b78}}}

Paso 7: Limpieza

Puede eliminar los recursos de IAM que el proxy de servicio de AWS necesita para funcionar.
Tutorial: Creación de una API con integración de AWS 90
Amazon API Gateway Guía para desarrolladores

Warning
Si elimina un recurso de IAM que utiliza un proxy de servicio de AWS, ese proxy de servicio
de AWS y todas las API que lo utilicen dejarán de funcionar. La eliminación de un recurso
de IAM no se puede deshacer. Si desea utilizar el recurso de IAM de nuevo, debe volver a
crearlo.

Para eliminar los recursos de IAM asociados

1. Abra la consola de IAM en https://console.aws.amazon.com/iam/.

2. En el área Details (Detalles), elija Roles (Funciones).

3. Seleccione APIGatewayAWSProxyExecRole y, a continuación, elija Role Actions (Acciones de

rol), Delete Role (Eliminar rol). Cuando se le pregunte, elija Yes, Delete.

4. En el área Details (Detalles), elija Policies (Políticas).

5. Seleccione APIGatewayAWSProxyExecPolicy y, a continuación, elija Policy Actions (Acciones

de la política) y luego Delete (Eliminar). Cuando se le pregunte, elija Delete (Eliminar).

Ha llegado al final de este tutorial. Para obtener más detalles sobre la creación de una API con un
proxy de servicio de AWS, consulte Tutorial: Crear una API de REST como proxy de Amazon S3
en API Gateway, Tutorial: creación de una API REST Calc con dos integraciones de servicios de
AWS y una integración de Lambda sin proxy o Tutorial: Creación de una API de REST como proxy
de Amazon Kinesis en API Gateway.

Tutorial: creación de una API REST Calc con dos integraciones de

servicios de AWS y una integración de Lambda sin proxy

El tutorial de introducción a integraciones sin proxy solamente utiliza la integración de Lambda

Function. La integración de Lambda Function es un caso especial del tipo de integración de AWS
Service que configura por usted la mayor parte de la integración; por ejemplo, la incorporación
automática de los permisos basados en recursos necesarios para invocar la función de Lambda.
Aquí, dos de las tres integraciones usan integración de AWS Service. En este tipo de integración,
tiene más control, pero tendrá que realizar manualmente tareas como la creación y especificación de
un rol de IAM que contenga los permisos adecuados.

Tutorial: API Calc con tres integraciones 91

Amazon API Gateway Guía para desarrolladores

En este tutorial, creará una función Calc de Lambda que implementa operaciones aritméticas
básicas, aceptando y devolviendo entradas y salidas con formato JSON. A continuación, creará una
API REST y la integrará con la función de Lambda de la siguiente forma:

1. Exponiendo un método de GET en el recurso /calc para invocar la función de Lambda,

proporcionando la entrada como parámetros de cadena de consulta. (Integración de AWS
Service)
2. Exponiendo un método de POST en el recurso /calc para invocar la función de Lambda,
proporcionando la entrada en la carga de la solicitud del método. (Integración de AWS Service)
3. Exponiendo un método GET en recursos /calc/{operand1}/{operand2}/{operator}
anidados para invocar la función de Lambda, proporcionando la entrada como parámetros de
ruta. (Integración de Lambda Function)

Además de probar con este tutorial, sugerimos que estudie el archivo de definición de OpenAPI para
la API de Calc, que puede importar a API Gateway siguiendo las instrucciones de the section called
“OpenAPI”.

Temas
• Crear un rol de IAM asumible
• Creación de una función Calc de Lambda
• Probar la función Calc de Lambda
• Cree una API de Calc
• Integración 1: Crear un método GET con parámetros de consulta para llamar a la función de
Lambda
• Integración 2: Crear un método POST con una carga JSON para llamar a la función de Lambda
• Integración 3: Crear un método GET con parámetros de ruta para llamar a la función de Lambda
• Definiciones de OpenAPI de una API de ejemplo integrada con una función de Lambda

Crear un rol de IAM asumible

Para que su API invoque su función Calc de Lambda, necesitará tener un rol de IAM asumible por
API Gateway, que es un rol de IAM con la siguiente relación de confianza:

Tutorial: API Calc con tres integraciones 92

Amazon API Gateway Guía para desarrolladores

"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "apigateway.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}

El rol que cree tendrá que tener el permiso InvokeFunction de Lambda. De lo contrario, el
intermediario de la API recibirá una respuesta 500 Internal Server Error. Para dar al rol este
permiso, asociará la siguiente política de IAM:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}

A continuación, se explica cómo realizar todo esto:

Crear un rol de IAM asumible por API Gateway

1. Inicie sesión en la consola de IAM.

2. Elija Roles.
3. Elija Create Role.
4. En Select type of trusted entity (Seleccionar el tipo de entidad de confianza), elija AWS Service
(Servicio de AWS).
5. En Choose the service that will use this role (Elegir el servicio que usará este rol), elija Lambda.
6. Elija Next: Permissions (Siguiente: permisos).

Tutorial: API Calc con tres integraciones 93

Amazon API Gateway Guía para desarrolladores

7. Elija Create Policy (Crear política).

Se abrirá una nueva ventana de consola Create Policy (Crear política). En esa ventana, haga lo
siguiente:

a. En la pestaña JSON, reemplace la política existente por la siguiente:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}

b. Elija Review policy (Revisar política).

c. En Review Policy (Revisar política) haga lo siguiente:

i. En Nombre, escriba un nombre, como lambda_execute.

ii. Elija Create Policy (Crear política).
8. En la ventana de consola Create Role (Crear rol) original, haga lo siguiente:

a. En Attach permissions policies (Asociar políticas de permisos), elija la política

lambda_execute de la lista desplegable.

Si no ve su política en la lista, haga clic en el botón Refresh (Actualizar) en la parte superior

de la lista. (¡No actualice la página del navegador!)
b. Elija Next: Tags (Siguiente: Etiquetas).
c. Elija Next: Review.
d. En Role name (Nombre de rol), escriba un nombre como
lambda_invoke_function_assume_apigw_role.
e. Elija Create role (Crear rol).
9. Elija el rol lambda_invoke_function_assume_apigw_role de la lista de roles.
10. Seleccione la pestaña Trust Relationships (Relaciones de confianza).

Tutorial: API Calc con tres integraciones 94

Amazon API Gateway Guía para desarrolladores

11. Elija Edit trust relationship (Editar relación de confianza).

12. Reemplace la política existente por la siguiente:

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"lambda.amazonaws.com",
"apigateway.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}

13. Elija Update Trust Policy.

14. Anote el ARN del rol que acaba de crear. Lo necesitará más adelante.

Creación de una función Calc de Lambda

A continuación, creará una función de Lambda con la consola de Lambda.

1. En la consola de Lambda, elija Create function (Crear función).

2. Elija Author from Scratch (Crear desde cero).

3. En Name (Nombre) escriba Calc.

4. En Tiempo de ejecución, elija el último tiempo de ejecución de Node.js o Python compatible.

5. Elija Crear función.

6. Copie la siguiente función de Lambda en el tiempo de ejecución de su preferencia y péguela en

el editor de código en la consola de Lambda.

Tutorial: API Calc con tres integraciones 95

Amazon API Gateway Guía para desarrolladores

Node.js

export const handler = async function (event, context) {

console.log("Received event:", JSON.stringify(event));

if (
event.a === undefined ||
event.b === undefined ||
event.op === undefined
) {
return "400 Invalid Input";
}

const res = {};

res.a = Number(event.a);
res.b = Number(event.b);
res.op = event.op;
if (isNaN(event.a) || isNaN(event.b)) {
return "400 Invalid Operand";
}
switch (event.op) {
case "+":
case "add":
res.c = res.a + res.b;
break;
case "-":
case "sub":
res.c = res.a - res.b;
break;
case "*":
case "mul":
res.c = res.a * res.b;
break;
case "/":
case "div":
if (res.b == 0) {
return "400 Divide by Zero";
} else {
res.c = res.a / res.b;
}
break;
default:
return "400 Invalid Operator";

Tutorial: API Calc con tres integraciones 96

Amazon API Gateway Guía para desarrolladores

return res;
};

Python

import json

def lambda_handler(event, context):

print(event)

try:
(event['a']) and (event['b']) and (event['op'])
except KeyError:
return '400 Invalid Input'

try:
res = {"a": float(event['a']), "b": float(event['b']), "op":
event['op']}
except ValueError:
return '400 Invalid Operand'

if event['op'] == '+':
res['c'] = res['a'] + res['b']
elif event['op'] == '-':
res['c'] = res['a'] - res['b']
elif event['op'] == '*':
res['c'] = res['a'] * res['b']
elif event['op'] == '/':
if res['b'] == 0:
return '400 Divide by Zero'
else:
res['c'] = res['a'] / res['b']
else:
return '400 Invalid Operator'

return res

7. Bajo Execution role (Rol de ejecución) elija Choose an existing role (Elegir un rol existente).

8. Escriba el ARN del rol para el rol lambda_invoke_function_assume_apigw_role que creó

anteriormente.

Tutorial: API Calc con tres integraciones 97

Amazon API Gateway Guía para desarrolladores

9. Elija Deploy (Implementar).

Esta función requiere dos operandos (a y b) y un operador (op) del parámetro de entrada event. La
entrada es un objeto JSON con el siguiente formato:

{
"a": "Number" | "String",
"b": "Number" | "String",
"op": "String"
}

Esta función devuelve el resultado calculado (c) y la entrada. Si se trata de una entrada no válida,
la función devuelve el valor null o la cadena "Invalid op" como resultado. La salida tiene el siguiente
formato JSON:

{
"a": "Number",
"b": "Number",
"op": "String",
"c": "Number" | "String"
}

Debe probar la función en la consola de Lambda antes de integrarla con la API en el siguiente paso.

Probar la función Calc de Lambda

Indicamos aquí como probar la función Calc en la consola de Lambda.

1. Elija la pestaña Prueba.

2. Para el nombre del evento de prueba, escriba calc2plus5.
3. Sustituya la definición del evento de prueba por lo siguiente:

{
"a": "2",
"b": "5",

Tutorial: API Calc con tres integraciones 98

Amazon API Gateway Guía para desarrolladores

"op": "+"
}

4. Seleccione Save.
5. Seleccione Test (Probar).

6. Expanda Execution result: succeeded (Resultado de la ejecución: correcta). Debería ver lo

siguiente:

{
"a": 2,
"b": 5,
"op": "+",
"c": 7
}

Cree una API de Calc

El procedimiento siguiente describe cómo crear una API para la función Calc de Lambda que acaba
de crear. En las siguientes secciones, añadirá recursos y métodos.

Para crear un API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las
características del servicio. En REST API, elija Build (Compilación). Cuando aparezca el menú
emergente Create Example API (Crear API de ejemplo), elija OK (Aceptar).

Si esta no es la primera vez que utiliza API Gateway, elija Create API (Crear API). En REST API,
elija Build (Compilación).

3. En API name (Nombre de la API), escribaLambdaCalc.

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Mantenga Tipo de punto de conexión de la API establecido en Regional.

6. Seleccione Create API (Crear API).

Tutorial: API Calc con tres integraciones 99

Amazon API Gateway Guía para desarrolladores

Integración 1: Crear un método GET con parámetros de consulta para llamar a la

función de Lambda

Mediante la creación de un método GET que pasa los parámetros de cadenas de consulta a la
función de Lambda, habilita la API que se va a invocar desde un navegador. Este método puede ser
útil, en especial para las API que permiten acceso abierto.

Después de crear una API, se crea un recurso. Normalmente, los recursos de la API están
organizados en un árbol de recursos de acuerdo con la lógica de la aplicación. Para este paso, debe
crear un recurso /calc.

Para crear un recurso /calc

1. Elija Crear recurso.

2. Mantenga Recurso proxy desactivado.
3. Mantenga Ruta del recurso en /.
4. En Nombre del recurso, escriba calc.
5. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
6. Elija Crear recurso.

Mediante la creación de un método GET que pasa los parámetros de cadenas de consulta a la
función de Lambda, habilita la API que se va a invocar desde un navegador. Este método puede ser
útil, en especial para las API que permiten acceso abierto.

En este método, Lambda requiere que se use la solicitud POST para invocar cualquier función de
Lambda. Este ejemplo muestra que el método HTTP en una solicitud de método del frontend puede
diferir de la solicitud de integración en el backend.

Para crear un método GET

1. Seleccione el recurso calc y, a continuación, elija Crear método.

2. En Tipo de método, seleccione GET.
3. En Tipo de integración, seleccione Servicio de AWS.
4. En Región de AWS, seleccione la Región de AWS donde creó la función de Lambda.
5. En Servicio de AWS, seleccione Lambda.
6. Deje Subdominio de AWS en blanco.

Tutorial: API Calc con tres integraciones 100

Amazon API Gateway Guía para desarrolladores

7. En Método HTTP, seleccione POST.

8. En Tipo de acción, elija Usar sustitución de ruta. Esta opción nos permite especificar el ARN de
la acción Invoke para ejecutar nuestra función Calc.
9. En Sustitución de ruta, escriba 2015-03-31/functions/arn:aws:lambda:us-
east-2:account-id:function:Calc/invocations. En account-id, introduzca su
identificador de Cuenta de AWS. En us-east-2, introduzca la Región de AWS donde creó la
función de Lambda.
10. En Rol de ejecución, escriba el ARN del rol para
lambda_invoke_function_assume_apigw_role.
11. No cambie la configuración de Caché de credenciales ni Tiempo de espera predeterminado.
12. Elija Crear método.

Ahora, vamos a configurar los parámetros de consulta para el método GET en el recurso /calc para
que pueda recibir la entrada en nombre de la función de Lambda del backend.

Para configurar parámetros de cadenas de consulta

1. En la sección Solicitud de método, elija Editar.

2. En Validador de solicitud, seleccione Validar parámetros de cadena de consulta y encabezados.
Esta configuración hará que se devuelva un mensaje de error si el cliente no especifica los
parámetros requeridos.
3. Elija Parámetros de cadenas de consulta de URL y haga lo siguiente:

a. Elija Add query string (Añadir cadena de consulta).

b. En Nombre, ingrese operand1.
c. Active la opción Obligatorio.
d. Mantenga Almacenamiento en caché desactivado.

Repita los mismos pasos y cree una cadena de consulta llamada operand2 y una cadena de
consulta llamada operator.
4. Elija Guardar.

Ahora, vamos a crear una plantilla de mapeo para convertir las cadenas de consulta proporcionadas
por el cliente en la carga de la solicitud de integración, tal y como requiere la función Calc. Esta

Tutorial: API Calc con tres integraciones 101

Amazon API Gateway Guía para desarrolladores

plantilla mapea los tres parámetros de cadena de consulta declarados en Solicitud de método en
los valores de propiedad designados del objeto JSON como entrada a la función de Lambda del
backend. El objeto JSON transformado se incluirá como la carga de la solicitud de integración.

Para mapear los parámetros de entrada a la solicitud de integración

1. En la sección Solicitud de integración, elija Editar.

2. En Acceso directo de cuerpo de la solicitud, elija Cuando no haya plantillas definidas

(recomendado).

3. Elija Plantillas de mapeo.

4. Elija Add mapping template (Añadir plantilla de asignación).

5. En Tipo de contenido, ingrese application/json.

6. En Cuerpo de la plantilla, introduzca el siguiente código:

{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": "$input.params('operator')"
}

7. Elija Guardar.

Ahora puede probar el método GET para verificar que se ha configurado correctamente para invocar
la función de Lambda.

Para probar el método GET

1. Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para
mostrar la pestaña.

2. En Cadenas de consulta, escriba operand1=2&operand2=3&operator=+.

3. Seleccione Test (Probar).

El resultado debe ser parecido al siguiente:

Tutorial: API Calc con tres integraciones 102

Amazon API Gateway Guía para desarrolladores

Integración 2: Crear un método POST con una carga JSON para llamar a la función de
Lambda

Al crear un método POST con una carga JSON para llamar a la función de Lambda, lo hace de tal
manera que el cliente debe proporcionar la entrada necesaria a la función del backend en el cuerpo
de la solicitud. Para garantizar que el cliente carga los datos de entrada correctos, habilitará la
validación de solicitudes en la carga.

Tutorial: API Calc con tres integraciones 103

Amazon API Gateway Guía para desarrolladores

Para crear un método POST con una carga JSON

1. Seleccione el recurso calc y, a continuación, elija Crear método.

2. En Tipo de método, seleccione POST.
3. En Tipo de integración, seleccione Servicio de AWS.
4. En Región de AWS, seleccione la Región de AWS donde creó la función de Lambda.
5. En Servicio de AWS, seleccione Lambda.
6. Deje Subdominio de AWS en blanco.
7. En Método HTTP, seleccione POST.
8. En Tipo de acción, elija Usar sustitución de ruta. Esta opción nos permite especificar el ARN de
la acción Invoke para ejecutar nuestra función Calc.
9. En Sustitución de ruta, escriba 2015-03-31/functions/arn:aws:lambda:us-
east-2:account-id:function:Calc/invocations. En account-id, introduzca su
identificador de Cuenta de AWS. En us-east-2, introduzca la Región de AWS donde creó la
función de Lambda.
10. En Rol de ejecución, escriba el ARN del rol para
lambda_invoke_function_assume_apigw_role.
11. No cambie la configuración de Caché de credenciales ni Tiempo de espera predeterminado.
12. Elija Crear método.

Ahora vamos a crear un modelo de entrada para describir la estructura de los datos de entrada y
validar el cuerpo de la solicitud entrante.

Para crear el modelo de entrada

1. En el panel de navegación principal, elija Modelos.

2. Seleccione Crear modelo.
3. En Nombre, ingrese input.
4. En Tipo de contenido, ingrese application/json.

Si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de

la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido,
introduzca $default.
5. En Esquema del modelo, escriba el siguiente modelo:

Tutorial: API Calc con tres integraciones 104

Amazon API Gateway Guía para desarrolladores

{
"type":"object",
"properties":{
"a":{"type":"number"},
"b":{"type":"number"},
"op":{"type":"string"}
},
"title":"input"
}

6. Seleccione Crear modelo.

Ahora cree un modelo de salida. Este modelo describe la estructura de datos de la salida calculada
desde el backend. Se puede utilizar para asignar los datos de la respuesta de integración a un
modelo diferente. Este tutorial se basa en el comportamiento de paso a través y no utiliza este
modelo.

Para crear un modelo de salida

1. Seleccione Crear modelo.

2. En Nombre, ingrese output.

3. En Tipo de contenido, ingrese application/json.

Si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de

la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido,
introduzca $default.
4. En Esquema del modelo, escriba el siguiente modelo:

{
"type":"object",
"properties":{
"c":{"type":"number"}
},
"title":"output"
}

5. Seleccione Crear modelo.

Tutorial: API Calc con tres integraciones 105

Amazon API Gateway Guía para desarrolladores

Ahora cree un modelo de resultados. Este modelo describe la estructura de datos de los datos de
respuesta devueltos. Hace referencia a los esquemas de entrada y salida definidos en su API.

Para crear un modelo de resultados

1. Seleccione Crear modelo.

2. En Nombre, ingrese result.

3. En Tipo de contenido, ingrese application/json.

Si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de

la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido,
introduzca $default.

4. En Esquema del modelo, introduzca el siguiente modelo con su restapi-id. El restapi-id

aparece entre paréntesis en la parte superior de la consola en el siguiente flujo: API Gateway
> APIs > LambdaCalc (abc123).

{
"type":"object",
"properties":{
"input":{
"$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/
input"
},
"output":{
"$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/
output"
}
},
"title":"result"
}

5. Seleccione Crear modelo.

Ahora configure la solicitud de método de su método POST para habilitar la validación de la solicitud
en el cuerpo de la solicitud entrante.

1. En el panel de navegación principal, seleccione Recursos y, a continuación, seleccione el

método POST en el árbol de recursos.

2. En la sección Configuración de solicitud de método, elija Editar.

Tutorial: API Calc con tres integraciones 106

Amazon API Gateway Guía para desarrolladores

3. En Validador de solicitudes, seleccione Validar cuerpo.

4. Seleccione Cuerpo de la solicitud y, a continuación, seleccione Añadir modelo.
5. En Tipo de contenido, ingrese application/json.

Si no se encuentra ningún tipo de contenido coincidente, no se realiza la validación de

la solicitud. Para utilizar el mismo modelo independientemente del tipo de contenido,
introduzca $default.
6. En Modelo, seleccione entrada.
7. Elija Guardar.

Ahora puede probar el método POST para verificar que se ha configurado correctamente para invocar
la función de Lambda.

Para probar el método POST

1. Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para
mostrar la pestaña.
2. En Cuerpo de la solicitud, pegue la siguiente carga JSON.

{
"a": 1,
"b": 2,
"op": "+"
}

3. Seleccione Probar.

Debería ver los siguientes datos de salida:

{
"a": 1,
"b": 2,
"op": "+",
"c": 3
}

Tutorial: API Calc con tres integraciones 107

Amazon API Gateway Guía para desarrolladores

Integración 3: Crear un método GET con parámetros de ruta para llamar a la función
de Lambda

Ahora creará un método GET en un recurso especificado por una secuencia de parámetros de ruta
para llamar a la función de Lambda del backend. Los valores de los parámetros de ruta especifican
los datos de entrada a la función de Lambda. Definirá una plantilla de asignación para asignar los
valores de los parámetros de ruta entrantes a la carga de la solicitud de integración necesaria.

La estructura de recursos de la API resultante será como la siguiente:

Para crear un recurso /{operand1}/{operand2}/{operator}

1. Elija Crear recurso.

2. En Ruta de recurso, seleccione /calc.
3. En Nombre del recurso, escriba {operand1}.
4. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
5. Elija Crear recurso.
6. En Ruta de recurso, seleccione /calc/{operand1}/.
7. En Nombre del recurso, escriba {operand2}.
8. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).

Tutorial: API Calc con tres integraciones 108

Amazon API Gateway Guía para desarrolladores

9. Elija Crear recurso.

10. En Ruta de recurso, seleccione /calc/{operand1}/{operand2}/.
11. En Nombre del recurso, escriba {operator}.
12. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
13. Elija Crear recurso.

Esta vez utilizará la integración de Lambda incorporada en la consola de API Gateway para
configurar la integración del método.

Para configurar una integración del método

1. Seleccione el recurso /{operand1}/{operand2}/{operator} y, a continuación, elija Crear método.

2. En Tipo de método, seleccione GET.
3. En Tipo de integración, seleccione Lambda.
4. Mantenga desactivada la Integración de proxy Lambda.
5. En Función de Lambda, seleccione la Región de AWS donde creó su función de Lambda e
introduzca Calc.
6. Mantenga activado Tiempo de espera predeterminado.
7. Elija Crear método.

Ahora debe crear una plantilla de mapeo para mapear los tres parámetros de la ruta de la URL,
declarados cuando se creó el recurso /calc/{operand1}/{operand2}/{operator}, con los valores de
propiedad designados en el objeto JSON. Como las rutas URL deben estar codificadas como
direcciones URL, el operador de división debe especificarse como %2F en lugar de /. Esta plantilla
traduce %2F en '/' antes de pasarlo a la función de Lambda.

Para crear una plantilla de mapeo

1. En la sección Solicitud de integración, elija Editar.

2. En Acceso directo de cuerpo de la solicitud, elija Cuando no haya plantillas definidas
(recomendado).
3. Elija Plantillas de mapeo.
4. En Tipo de contenido, ingrese application/json.
5. En Cuerpo de la plantilla, introduzca el siguiente código:

Tutorial: API Calc con tres integraciones 109

Amazon API Gateway Guía para desarrolladores

{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op":
#if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
}

6. Elija Guardar.

Ahora puede probar el método GET para verificar que se ha configurado correctamente para invocar
la función de Lambda y pasar el resultado original a través de la respuesta de integración sin
mapear.

Para probar el método GET

1. Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para
mostrar la pestaña.

2. Para Ruta, haga lo siguiente:

a. En operand1, introduzca 1.

b. En operand2, introduzca 1.

c. En operator, introduzca +.

3. Seleccione Test (Probar).

4. El resultado debe tener el siguiente aspecto:

Tutorial: API Calc con tres integraciones 110

Amazon API Gateway Guía para desarrolladores

A continuación, creará el modelo de la estructura de datos de la carga de la respuesta del método

detrás del esquema result.

De forma predeterminada, el cuerpo de la respuesta del método se asigna a un modelo vacío. Esto
hará que el cuerpo de la respuesta de integración se transfiera sin asignación. Sin embargo, cuando
genere un SDK para alguno de los lenguajes con establecimiento inflexible de tipos, como Java u
Objective-C, los usuarios del SDK recibirán un objeto vacío como resultado. Para garantizar que
el cliente REST y los clientes del SDK reciban el resultado deseado, debe crear los datos de la
respuesta mediante un esquema predefinido. A continuación, definirá un modelo para el cuerpo

Tutorial: API Calc con tres integraciones 111

Amazon API Gateway Guía para desarrolladores

de la respuesta del método y cómo crear una plantilla de asignación para traducir el cuerpo de la
respuesta de integración al cuerpo de la respuesta del método.

Para crear una respuesta del método

1. En la pestaña Respuesta del método, en Respuesta 200, elija Editar.

2. En Cuerpo de la respuesta, seleccione Agregar modelo.

3. En Tipo de contenido, ingrese application/json.

4. En Modelo, seleccione resultado.

5. Elija Guardar.

Al configurar el modelo para el cuerpo de la respuesta del método, nos aseguramos de que los datos
de la respuesta se emitan en el objeto result de un determinado SDK. Para asegurarse de que
los datos de la respuesta de integración se asignen según corresponda, necesitará una plantilla de
asignación.

Para crear una plantilla de mapeo

1. En la sección Respuesta de integración, en Predeterminado: respuesta, elija Editar.

2. Elija Plantillas de mapeo.

3. En Tipo de contenido, ingrese application/json.

4. En Generar plantilla, seleccione resultado.

5. Modifique la plantilla de mapeo generada para que coincida con lo siguiente:

#set($inputRoot = $input.path('$'))
{
"input" : {
"a" : $inputRoot.a,
"b" : $inputRoot.b,
"op" : "$inputRoot.op"
},
"output" : {
"c" : $inputRoot.c
}
}

6. Elija Guardar.

Tutorial: API Calc con tres integraciones 112

Amazon API Gateway Guía para desarrolladores

Para probar la plantilla de mapeo

1. Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para
mostrar la pestaña.
2. Para Ruta, haga lo siguiente:

a. En operand1, introduzca 1.
b. En operand2, introduzca 2.

c. En operator, introduzca +.

3. Seleccione Probar.

4. El resultado será parecido al siguiente:

{
"input": {
"a": 1,
"b": 2,
"op": "+"
},
"output": {
"c": 3
}
}

En este momento, solo puede llamar a la API utilizando la característica Prueba de la consola de
API Gateway. Para hacer que esté disponible para los clientes, debe implementar la API. Asegúrese
siempre para volver a implementar la API, cada vez que agrega, modifica o elimina un recurso o un
método, actualizar una asignación de datos o actualiza la configuración de la etapa. De lo contrario,
las nuevas características o actualizaciones no estarán disponibles para los clientes de la API.

Para implementar la API

1. Elija Deploy API (Implementar API).

2. En Etapa, seleccione Nueva etapa.

3. En Stage name (Nombre de etapa), escriba Prod.

4. (Opcional) En Description (Descripción), introduzca una descripción.

5. Elija Implementar.

Tutorial: API Calc con tres integraciones 113

Amazon API Gateway Guía para desarrolladores

6. (Opcional) En Detalles de la etapa, para URL de invocación, puede elegir el icono de copia para
copiar la URL de invocación de su API. Puede utilizar esto con herramientas como Postman y
cURL para probar la API.

Note
Vuelva a implementar la API cada vez que agrega, modifica o elimina un recurso o un
método, actualiza una asignación de datos o actualiza la configuración de la etapa. De
lo contrario, las nuevas características o actualizaciones no estarán disponibles para los
clientes de la API.

Definiciones de OpenAPI de una API de ejemplo integrada con una función de

Lambda

OpenAPI 2.0

{
"swagger": "2.0",
"info": {
"version": "2017-04-20T04:08:08Z",
"title": "LambdaCalc"
},
"host": "uojnr9hd57.execute-api.us-east-1.amazonaws.com",
"basePath": "/test",
"schemes": [
"https"
],
"paths": {
"/calc": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{

Tutorial: API Calc con tres integraciones 114

Amazon API Gateway Guía para desarrolladores

"name": "operand2",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "query",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
},
"headers": {
"operand_1": {
"type": "string"
},
"operand_2": {
"type": "string"
},
"operator": {
"type": "string"
}
}
}
},
"x-amazon-apigateway-request-validator": "Validate query string parameters
and headers",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",

Tutorial: API Calc con tres integraciones 115

Amazon API Gateway Guía para desarrolladores

"responseParameters": {
"method.response.header.operator": "integration.response.body.op",
"method.response.header.operand_2": "integration.response.body.b",
"method.response.header.operand_1": "integration.response.body.a"
},
"responseTemplates": {
"application/json": "#set($res = $input.path('$'))\n{\n \"result
\": \"$res.a, $res.b, $res.op => $res.c\",\n \"a\" : \"$res.a\",\n \"b\" :
\"$res.b\",\n \"op\" : \"$res.op\",\n \"c\" : \"$res.c\"\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/
arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_match",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n
\"b\": \"$input.params('operand2')\", \n \"op\": \"$input.params('operator')\"
\n}"
},
"type": "aws"
}
},
"post": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"in": "body",
"name": "Input",
"required": true,
"schema": {
"$ref": "#/definitions/Input"
}
}
],
"responses": {
"200": {
"description": "200 response",

Tutorial: API Calc con tres integraciones 116

Amazon API Gateway Guía para desarrolladores

"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-request-validator": "Validate body",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"a
\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : $inputRoot.op,\n \"c\" :
$inputRoot.c\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/
arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"type": "aws"
}
}
},
"/calc/{operand1}/{operand2}/{operator}": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "path",

Tutorial: API Calc con tres integraciones 117

Amazon API Gateway Guía para desarrolladores

"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n
\"input\" : {\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" :
\"$inputRoot.op\"\n },\n \"output\" : {\n \"c\" : $inputRoot.c\n }\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/
arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",
\n \"b\": \"$input.params('operand2')\",\n \"op\":
#if($input.params('operator')=='%2F')\"/\"#{else}\"$input.params('operator')\"#end
\n \n}"
},
"contentHandling": "CONVERT_TO_TEXT",
"type": "aws"
}
}

Tutorial: API Calc con tres integraciones 118

Amazon API Gateway Guía para desarrolladores

}
},
"definitions": {
"Input": {
"type": "object",
"required": [
"a",
"b",
"op"
],
"properties": {
"a": {
"type": "number"
},
"b": {
"type": "number"
},
"op": {
"type": "string",
"description": "binary op of ['+', 'add', '-', 'sub', '*', 'mul', '%2F',
'div']"
}
},
"title": "Input"
},
"Output": {
"type": "object",
"properties": {
"c": {
"type": "number"
}
},
"title": "Output"
},
"Result": {
"type": "object",
"properties": {
"input": {
"$ref": "#/definitions/Input"
},
"output": {
"$ref": "#/definitions/Output"
}
},

Tutorial: API Calc con tres integraciones 119

Amazon API Gateway Guía para desarrolladores

"title": "Result"
}
},
"x-amazon-apigateway-request-validators": {
"Validate body": {
"validateRequestParameters": false,
"validateRequestBody": true
},
"Validate query string parameters and headers": {
"validateRequestParameters": true,
"validateRequestBody": false
}
}
}

Tutorial: Crear una API de REST como proxy de Amazon S3 en API

Gateway

Para ilustrar cómo usar una API de REST en API Gateway como proxy de Amazon S3, en esta
sección se describe cómo crear y configurar una API de REST para exponer las siguientes
operaciones de Amazon S3:

• Exponer GET en el recurso raíz de la API para enumerar todos los buckets de Amazon S3 de un
intermediario.

• Exponer GET en un recurso de carpeta para ver una lista de todos los objetos de un bucket de
Amazon S3.

• Exponer GET en un recurso de carpeta o elemento para ver o descargar un objeto de un bucket de
Amazon S3.

Es posible que desee importar la API de ejemplo como proxy de Amazon S3, tal y como se muestra
en Definiciones de OpenAPI de la API de ejemplo como un proxy de Amazon S3. Este ejemplo
contiene métodos más expuestos. Para obtener instrucciones sobre cómo importar una API mediante
la definición de OpenAPI, consulte Configuración de una API de REST mediante OpenAPI.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 120
Amazon API Gateway Guía para desarrolladores

Note
Para integrar su API de API Gateway con Amazon S3, debe elegir una región en la que
estén disponibles los servicios API Gateway y Amazon S3. Para obtener información sobre
la disponibilidad en función de la región, consulte Cuotas y puntos de enlace de Amazon API
Gateway.

Temas
• Configurar permisos de IAM para que la API invoque acciones de Amazon S3
• Crear recursos de API para representar recursos de Amazon S3
• Exponer un método de API para enumerar los buckets de Amazon S3 del intermediario
• Exponer métodos de API para tener acceso a un bucket de Amazon S3
• Exponer métodos de API para tener acceso a un objeto de Amazon S3 en un bucket
• Definiciones de OpenAPI de la API de ejemplo como un proxy de Amazon S3
• Llamar a la API mediante un cliente API de REST

Configurar permisos de IAM para que la API invoque acciones de Amazon S3

Para permitir que la API invoque las acciones de Amazon S3, debe tener las políticas de IAM
adecuadas asociadas a un rol de IAM.

Para crear el rol de ejecución del proxy de servicio de AWS

1. Inicie sesión en la AWS Management Console y abra la consola de IAM en https://

console.aws.amazon.com/iam/.
2. Elija Roles.
3. Elija Crear rol.
4. Elija Servicio de AWS en Seleccionar el tipo de entidad de confianza y, a continuación, elija API
Gateway y seleccione Permite que API Gateway envíe registros a CloudWatch Logs.
5. Seleccione Siguiente y de nuevo Siguiente.
6. En Role name (Nombre de rol), escriba APIGatewayS3ProxyPolicy y luego elija Create role
(Crear rol).
7. En la lista Roles (Roles), elija el rol que acaba de crear. Puede que tenga que desplazarse o
usar la barra de búsqueda para encontrar el rol.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 121
Amazon API Gateway Guía para desarrolladores

8. Para el rol seleccionado, seleccione la pestaña Agregar permisos.

9. Elija Adjuntar políticas en la lista desplegable.
10. En la barra de búsqueda, escriba AmazonS3FullAccess y, a continuación, elija Añadir
permisos.

Note
Para simplificar el proceso, este tutorial utiliza una política administrada. Como práctica
recomendada, se deben crear políticas de IAM propias para otorgar los permisos
mínimos requeridos.

11. Anote el ARN del rol recién creado, ya que lo usará más adelante.

Crear recursos de API para representar recursos de Amazon S3

Utilizaremos el recurso raíz (/) de la API como contenedor de buckets de Amazon S3 de un

intermediario autenticado. También crearemos los recursos Folder y Item para representar un
bucket de Amazon S3 determinado y un objeto de Amazon S3 determinado, respectivamente. El
intermediario especificará el nombre de carpeta y la clave de objeto en forma de parámetros de ruta
como parte de la URL de una solicitud.

Note
Al acceder a los objetos cuya clave de objeto incluye / o cualquier otro carácter especial,
el carácter estar codificado en la URL. Por ejemplo, test/test.txt deben codificarse en
test%2Ftest.txt.

Para crear un recurso de API que exponga las características del servicio Amazon S3

1. En la misma Región de AWS que creó el bucket de Amazon S3, cree una API llamada MyS3.
Este recurso raíz de la API (/) representa el servicio Amazon S3. En este paso, creará dos
recursos adicionales,/{folder} y /{item}.
2. Seleccione el recurso raíz de la API y, a continuación, elija Crear recurso.
3. Mantenga Recurso proxy desactivado.
4. En Ruta de recurso, seleccione /.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 122
Amazon API Gateway Guía para desarrolladores

5. En Nombre del recurso, escriba {folder}.

6. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
7. Elija Crear recurso.
8. Seleccione el recurso /{folder} y, a continuación, elija Crear recurso.
9. Siga los pasos anteriores para crear un recurso secundario de /{folder} denominado {item}.

Su API final debería parecerse a la siguiente:

Exponer un método de API para enumerar los buckets de Amazon S3 del

intermediario

Obtener la lista de buckets de Amazon S3 del intermediario implica invocar la acción GET Service
en Amazon S3. En el recurso raíz de la API, (/), cree el método GET. Configure el método GET para
realizar la integración con Amazon S3, tal y como se indica a continuación.

Para crear e inicializar el método GET / de la API

1. Seleccione el recurso / y, a continuación, elija Crear método.

2. En el tipo de método, seleccione GET.
3. En Tipo de integración, seleccione Servicio de AWS.
4. Para Región de AWS, seleccione la Región de AWS donde creó su bucket de Amazon S3.
5. Para Servicio de AWS, elija Amazon Simple Storage Service.
6. Deje Subdominio de AWS en blanco.
7. En Método HTTP, seleccione GET.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 123
Amazon API Gateway Guía para desarrolladores

8. En Tipo de acción, elija Usar sustitución de ruta. Al anular la ruta, API Gateway reenvía la
solicitud del cliente a Amazon S3 como la solicitud del tipo de ruta de la API de REST de
Amazon S3 correspondiente, en la cual un recurso de Amazon S3 se expresa por la ruta de
recursos del patrón s3-host-name/bucket/key. API Gateway establece el s3-host-name y
transmite el bucket y la key especificados por el cliente a Amazon S3.
9. En Sustitución de ruta, escriba /.
10. En Rol de ejecución, escriba el ARN del rol para APIGatewayS3ProxyPolicy.
11. Elija Crear método.

Esta configuración integra la solicitud GET https://your-api-host/stage/ del frontend con la

solicitud GET https://your-s3-host/ del backend.

Note
Tras la configuración inicial, puede modificar estos ajustes en la página Integration Request
(Solicitud de integración) del método.

Para controlar quién puede llamar a este método de nuestra API, activamos la marca de autorización
del método y la establecemos en AWS_IAM.

Para permitir que IAM controle el acceso al método GET /

1. En la pestaña Solicitud de método, en Configuración de solicitud de método, elija Editar.

2. En Autorización, en el menú desplegable, seleccione AWS_IAM.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 124
Amazon API Gateway Guía para desarrolladores

3. Elija Guardar.

Para que nuestra API devuelva respuestas correctas y excepciones al intermediario, vamos a
declarar las respuestas 200, 400 y 500 en Method Response (Respuesta de método). Utilizamos el
mapeo predeterminado para las respuestas 200, de forma que las respuestas del backend del código
de estado no declarado aquí se devuelvan al intermediario como respuestas 200.

Para declarar tipos de respuestas para el método GET /

1. En la pestaña Respuesta del método, en Respuesta 200, elija Editar.

2. Elija Añadir encabezado y haga lo siguiente:

a. En Nombre de encabezado, escriba Content-Type.

b. Elija Add header (Añadir encabezado).

Repita estos pasos para crear un encabezado Timestamp y un encabezado Content-Length.

3. Elija Guardar.

4. En la pestaña Método de respuesta, en Respuestas de método, seleccione Crear respuesta.

5. En Código de estado HTTP, introduzca 400.

No establezca ningún encabezado para esta respuesta.

6. Elija Guardar.

7. Repita los pasos siguientes para crear la respuesta 500.

No establezca ningún encabezado para esta respuesta.

Como la respuesta de integración correcta de Amazon S3 devuelve la lista de buckets como una
carga XML y la respuesta de método predeterminada de API Gateway devuelve una carga JSON,
debemos mapear el valor del parámetro del encabezado Content-Type del backend con su homólogo
en el frontend. De lo contrario, el cliente recibirá application/json para el tipo de contenido
cuando el cuerpo de la respuesta sea en realidad una cadena XML. El siguiente procedimiento
muestra cómo realizar esta configuración. Además, también queremos mostrar al cliente otros
parámetros de encabezado, como Date y Content-Length.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 125
Amazon API Gateway Guía para desarrolladores

Para configurar asignaciones de encabezado de respuesta para el método GET /

1. En la pestaña Respuesta de integración, en Predeterminado: respuesta, seleccione Editar.

2. Para el encabezado Content-Length, introduzca
integration.response.header.Content-Length en el valor de mapeo.
3. Para el encabezado Content-Type, introduzca integration.response.header.Content-
Type en el valor de mapeo.
4. Para el encabezado Timestamp, introduzca integration.response.header.Date en el
valor de mapeo.
5. Elija Guardar. El resultado debería ser similar al siguiente:

6. En la pestaña Respuesta de integración, en Respuestas de integración, seleccione Crear

respuesta.
7. En HTTP status regex (Expresión regular de estado HTTP), escriba 4\d{2}. Esto asigna todos
los códigos de estado de respuesta HTTP 4xx a la respuesta del método.
8. En Código de estado de respuesta del método, seleccione 400.
9. Seleccione Crear.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 126
Amazon API Gateway Guía para desarrolladores

10. Repita los siguientes pasos para crear una respuesta de integración para la respuesta del
método 500. En HTTP status regex (Expresión regular de estado HTTP), escriba 5\d{2}.

Como práctica recomendada, vamos a probar nuestra API tal y como está configurada de momento.

Para probar el método GET /

1. Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para
mostrar la pestaña.

2. Seleccione Probar. El resultado debe ser similar al de la siguiente imagen:

Exponer métodos de API para tener acceso a un bucket de Amazon S3

Para trabajar con un bucket de Amazon S3, exponemos el método GET en el recurso /{folder}
para mostrar los objetos de un bucket. Las instrucciones son similares a las que se describen en

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 127
Amazon API Gateway Guía para desarrolladores

Exponer un método de API para enumerar los buckets de Amazon S3 del intermediario. Para ver
más métodos, puede importar la API de ejemplo aquí, Definiciones de OpenAPI de la API de ejemplo
como un proxy de Amazon S3.

Para exponer el método GET en un recurso de carpeta

1. Seleccione el recurso /{folder} y, a continuación, elija Crear método.

2. En el tipo de método, seleccione GET.

3. En Tipo de integración, seleccione Servicio de AWS.

4. Para Región de AWS, seleccione la Región de AWS donde creó su bucket de Amazon S3.

5. Para Servicio de AWS, elija Amazon Simple Storage Service.

6. Deje Subdominio de AWS en blanco.

7. En Método HTTP, seleccione GET.

8. En Tipo de acción, elija Usar sustitución de ruta.

9. En Sustitución de ruta, escriba {bucket}.

10. En Rol de ejecución, escriba el ARN del rol para APIGatewayS3ProxyPolicy.

11. Elija Crear método.

Establezca el parámetro de ruta {folder} en la URL del punto de conexión de Amazon S3. Debe
mapear el parámetro de ruta {folder} de la solicitud de método al parámetro de ruta {bucket} de
la solicitud de integración.

Para mapear {folder} a {bucket}:

1. En la pestaña Solicitud de integración, en Configuración de la solicitud de integración, seleccione

Editar.
2. Elija Parámetros de la ruta URL y, a continuación, elija Agregar parámetro de ruta.

3. En Nombre, ingrese bucket.

4. En Mapeado de, introduzca method.request.path.folder. La configuración debería

parecerse a la siguiente:

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 128
Amazon API Gateway Guía para desarrolladores

5. Elija Guardar.

Ahora, pruebe la API.

Para probar el método /{folder} GET

1. Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para
mostrar la pestaña.

2. En Ruta, para la carpeta, introduzca el nombre de tu bucket.

3. Seleccione Probar.

El resultado de la prueba incluirá una lista de los objetos del bucket.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 129
Amazon API Gateway Guía para desarrolladores

Exponer métodos de API para tener acceso a un objeto de Amazon S3 en un bucket

Amazon S3 admite las acciones GET, DELETE, HEAD, OPTIONS, POST y PUT para acceder a
objetos de un bucket determinado y administrarlos. En este tutorial, expondrá un método GET del
recurso {folder}/{item} para obtener una imagen de un bucket. Para ver más aplicaciones del

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 130
Amazon API Gateway Guía para desarrolladores

recurso {folder}/{item}, consulte la API de ejemplo, Definiciones de OpenAPI de la API de

ejemplo como un proxy de Amazon S3.

Para exponer el método GET en un recurso de elemento

1. Seleccione el recurso /{item} y, a continuación, elija Crear método.

2. En el tipo de método, seleccione GET.
3. En Tipo de integración, seleccione Servicio de AWS.
4. Para Región de AWS, seleccione la Región de AWS donde creó su bucket de Amazon S3.
5. Para Servicio de AWS, elija Amazon Simple Storage Service.
6. Deje Subdominio de AWS en blanco.
7. En Método HTTP, seleccione GET.
8. En Tipo de acción, elija Usar sustitución de ruta.
9. En Sustitución de ruta, introduzca {bucket}/{object}.
10. En Rol de ejecución, escriba el ARN del rol para APIGatewayS3ProxyPolicy.
11. Elija Crear método.

Establezca los parámetros de ruta {folder} y {item} en la URL del punto de conexión de
Amazon S3. Debe mapear el parámetro de ruta de la solicitud de método al parámetro de ruta de la
solicitud de integración.

En este paso, hará lo siguiente:

• Mapee el parámetro de ruta {folder} de la solicitud de método al parámetro de ruta {bucket}

de la solicitud de integración.
• Mapee el parámetro de ruta {item} de la solicitud de método al parámetro de ruta {object} de
la solicitud de integración.

Para mapear {folder} a {bucket} y {item} a {object}

1. En la pestaña Solicitud de integración, en Configuración de la solicitud de integración, seleccione

Editar.
2. Elija los Parámetros de la ruta URL.
3. Elija Añadir parámetro de ruta.
4. En Nombre, ingrese bucket.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 131
Amazon API Gateway Guía para desarrolladores

5. En Mapeado de, introduzca method.request.path.folder.

6. Elija Añadir parámetro de ruta.

7. En Nombre, ingrese object.

8. En Mapeado de, introduzca method.request.path.item.

9. Elija Guardar.

Para probar el método /{folder}/{object} GET

1. Elija la pestaña Prueba. Puede que tenga que elegir el botón de flecha hacia la derecha para
mostrar la pestaña.

2. En Ruta, para la carpeta, introduzca el nombre de tu bucket.

3. En Ruta, para el elemento, introduzca el nombre de un elemento.

4. Seleccione Probar.

El cuerpo de la respuesta incluirá el contenido del elemento.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 132
Amazon API Gateway Guía para desarrolladores

La solicitud devuelve correctamente el texto sin formato ("Hello world") como el contenido del
archivo especificado (test.txt) en el bucket de Amazon S3 indicado (DOC-EXAMPLE-BUCKET).

Para descargar o cargar archivos binarios, que en API Gateway se considera cualquier cosa que no
sea contenido JSON codificado en UTF-8, es necesaria una configuración adicional de la API. Esto
se detalla de la siguiente manera:

Descargar o cargar archivos binarios de S3

1. Registrar los tipos de archivo del archivo afectado en los tipos "binaryMediaTypes" de la API.
Puede hacer lo siguiente en la consola:

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 133
Amazon API Gateway Guía para desarrolladores

a. Elija Configuración de API para la API.

b. En Tipos de medios binarios, seleccione Gestionar tipos de medios.
c. Seleccione Añadir tipo de medio binario y, a continuación, introduzca el tipo de medio
requerido, por ejemplo, image/png.
d. Elija Save Changes (Guardar cambios), para guardar la configuración.
2. Añada las cabeceras Content-Type (para cargar) y/o Accept (para descargar) a la solicitud
del método para exigir que el cliente especifique el tipo de medios binarios necesarios y
asignarlos a la solicitud de integración.
3. Establezca la opción Content Handling (Tratamiento de contenido) en Passthrough en la
solicitud de integración (para cargar) y en una respuesta de integración (para descargar).
Asegúrese de que no se define ninguna plantilla de mapeo para el tipo de contenido afectado.
Para obtener más información, consulte Comportamiento del acceso directo a la integración y
Seleccionar una plantilla de asignación VTL.

El límite de tamaño de carga es 10 MB. Consulte Cuotas de API Gateway para configurar y ejecutar
una API REST.

Asegúrese de que los archivos en Amazon S3 incluyen los tipos de contenido correctos en los
metadatos. Para contenido multimedia que se puede transmitir, es posible que los metadatos deban
incluir Content-Disposition:inline.

Para obtener más información sobre la compatibilidad con datos binarios en API Gateway, consulte
Conversiones de tipo de contenido en API Gateway.

Definiciones de OpenAPI de la API de ejemplo como un proxy de Amazon S3

En las siguientes definiciones de OpenAPI, se describe una API que funciona como proxy de
Amazon S3. Esta API contiene más operaciones de Amazon S3 que la API que creó en el tutorial.
Los siguientes métodos se exponen en las definiciones de OpenAPI:

• Exponer GET en el recurso raíz de la API para enumerar todos los buckets de Amazon S3 de un
intermediario.
• Exponer GET en un recurso de carpeta para ver una lista de todos los objetos de un bucket de
Amazon S3.
• Exponer PUT en un recurso de carpeta para agregar un bucket a Amazon S3.
• Exponer DELETE en un recurso de carpeta para eliminar un bucket de Amazon S3.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 134
Amazon API Gateway Guía para desarrolladores

• Exponer GET en un recurso de carpeta o elemento para ver o descargar un objeto de un bucket de
Amazon S3.
• Exponer PUT en un recurso de carpeta o elemento para cargar un objeto en un bucket de Amazon
S3.
• Exponer HEAD en un recurso de carpeta o elemento para obtener los metadatos de objeto en un
bucket de Amazon S3.
• Exponer DELETE en un recurso de carpeta o elemento para eliminar un objeto de un bucket de
Amazon S3.

Para obtener instrucciones sobre cómo importar una API mediante la definición de OpenAPI,
consulte Configuración de una API de REST mediante OpenAPI.

Para obtener instrucciones sobre cómo crear una API similar, consulte Tutorial: Crear una API de
REST como proxy de Amazon S3 en API Gateway.

Para obtener información sobre cómo invocar esta API mediante Postman, que admite la
autorización de IAM AWS, consulte Llamar a la API mediante un cliente API de REST.

OpenAPI 2.0

{
"swagger": "2.0",
"info": {
"version": "2016-10-13T23:04:43Z",
"title": "MyS3"
},
"host": "9gn28ca086.execute-api.{region}.amazonaws.com",
"basePath": "/S3",
"schemes": [
"https"
],
"paths": {
"/": {
"get": {
"produces": [
"application/json"
],
"responses": {
"200": {
"description": "200 response",

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 135
Amazon API Gateway Guía para desarrolladores

"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Timestamp": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type",
"method.response.header.Content-Length":
"integration.response.header.Content-Length",
"method.response.header.Timestamp":
"integration.response.header.Date"
}
},

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 136
Amazon API Gateway Guía para desarrolladores

"5\\d{2}": {
"statusCode": "500"
}
},
"uri": "arn:aws:apigateway:us-west-2:s3:path//",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
}
},
"/{folder}": {
"get": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Date": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 137
Amazon API Gateway Guía para desarrolladores

},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type",
"method.response.header.Date": "integration.response.header.Date",
"method.response.header.Content-Length":
"integration.response.header.content-length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
},
"put": {
"produces": [
"application/json"
],
"parameters": [

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 138
Amazon API Gateway Guía para desarrolladores

{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 139
Amazon API Gateway Guía para desarrolladores

"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type",
"method.response.header.Content-Length":
"integration.response.header.Content-Length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder",
"integration.request.header.Content-Type":
"method.request.header.Content-Type"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",
"httpMethod": "PUT",
"type": "aws"
}
},
"delete": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 140
Amazon API Gateway Guía para desarrolladores

"headers": {
"Date": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type",
"method.response.header.Date": "integration.response.header.Date"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"passthroughBehavior": "when_no_match",

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 141
Amazon API Gateway Guía para desarrolladores

"httpMethod": "DELETE",
"type": "aws"
}
}
},
"/{folder}/{item}": {
"get": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"content-type": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 142
Amazon API Gateway Guía para desarrolladores

}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.content-type":
"integration.response.header.content-type",
"method.response.header.Content-Type":
"integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "aws"
}
},
"head": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 143
Amazon API Gateway Guía para desarrolladores

"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 144
Amazon API Gateway Guía para desarrolladores

"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type",
"method.response.header.Content-Length":
"integration.response.header.Content-Length"
}
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "HEAD",
"type": "aws"
}
},
"put": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 145
Amazon API Gateway Guía para desarrolladores

}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type",
"method.response.header.Content-Length":
"integration.response.header.Content-Length"
}
},

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 146
Amazon API Gateway Guía para desarrolladores

"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder",
"integration.request.header.Content-Type":
"method.request.header.Content-Type"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "PUT",
"type": "aws"
}
},
"delete": {
"produces": [
"application/json"
],
"parameters": [
{
"name": "item",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "folder",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Length": {
"type": "string"
},

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 147
Amazon API Gateway Guía para desarrolladores

"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response"
},
"500": {
"description": "500 response"
}
},
"security": [
{
"sigv4": []
}
],
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"4\\d{2}": {
"statusCode": "400"
},
"default": {
"statusCode": "200"
},
"5\\d{2}": {
"statusCode": "500"
}
},
"requestParameters": {
"integration.request.path.object": "method.request.path.item",
"integration.request.path.bucket": "method.request.path.folder"
},
"uri": "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"passthroughBehavior": "when_no_match",
"httpMethod": "DELETE",
"type": "aws"
}
}
}
},
"securityDefinitions": {
"sigv4": {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 148
Amazon API Gateway Guía para desarrolladores

"type": "apiKey",
"name": "Authorization",
"in": "header",
"x-amazon-apigateway-authtype": "awsSigv4"
}
},
"definitions": {
"Empty": {
"type": "object",
"title": "Empty Schema"
}
}
}

OpenAPI 3.0

{
"openapi" : "3.0.1",
"info" : {
"title" : "MyS3",
"version" : "2016-10-13T23:04:43Z"
},
"servers" : [ {
"url" : "https://9gn28ca086.execute-api.{region}.amazonaws.com/{basePath}",
"variables" : {
"basePath" : {
"default" : "S3"
}
}
} ],
"paths" : {
"/{folder}" : {
"get" : {
"parameters" : [ {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 149
Amazon API Gateway Guía para desarrolladores

"description" : "400 response",

"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Date" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 150
Amazon API Gateway Guía para desarrolladores

"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" :
"integration.response.header.Content-Type",
"method.response.header.Date" : "integration.response.header.Date",
"method.response.header.Content-Length" :
"integration.response.header.content-length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"put" : {
"parameters" : [ {
"name" : "Content-Type",
"in" : "header",
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 151
Amazon API Gateway Guía para desarrolladores

"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "PUT",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" :
"integration.response.header.Content-Type",
"method.response.header.Content-Length" :
"integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 152
Amazon API Gateway Guía para desarrolladores

"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder",
"integration.request.header.Content-Type" :
"method.request.header.Content-Type"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"delete" : {
"parameters" : [ {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Date" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 153
Amazon API Gateway Guía para desarrolladores

"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "DELETE",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" :
"integration.response.header.Content-Type",
"method.response.header.Date" : "integration.response.header.Date"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
},
"/{folder}/{item}" : {
"get" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 154
Amazon API Gateway Guía para desarrolladores

"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"content-type" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 155
Amazon API Gateway Guía para desarrolladores

"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.content-type" :
"integration.response.header.content-type",
"method.response.header.Content-Type" :
"integration.response.header.Content-Type"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"put" : {
"parameters" : [ {
"name" : "Content-Type",
"in" : "header",
"schema" : {
"type" : "string"
}
}, {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 156
Amazon API Gateway Guía para desarrolladores

}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "PUT",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 157
Amazon API Gateway Guía para desarrolladores

"responseParameters" : {
"method.response.header.Content-Type" :
"integration.response.header.Content-Type",
"method.response.header.Content-Length" :
"integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder",
"integration.request.header.Content-Type" :
"method.request.header.Content-Type"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"delete" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 158
Amazon API Gateway Guía para desarrolladores

"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "DELETE",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200"
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 159
Amazon API Gateway Guía para desarrolladores

"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
},
"head" : {
"parameters" : [ {
"name" : "item",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
}, {
"name" : "folder",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }
},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 160
Amazon API Gateway Guía para desarrolladores

"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "HEAD",
"uri" : "arn:aws:apigateway:us-west-2:s3:path/{bucket}/{object}",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {
"method.response.header.Content-Type" :
"integration.response.header.Content-Type",
"method.response.header.Content-Length" :
"integration.response.header.Content-Length"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"requestParameters" : {
"integration.request.path.object" : "method.request.path.item",
"integration.request.path.bucket" : "method.request.path.folder"
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
},
"/" : {
"get" : {
"responses" : {
"400" : {
"description" : "400 response",
"content" : { }

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 161
Amazon API Gateway Guía para desarrolladores

},
"500" : {
"description" : "500 response",
"content" : { }
},
"200" : {
"description" : "200 response",
"headers" : {
"Content-Length" : {
"schema" : {
"type" : "string"
}
},
"Timestamp" : {
"schema" : {
"type" : "string"
}
},
"Content-Type" : {
"schema" : {
"type" : "string"
}
}
},
"content" : {
"application/json" : {
"schema" : {
"$ref" : "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration" : {
"credentials" : "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"httpMethod" : "GET",
"uri" : "arn:aws:apigateway:us-west-2:s3:path//",
"responses" : {
"4\\d{2}" : {
"statusCode" : "400"
},
"default" : {
"statusCode" : "200",
"responseParameters" : {

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 162
Amazon API Gateway Guía para desarrolladores

"method.response.header.Content-Type" :
"integration.response.header.Content-Type",
"method.response.header.Content-Length" :
"integration.response.header.Content-Length",
"method.response.header.Timestamp" :
"integration.response.header.Date"
}
},
"5\\d{2}" : {
"statusCode" : "500"
}
},
"passthroughBehavior" : "when_no_match",
"type" : "aws"
}
}
}
},
"components" : {
"schemas" : {
"Empty" : {
"title" : "Empty Schema",
"type" : "object"
}
}
}
}

Llamar a la API mediante un cliente API de REST

Para proporcionar un tutorial completo, ahora mostraremos cómo llamar a la API mediante Postman,
que admite la autorización de IAM de AWS.

Para llamar a nuestra API de proxy de Amazon S3 mediante Postman

1. Implemente o vuelva a implementar la API. Anote la URL base de la API que se muestra junto a
Invoke URL (URL de invocación) en la parte superior de Stage Editor (Editor de etapas).
2. Inicie Postman.
3. Elija Authorization (Autorización) y, a continuación, elija AWS Signature. Escriba el ID de clave
de acceso y la clave de acceso secreta del usuario de IAM en los campos de entrada AccessKey
y SecretKey, respectivamente. Escriba la región de AWS en la que se va a implementar la API

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 163
Amazon API Gateway Guía para desarrolladores

en el cuadro de texto Región de AWS. Escriba execute-api en el campo de entrada Service

Name (Nombre del servicio).

Puede crear un par de claves desde la pestaña Security Credentials (Credenciales de

seguridad) de su cuenta de usuario de IAM en la consola de administración de IAM.

4. Para agregar un bucket denominado apig-demo-5 a su cuenta de Amazon S3 en la región

{region}:

Note
Asegúrese de que el nombre de bucket sea único de forma global.

a. Seleccione PUT en la lista desplegable de métodos y escriba la URL del método

(https://api-id.execute-api.aws-region.amazonaws.com/stage/folder-
name)

b. Establezca el valor del encabezado Content-Type en application/xml. Es posible que

necesite eliminar todos los encabezados existentes antes de configurar el tipo de contenido.

c. Elija el elemento de menú Body (Cuerpo) y escriba el siguiente fragmento XML como
cuerpo de la solicitud:

<CreateBucketConfiguration>
<LocationConstraint>{region}</LocationConstraint>
</CreateBucketConfiguration>

d. Elija Send (Enviar) para enviar la solicitud. Si todo va bien, debería recibir una respuesta
200 OK con una carga vacía.

5. Para añadir un archivo de texto a un bucket, siga las instrucciones anteriores. Si especifica el
nombre de bucket de apig-demo-5 para {folder} y el nombre de archivo Readme.txt para
{item} en la dirección URL y proporciona la cadena de texto Hello, World! como contenido
de archivo (con lo que se convierte en la carga de la solicitud), la respuesta será

PUT /S3/apig-demo-5/Readme.txt HTTP/1.1

Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T062647Z

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 164
Amazon API Gateway Guía para desarrolladores

Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/execute-

api/aws4_request, SignedHeaders=content-length;content-type;host;x-amz-date,
Signature=ccadb877bdb0d395ca38cc47e18a0d76bb5eaf17007d11e40bf6fb63d28c705b
Cache-Control: no-cache
Postman-Token: 6135d315-9cc4-8af8-1757-90871d00847e

Hello, World!

Si todo sale bien, debe recibir una respuesta 200 OK con una carga vacía.

6. Para obtener el contenido del archivo Readme.txt que acaba de añadir al bucket apig-
demo-5, envíe una solicitud GET como la siguiente:

GET /S3/apig-demo-5/Readme.txt HTTP/1.1

Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T063759Z
Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/
execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date,
Signature=ba09b72b585acf0e578e6ad02555c00e24b420b59025bc7bb8d3f7aed1471339
Cache-Control: no-cache
Postman-Token: d60fcb59-d335-52f7-0025-5bd96928098a

Si todo sale bien, debe recibir una respuesta 200 OK con la cadena de texto Hello, World!
como la carga.

7. Para mostrar los elementos del bucket apig-demo-5, envíe la siguiente solicitud:

GET /S3/apig-demo-5 HTTP/1.1

Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T064324Z
Authorization: AWS4-HMAC-SHA256 Credential=access-key-id/20161015/{region}/
execute-api/aws4_request, SignedHeaders=content-type;host;x-amz-date,
Signature=4ac9bd4574a14e01568134fd16814534d9951649d3a22b3b0db9f1f5cd4dd0ac
Cache-Control: no-cache
Postman-Token: 9c43020a-966f-61e1-81af-4c49ad8d1392

Si todo sale bien, debe recibir una respuesta 200 OK con una carga XML que muestre un único
elemento en el bucket especificado, a menos que haya añadido más archivos al bucket antes de
enviar esta solicitud.

Tutorial: Crear una API de REST como proxy de Amazon S3 en API Gateway 165
Amazon API Gateway Guía para desarrolladores

<?xml version="1.0" encoding="UTF-8"?>

<ListBucketResult xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
<Name>apig-demo-5</Name>
<Prefix></Prefix>
<Marker></Marker>
<MaxKeys>1000</MaxKeys>
<IsTruncated>false</IsTruncated>
<Contents>
<Key>Readme.txt</Key>
<LastModified>2016-10-15T06:26:48.000Z</LastModified>
<ETag>"65a8e27d8879283831b664bd8b7f0ad4"</ETag>
<Size>13</Size>
<Owner>
<ID>06e4b09e9d...603addd12ee</ID>
<DisplayName>user-name</DisplayName>
</Owner>
<StorageClass>STANDARD</StorageClass>
</Contents>
</ListBucketResult>

Note
Para cargar o descargar una imagen, debe configurar el tratamiento de contenido como
CONVERT_TO_BINARY.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis en

API Gateway

Esta página describe cómo crear y configurar una API de REST con una integración del tipo AWS
para tener acceso a Kinesis.

Note
Para integrar la API de API Gateway con Kinesis, debe elegir una región en la que estén
disponibles los servicios API Gateway y Kinesis. Para conocer la disponibilidad de las
regiones, consulte Puntos de enlace y cuotas de servicio.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 166
Amazon API Gateway Guía para desarrolladores

A modo de ejemplo, crearemos una API de ejemplo para permitir que un cliente haga lo siguiente:

1. Listado de los flujos disponibles para el usuario en Kinesis

2. Creación, descripción o eliminación de un flujo especificado
3. Leer registros de datos o escribir registros de datos en un flujo especificado

Para realizar las tareas anteriores, la API expone métodos en diferentes recursos para invocar lo
siguiente, respectivamente:

1. La acción ListStreams en Kinesis

2. La acción CreateStream, DescribeStream o DeleteStream
3. La acción GetRecords o PutRecords (incluida la acción PutRecord) en Kinesis

En concreto, crearemos la API mediante las operaciones siguientes:

• Exponer un método HTTP GET en el recurso /streams de la API e integrar el método con la
acción ListStreams de Kinesis para mostrar los flujos de la cuenta del intermediario.
• Exponer un método HTTP POST en el recurso /streams/{stream-name} de la API e integrar
el método con la acción CreateStream de Kinesis para crear un flujo con nombre en la cuenta del
intermediario.
• Exponer un método HTTP GET en el recurso /streams/{stream-name} de la API e integrar el
método con la acción DescribeStream de Kinesis para describir un flujo con nombre en la cuenta
del intermediario.
• Exponer un método HTTP DELETE en el recurso /streams/{stream-name} de la API e
integrar el método con la acción DeleteStream de Kinesis para eliminar un flujo en la cuenta del
intermediario.
• Exponer un método PUT HTTP en el recurso /streams/{stream-name}/record de la API e
integrar el método con la acción PutRecord de Kinesis. Esto permite que el cliente añada un solo
registro de datos al flujo con nombre.
• Exponer un método PUT HTTP en el recurso /streams/{stream-name}/records de la API e
integrar el método con la acción PutRecords de Kinesis. Esto permite que el cliente añada una lista
de registros de datos al flujo con nombre.
• Exponer un método GET HTTP en el recurso /streams/{stream-name}/records de la API
e integrar el método con la acción GetRecords de Kinesis. Esto permite que el cliente muestre
registros de datos en el flujo con nombre, con un iterador de fragmento especificado. Un iterador

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 167
Amazon API Gateway Guía para desarrolladores

de fragmento especifica la posición del fragmento desde la que se empiezan a leer los registros de
datos de forma secuencial.
• Exponer un método GET HTTP en el recurso /streams/{stream-name}/sharditerator de
la API e integrar el método con la acción GetShardIterator de Kinesis. Este método auxiliar debe
proporcionarse en la acción ListStreams de Kinesis.

Puede aplicar las instrucciones que se presentan aquí a otras acciones de Kinesis. Para obtener la
lista completa de las acciones de Kinesis, consulte Referencia de API de Amazon Kinesis.

En lugar de utilizar la consola de API Gateway para crear la API de ejemplo, puede importar la
API de ejemplo en API Gateway mediante la API de importación de API Gateway. Para obtener
información acerca de cómo utilizar Import API, consulte Configuración de una API de REST
mediante OpenAPI.

Creación de un rol y una política de IAM para que la API tenga acceso a Kinesis

Para que la API pueda invocar las acciones de Kinesis necesarias, debe tener las políticas de IAM
adecuadas asociadas a un rol de IAM.

Para crear el rol de ejecución del proxy de servicio de AWS

1. Inicie sesión en AWS Management Console y abra la consola de IAM en https://

console.aws.amazon.com/iam/.
2. Elija Roles.
3. Elija Crear rol.
4. Elija Servicio de AWS en Seleccionar el tipo de entidad de confianza y, a continuación, elija API
Gateway y seleccione Permite que API Gateway envíe registros a CloudWatch Logs.
5. Seleccione Siguiente y de nuevo Siguiente.
6. En Role name (Nombre de rol), escriba APIGatewayKinesisProxyPolicy y luego elija
Create role (Crear rol).
7. En la lista Roles (Roles), elija el rol que acaba de crear. Puede que tenga que desplazarse o
usar la barra de búsqueda para encontrar el rol.
8. Para el rol seleccionado, seleccione la pestaña Agregar permisos.
9. Elija Adjuntar políticas en la lista desplegable.
10. En la barra de búsqueda, escriba AmazonKinesisFullAccess y, a continuación, elija Añadir
permisos.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 168
Amazon API Gateway Guía para desarrolladores

Note
Para simplificar el proceso, este tutorial utiliza una política administrada. Como práctica
recomendada, se deben crear políticas de IAM propias para otorgar los permisos
mínimos requeridos.

11. Anote el ARN del rol recién creado, ya que lo usará más adelante.

Inicio de la creación de una API como proxy de Kinesis

Utilice los siguientes pasos para crear la API en la consola de API Gateway.

Para crear una API como un proxy de servicio de AWS para Kinesis

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Si es la primera vez que utiliza API Gateway, verá una página en la que aparecen las
características del servicio. En REST API, elija Build (Compilación). Cuando aparezca el menú
emergente Create Example API (Crear API de ejemplo), elija OK (Aceptar).

Si esta no es la primera vez que utiliza API Gateway, elija Create API (Crear API). En REST API,
elija Build (Compilación).
3. Elija New API (Nueva API).
4. En API name (Nombre de la API), escriba KinesisProxy. Mantenga los valores
predeterminados en todos los demás campos.
5. (Opcional) En Description (Descripción), introduzca una descripción.
6. Seleccione Create API (Crear API).

Una vez creada la API, la consola de API Gateway mostrará la página Resources (Recursos), que
contiene únicamente el recurso raíz de la API (/).

Lista de flujos en Kinesis

Kinesis es compatible con la acción ListStreams con la siguiente llamada a la API de REST:

POST /?Action=ListStreams HTTP/1.1

Host: kinesis.<region>.<domain>
Content-Length: <PayloadSizeBytes>

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 169
Amazon API Gateway Guía para desarrolladores

User-Agent: <UserAgentString>
Content-Type: application/x-amz-json-1.1
Authorization: <AuthParams>
X-Amz-Date: <Date>

{
...
}

En la anterior solicitud de API de REST, la acción se especifica en el parámetro de consulta Action.

También puede, en su lugar, especificar la acción en un encabezado X-Amz-Target:

POST / HTTP/1.1
Host: kinesis.<region>.<domain>
Content-Length: <PayloadSizeBytes>
User-Agent: <UserAgentString>
Content-Type: application/x-amz-json-1.1
Authorization: <AuthParams>
X-Amz-Date: <Date>
X-Amz-Target: Kinesis_20131202.ListStreams
{
...
}

En este tutorial usamos el parámetro de consulta para especificar la acción.

Para exponer una acción de Kinesis en la API, agregue un recurso /streams a la raíz de la API. A
continuación, defina un método GET en el recurso e integre el método en la acción ListStreams de
Kinesis.

En el siguiente procedimiento se describe cómo listar los flujos de Kinesis con la consola de API
Gateway.

Para listar los flujos de Kinesis con la consola de API Gateway

1. Seleccione el recurso / y, a continuación, elija Crear recurso.

2. En Nombre del recurso, escriba streams.
3. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
4. Elija Crear recurso.
5. Elija el recurso /streams y luego Crear método. A continuación, haga lo siguiente:

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 170
Amazon API Gateway Guía para desarrolladores

a. En Tipo de método, seleccione GET.

Note
El verbo HTTP de un método invocado por un cliente puede ser diferente del verbo
HTTP de una integración requerida por el backend. Aquí elegimos GET porque
mostrar los flujos es intuitivamente una operación READ.

b. En Tipo de integración, seleccione Servicio de AWS.

c. En Región de AWS, seleccione la Región de AWS donde creó el flujo de Kinesis.

d. En Servicio de AWS, seleccione Kinesis.

e. Deje Subdominio de AWS en blanco.

f. En HTTP method (Método HTTP), elija POST.

Note
Aquí elegimos POST porque Kinesis requiere que la acción ListStreams también
se invoque.

g. En Tipo de acción, elija Usar nombre de acción.

h. En Nombre de la función, introduzca ListStreams.

i. En Rol de ejecución, escriba el ARN del rol de ejecución.

j. Deje el valor predeterminado Acceso directo en Tratamiento de contenido.

k. Elija Crear método.

6. En la pestaña Solicitud de integración, en Configuración de la solicitud de integración, seleccione

Editar.
7. En Acceso directo de cuerpo de la solicitud, elija Cuando no haya plantillas definidas
(recomendado).

8. Elija Parámetros de encabezados de consulta de URL y luego haga lo siguiente:

a. Seleccione Añadir parámetros de encabezados de solicitud.

b. En Name (Nombre), ingrese Content-Type.

c. En Mapeado de, introduzca 'application/x-amz-json-1.1'.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 171
Amazon API Gateway Guía para desarrolladores

Hemos utilizado un mapeo de parámetros de solicitud para definir el encabezado Content-

Type en el valor estático 'application/x-amz-json-1.1' para informar a Kinesis de que
la entrada es de una versión específica de JSON.

9. Elija Plantillas de mapeo y, a continuación, elija Agregar plantilla de mapeo y haga lo siguiente:

a. En Content-Type, indique application/json.

b. En Cuerpo de plantilla, escriba {}.

c. Seleccione Guardar.

La solicitud ListStreams toma una carga con el siguiente formato JSON:

{
"ExclusiveStartStreamName": "string",
"Limit": number
}

Sin embargo, las propiedades son opcionales. Para utilizar los valores predeterminados, usamos
aquí una carga JSON vacía.

10. Pruebe el método GET en el recurso /streams para invocar la acción ListStreams en Kinesis:

Elija la pestaña Test (Prueba). Puede que tenga que elegir el botón de flecha hacia la derecha
para mostrar la pestaña.

Elija Prueba para probar su método.

Si ya ha creado dos flujos llamados "myStream" y "yourStream" en Kinesis, la prueba realizada

correctamente devolverá una respuesta 200 OK que contiene la siguiente carga:

{
"HasMoreStreams": false,
"StreamNames": [
"myStream",
"yourStream"
]

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 172
Amazon API Gateway Guía para desarrolladores

Creación, descripción y eliminación de un flujo en Kinesis

Crear, describir y eliminar un flujo en Kinesis implica realizar las siguientes solicitudes a la API de
REST de Kinesis, respectivamente:

POST /?Action=CreateStream HTTP/1.1

Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes

{
"ShardCount": number,
"StreamName": "string"
}

POST /?Action=DescribeStream HTTP/1.1

Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes

{
"StreamName": "string"
}

POST /?Action=DeleteStream HTTP/1.1

Host: kinesis.region.domain
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 173
Amazon API Gateway Guía para desarrolladores

"StreamName":"string"
}

Podemos crear la API para que acepte la entrada necesaria como una carga JSON de una solicitud
de método y transmita la carga a la solicitud de integración. Sin embargo, para proporcionar más
ejemplos de mapeo de datos entre solicitudes de método e integración y respuestas de método e
integración, crearemos nuestra API de una forma ligeramente distinta.

Exponemos los métodos HTTP GET, POST y Delete HTTP en un recurso Stream al que se
asignará un nombre. Utilizamos la variable de ruta {stream-name} como marcador de posición
del recurso de flujo e integramos estos métodos de la API con las acciones DescribeStream,
CreateStream y DeleteStream de Kinesis respectivamente. Exigimos que el cliente pase otros
datos de entrada como encabezados, parámetros de consulta o la carga de una solicitud de método.
Proporcionamos plantillas de asignación para transformar los datos en la carga de solicitud de
integración necesaria.

Para crear un recurso {stream-name}

1. Con el recurso /streams seleccionado, elija Crear recurso.

2. Mantenga Recurso proxy desactivado.
3. En Ruta de recurso, seleccione /streams.
4. En Nombre del recurso, escriba {stream-name}.
5. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
6. Elija Crear recurso.

Para configurar y probar el método GET en un recurso de flujo

1. Con el recurso /{stream-name} seleccionado, elija Crear método.

2. En Tipo de método, seleccione GET.
3. En Tipo de integración, seleccione Servicio de AWS.
4. En Región de AWS, seleccione la Región de AWS donde creó el flujo de Kinesis.
5. En Servicio de AWS, seleccione Kinesis.
6. Deje Subdominio de AWS en blanco.
7. En HTTP method (Método HTTP), elija POST.
8. En Tipo de acción, elija Usar nombre de acción.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 174
Amazon API Gateway Guía para desarrolladores

9. En Nombre de la función, introduzca DescribeStream.

10. En Rol de ejecución, escriba el ARN del rol de ejecución.
11. Deje el valor predeterminado Acceso directo en Tratamiento de contenido.
12. Elija Crear método.
13. En la sección Solicitud de integración, añada los siguientes Parámetros de encabezados de
solicitudes de URL:

Content-Type: 'x-amz-json-1.1'

La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que
el método GET /streams.
14. Añada la siguiente plantilla de mapeo de cuerpo para mapear los datos de la solicitud
del método GET /streams/{stream-name} a la solicitud de integración POST /?
Action=DescribeStream:

{
"StreamName": "$input.params('stream-name')"
}

Esta plantilla de mapeo genera la carga de la solicitud de integración necesaria para la acción
DescribeStream de Kinesis a partir del valor del parámetro de ruta stream-name de la
solicitud de método.
15. Para probar el método GET /stream/{stream-name} para invocar la acción
DescribeStream en Kinesis, seleccione la pestaña Prueba.
16. En Ruta, en stream-name, introduzca el nombre de un flujo de Kinesis existente.
17. Seleccione Test (Probar). Si la prueba tiene éxito, se devuelve la respuesta 200 OK con una
carga similar a la siguiente:

{
"StreamDescription": {
"HasMoreShards": false,
"RetentionPeriodHours": 24,
"Shards": [
{
"HashKeyRange": {
"EndingHashKey": "68056473384187692692674921486353642290",
"StartingHashKey": "0"

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 175
Amazon API Gateway Guía para desarrolladores

},
"SequenceNumberRange": {
"StartingSequenceNumber":
"49559266461454070523309915164834022007924120923395850242"
},
"ShardId": "shardId-000000000000"
},
...
{
"HashKeyRange": {
"EndingHashKey": "340282366920938463463374607431768211455",
"StartingHashKey": "272225893536750770770699685945414569164"
},
"SequenceNumberRange": {
"StartingSequenceNumber":
"49559266461543273504104037657400164881014714369419771970"
},
"ShardId": "shardId-000000000004"
}
],
"StreamARN": "arn:aws:kinesis:us-east-1:12345678901:stream/myStream",
"StreamName": "myStream",
"StreamStatus": "ACTIVE"
}
}

Después de implementar la API, puede realizar una solicitud REST a este método de la API:

GET https://your-api-id.execute-api.region.amazonaws.com/stage/streams/myStream
HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z

Para configurar y probar el método POST en un recurso de flujo

1. Con el recurso /{stream-name} seleccionado, elija Crear método.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 176
Amazon API Gateway Guía para desarrolladores

2. En Tipo de método, seleccione POST.

3. En Tipo de integración, seleccione Servicio de AWS.
4. En Región de AWS, seleccione la Región de AWS donde creó el flujo de Kinesis.
5. En Servicio de AWS, seleccione Kinesis.
6. Deje Subdominio de AWS en blanco.
7. En HTTP method (Método HTTP), elija POST.
8. En Tipo de acción, elija Usar nombre de acción.
9. En Nombre de la función, introduzca CreateStream.
10. En Rol de ejecución, escriba el ARN del rol de ejecución.
11. Deje el valor predeterminado Acceso directo en Tratamiento de contenido.
12. Elija Crear método.
13. En la sección Solicitud de integración, añada los siguientes Parámetros de encabezados de
solicitudes de URL:

Content-Type: 'x-amz-json-1.1'

La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que
el método GET /streams.
14. Añada la siguiente plantilla de mapeo de cuerpo para mapear los datos de la solicitud
del método POST /streams/{stream-name} a la solicitud de integración POST /?
Action=CreateStream:

{
"ShardCount": #if($input.path('$.ShardCount') == '') 5 #else
$input.path('$.ShardCount') #end,
"StreamName": "$input.params('stream-name')"
}

En la plantilla de mapeo anterior, definimos ShardCount en un valor fijo de 5 si el cliente no

especifica un valor en la carga de la solicitud de método.
15. Para probar el método POST /stream/{stream-name} para invocar la acción
CreateStream en Kinesis, seleccione la pestaña Prueba.
16. En Ruta, en stream-name, introduzca el nombre de un flujo de Kinesis nuevo.
17. Seleccione Test (Probar). Si la prueba tiene éxito, se devuelve una respuesta 200 OK sin datos.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 177
Amazon API Gateway Guía para desarrolladores

Después de implementar la API, también puede realizar una solicitud de API de REST al método
POST en un recurso Stream para invocar la acción CreateStream en Kinesis:

POST https://your-api-id.execute-api.region.amazonaws.com/stage/streams/yourStream
HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z

{
"ShardCount": 5
}

Configurar y probar el método DELETE en un recurso de flujo

1. Con el recurso /{stream-name} seleccionado, elija Crear método.

2. En Tipo de método, seleccione DELETE.
3. En Tipo de integración, seleccione Servicio de AWS.
4. En Región de AWS, seleccione la Región de AWS donde creó el flujo de Kinesis.
5. En Servicio de AWS, seleccione Kinesis.
6. Deje Subdominio de AWS en blanco.
7. En HTTP method (Método HTTP), elija POST.
8. En Tipo de acción, elija Usar nombre de acción.
9. En Nombre de la función, introduzca DeleteStream.
10. En Rol de ejecución, escriba el ARN del rol de ejecución.
11. Deje el valor predeterminado Acceso directo en Tratamiento de contenido.
12. Elija Crear método.
13. En la sección Solicitud de integración, añada los siguientes Parámetros de encabezados de
solicitudes de URL:

Content-Type: 'x-amz-json-1.1'

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 178
Amazon API Gateway Guía para desarrolladores

La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que
el método GET /streams.

14. Añada la siguiente plantilla de mapeo de cuerpo para mapear los datos de la solicitud de
método DELETE /streams/{stream-name} a la solicitud de integración de POST /?
Action=DeleteStream correspondiente:

{
"StreamName": "$input.params('stream-name')"
}

Esta plantilla de mapeo genera la entrada necesaria de la DELETE /streams/{stream-

name} acción desde el nombre de ruta URL proporcionada por el cliente: stream-name.

15. Para probar el método DELETE /stream/{stream-name} para invocar la acción

DeleteStream en Kinesis, seleccione la pestaña Prueba.

16. En Ruta, en stream-name, introduzca el nombre de un flujo de Kinesis existente.

17. Seleccione Test (Probar). Si la prueba tiene éxito, se devuelve una respuesta 200 OK sin datos.

Después de implementar la API, también puede realizar la siguiente solicitud API de REST al
método DELETE en el recurso Stream para llamar a la acción DeleteStream en Kinesis:

DELETE https://your-api-id.execute-api.region.amazonaws.com/stage/
streams/yourStream HTTP/1.1
Host: your-api-id.execute-api.region.amazonaws.com
Content-Type: application/json
Authorization: ...
X-Amz-Date: 20160323T194451Z

{}

Obtención de registros y adición de registros a un flujo de Kinesis

Después de crear un flujo en Kinesis, puede agregar registros de datos al flujo y leer los datos del
flujo. Agregar registros de datos implica llamar a la acción PutRecords o PutRecord de Kinesis. La
primera acción añade varios registros, mientras que la última añade un solo registro al flujo.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 179
Amazon API Gateway Guía para desarrolladores

POST /?Action=PutRecords HTTP/1.1

Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes

{
"Records": [
{
"Data": blob,
"ExplicitHashKey": "string",
"PartitionKey": "string"
}
],
"StreamName": "string"
}

POST /?Action=PutRecord HTTP/1.1

Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes

{
"Data": blob,
"ExplicitHashKey": "string",
"PartitionKey": "string",
"SequenceNumberForOrdering": "string",
"StreamName": "string"
}

Aquí, StreamName identifica el flujo de destino para añadir registros. StreamName, Data y
PartitionKey son datos de entrada necesarios. En nuestro ejemplo, usamos los valores

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 180
Amazon API Gateway Guía para desarrolladores

predeterminados para todos los datos de entrada opcionales y no especificaremos de forma explícita
los valores para ellos en la entrada de la solicitud del método.

Leer datos en Kinesis equivale a llamar a la acción GetRecords:

POST /?Action=GetRecords HTTP/1.1

Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes

{
"ShardIterator": "string",
"Limit": number
}

Aquí, el flujo de origen del que se obtienen los registros se especifica en el valor de
ShardIterator necesario, tal y como se muestra en la siguiente acción de Kinesis para obtener un
iterador de fragmento:

POST /?Action=GetShardIterator HTTP/1.1

Host: kinesis.region.domain
Authorization: AWS4-HMAC-SHA256 Credential=..., ...
...
Content-Type: application/x-amz-json-1.1
Content-Length: PayloadSizeBytes

{
"ShardId": "string",
"ShardIteratorType": "string",
"StartingSequenceNumber": "string",
"StreamName": "string"
}

Para las acciones GetRecords y PutRecords, exponemos los métodos GET y PUT,
respectivamente, en un recurso /records que se añade a un recurso de flujo con nombre (/
{stream-name}). Del mismo modo, exponemos la acción PutRecord como un método PUT en un
recurso /record.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 181
Amazon API Gateway Guía para desarrolladores

Como la acción GetRecords toma como entrada un valor de ShardIterator, que se obtiene
llamando a la acción auxiliar GetShardIterator, exponemos un método auxiliar GET en un
recurso ShardIterator (/sharditerator).

Para crear los recursos /record, /records y /sharditerator

1. Con el recurso /{stream-name} seleccionado, elija Crear recurso.

2. Mantenga Recurso proxy desactivado.
3. En Ruta de recurso, seleccione /{stream-name}.
4. En Nombre del recurso, escriba record.
5. Mantenga desactivado CORS (uso compartido de recursos entre orígenes).
6. Elija Crear recurso.
7. Repita los pasos anteriores para crear un recurso /records y un recurso /sharditerator. La API
final debe ser similar a la siguiente:

Los siguientes cuatro procedimientos describen cómo configurar cada uno de los métodos, cómo
asignar datos desde las solicitudes de método a las solicitudes de integración y cómo probar los
métodos.

Para configurar y probar el método PUT /streams/{stream-name}/record para invocar a

PutRecord en Kinesis

1. Con el recurso /record seleccionado, elija Crear método.

2. En Tipo de método, seleccione PUT.
3. En Tipo de integración, seleccione Servicio de AWS.
4. En Región de AWS, seleccione la Región de AWS donde creó el flujo de Kinesis.
5. En Servicio de AWS, seleccione Kinesis.
6. Deje Subdominio de AWS en blanco.
7. En HTTP method (Método HTTP), elija POST.
8. En Tipo de acción, elija Usar nombre de acción.
9. En Nombre de la función, introduzca PutRecord.
10. En Rol de ejecución, escriba el ARN del rol de ejecución.
11. Deje el valor predeterminado Acceso directo en Tratamiento de contenido.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 182
Amazon API Gateway Guía para desarrolladores

12. Elija Crear método.

13. En la sección Solicitud de integración, añada los siguientes Parámetros de encabezados de
solicitudes de URL:

Content-Type: 'x-amz-json-1.1'

La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que
el método GET /streams.

14. Añada la siguiente plantilla de mapeo de cuerpo para mapear los datos de la solicitud de
método PUT /streams/{stream-name}/record a la solicitud de integración de POST /?
Action=PutRecord correspondiente:

{
"StreamName": "$input.params('stream-name')",
"Data": "$util.base64Encode($input.json('$.Data'))",
"PartitionKey": "$input.path('$.PartitionKey')"
}

En esta plantilla de asignación se asume que la carga del método de solicitud tiene el siguiente
formato:

{
"Data": "some data",
"PartitionKey": "some key"
}

Estos datos se pueden modelar mediante el siguiente esquema JSON:

{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PutRecord proxy single-record payload",
"type": "object",
"properties": {
"Data": { "type": "string" },
"PartitionKey": { "type": "string" }
}
}

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 183
Amazon API Gateway Guía para desarrolladores

Puede crear un modelo para incluir este esquema y utilizar el modelo para facilitar la generación
de la plantilla de asignación. Sin embargo, puede generar una plantilla de asignación sin usar
ningún modelo.
15. Para probar el método PUT /streams/{stream-name}/record, establezca la variable de
ruta stream-name en el nombre de un flujo existente, introduzca la carga del formato necesario
y, a continuación, envíe la solicitud de método. El resultado correcto es una respuesta 200 OK
con una carga con el formato siguiente:

{
"SequenceNumber": "49559409944537880850133345460169886593573102115167928386",
"ShardId": "shardId-000000000004"
}

Para configurar y probar el método PUT /streams/{stream-name}/records para invocar a

PutRecords en Kinesis

1. Con el recurso /records seleccionado, elija Crear método.

2. En Tipo de método, seleccione PUT.

3. En Tipo de integración, seleccione Servicio de AWS.

4. En Región de AWS, seleccione la Región de AWS donde creó el flujo de Kinesis.

5. En Servicio de AWS, seleccione Kinesis.

6. Deje Subdominio de AWS en blanco.

7. En HTTP method (Método HTTP), elija POST.

8. En Tipo de acción, elija Usar nombre de acción.

9. En Nombre de la función, introduzca PutRecords.

10. En Rol de ejecución, escriba el ARN del rol de ejecución.

11. Deje el valor predeterminado Acceso directo en Tratamiento de contenido.

12. Elija Crear método.

13. En la sección Solicitud de integración, añada los siguientes Parámetros de encabezados de

solicitudes de URL:

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 184
Amazon API Gateway Guía para desarrolladores

Content-Type: 'x-amz-json-1.1'

La tarea sigue el mismo procedimiento para configurar el mapeo del parámetro de solicitud que
el método GET /streams.

14. Añada la siguiente plantilla de mapeo para mapear los datos de la solicitud del método
PUT /streams/{stream-name}/records a la solicitud de integración de POST /?
Action=PutRecords correspondiente:

{
"StreamName": "$input.params('stream-name')",
"Records": [
#foreach($elem in $input.path('$.records'))
{
"Data": "$util.base64Encode($elem.data)",
"PartitionKey": "$elem.partition-key"
}#if($foreach.hasNext),#end
#end
]
}

Esta plantilla de mapeo asume que el siguiente esquema JSON puede modelar la carga de la
solicitud de método:

{
"$schema": "http://json-schema.org/draft-04/schema#",
"title": "PutRecords proxy payload data",
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": { "type": "string" },
"partition-key": { "type": "string" }
}
}
}
}

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 185
Amazon API Gateway Guía para desarrolladores

Puede crear un modelo para incluir este esquema y utilizar el modelo para facilitar la generación
de la plantilla de asignación. Sin embargo, puede generar una plantilla de asignación sin usar
ningún modelo.

En este tutorial, hemos usado dos formatos de carga ligeramente diferentes para ilustrar que
un desarrollador de API puede optar por exponer el formato de datos de backend al cliente
u ocultárselo. Un formato es para el método PUT /streams/{stream-name}/records
(anterior). Otro formato se utiliza en el método PUT /streams/{stream-name}/record (en
el procedimiento anterior). En un entorno de producción, debe mantener la coherencia de ambos
formatos.

15.
Para probar el método PUT /streams/{stream-name}/records, establezca la variable de
ruta stream-name en un flujo existente, introduzca la siguiente carga y envíe la solicitud del
método.

{
"records": [
{
"data": "some data",
"partition-key": "some key"
},
{
"data": "some other data",
"partition-key": "some key"
}
]
}

El resultado correcto es una respuesta 200 OK con una carga similar a la siguiente:

{
"FailedRecordCount": 0,
"Records": [
{
"SequenceNumber": "49559409944537880850133345460167468741933742152373764162",
"ShardId": "shardId-000000000004"

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 186
Amazon API Gateway Guía para desarrolladores

},
{
"SequenceNumber": "49559409944537880850133345460168677667753356781548470338",
"ShardId": "shardId-000000000004"
}
]
}

Para configurar y probar el método GET /streams/{stream-name}/sharditerator para

invocar a GetShardIterator en Kinesis

GET /streams/{stream-name}/sharditerator es un método auxiliar para adquirir un iterador

de fragmento necesario antes de llamar al método GET /streams/{stream-name}/records.

1. Con el recurso /sharditerator seleccionado, elija Crear método.

2. En Tipo de método, seleccione GET.
3. En Tipo de integración, seleccione Servicio de AWS.
4. En Región de AWS, seleccione la Región de AWS donde creó el flujo de Kinesis.
5. En Servicio de AWS, seleccione Kinesis.
6. Deje Subdominio de AWS en blanco.
7. En HTTP method (Método HTTP), elija POST.
8. En Tipo de acción, elija Usar nombre de acción.
9. En Nombre de la función, introduzca GetShardIterator.
10. En Rol de ejecución, escriba el ARN del rol de ejecución.
11. Deje el valor predeterminado Acceso directo en Tratamiento de contenido.
12. Elija Crear método.

La acción GetShardIterator requiere una entrada de un valor de ShardId. Para pasar un

valor de ShardId proporcionado por el cliente, añadimos un parámetro de consulta shard-id
a la solicitud del método, tal y como se muestra en el siguiente paso.
13. En la pestaña Solicitud de método, en Configuración de solicitud de método, elija Editar.
14. Elija Parámetros de cadenas de consulta de URL y luego haga lo siguiente:

a. Elija Add query string (Añadir cadena de consulta).

b. En Name (Nombre), ingrese shard-id.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 187
Amazon API Gateway Guía para desarrolladores

c. Mantenga desactivados Obligatorio y Almacenamiento en caché.

d. Seleccione Guardar.

En la siguiente plantilla de mapeo, definimos el valor del parámetro de consulta shard-

id en el valor de la propiedad ShardId de la carga JSON como entrada de la acción
GetShardIterator en Kinesis.
15. En la sección Solicitud de integración, añada la siguiente plantilla de mapeo para generar
la entrada requerida (ShardId y StreamName) a la acción GetShardIterator a partir
de los parámetros shard-id y stream-name de la solicitud de método. Además, la
plantilla de mapeo también establece ShardIteratorType en TRIM_HORIZON como valor
predeterminada.

{
"ShardId": "$input.params('shard-id')",
"ShardIteratorType": "TRIM_HORIZON",
"StreamName": "$input.params('stream-name')"
}

16. Con la opción Test (Prueba) de la consola de API Gateway, escriba un nombre de flujo
existente como el valor de la variable stream-name de Path (Ruta), establezca shard-
id para Query string (Cadena de consulta) en un valor ShardId existente (por ejemplo,
shard-000000000004) y elija Test (Prueba).

La carga de la respuesta correcta es similar al siguiente resultado:

{
"ShardIterator": "AAAAAAAAAAFYVN3VlFy..."
}

Anote el valor de ShardIterator. Lo necesita para obtener los registros de un flujo.

Para configurar y probar el método GET /streams/{stream-name}/records para invocar la

acción GetRecords en Kinesis

1. Con el recurso /records seleccionado, elija Crear método.

2. En Tipo de método, seleccione GET.
3. En Tipo de integración, seleccione Servicio de AWS.

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 188
Amazon API Gateway Guía para desarrolladores

4. En Región de AWS, seleccione la Región de AWS donde creó el flujo de Kinesis.

5. En Servicio de AWS, seleccione Kinesis.
6. Deje Subdominio de AWS en blanco.
7. En HTTP method (Método HTTP), elija POST.
8. En Tipo de acción, elija Usar nombre de acción.
9. En Nombre de la función, introduzca GetRecords.
10. En Rol de ejecución, escriba el ARN del rol de ejecución.
11. Deje el valor predeterminado Acceso directo en Tratamiento de contenido.
12. Elija Crear método.

La acción GetRecords requiere una entrada de un valor de ShardIterator. Para pasar un

valor de ShardIterator proporcionado por el cliente, añadimos un parámetro de encabezado
Shard-Iterator a la solicitud del método, tal y como se muestra en los siguientes pasos.
13. En la pestaña Solicitud de método, en Configuración de solicitud de método, elija Editar.
14. Elija Encabezados de consulta HTTP y luego haga lo siguiente:

a. Elija Add header (Añadir encabezado).

b. En Name (Nombre), ingrese Shard-Iterator.
c. Mantenga desactivados Obligatorio y Almacenamiento en caché.
d. Seleccione Guardar.
15. En la sección Solicitud de integración, añada la siguiente plantilla de mapeo de cuerpo para
mapear el valor del parámetro de encabezado Shard-Iterator al valor de la propiedad
ShardIterator de la carga JSON para la acción GetRecords en Kinesis.

{
"ShardIterator": "$input.params('Shard-Iterator')"
}

16. Con la opción Prueba de la consola de API Gateway, escriba un nombre de flujo existente como
el valor de la variable stream-name de Ruta, establezca el Shard-Iterator de Encabezado
en el valor de ShardIterator obtenido de la serie de pruebas del método GET /streams/
{stream-name}/sharditerator (arriba) y elija Prueba.

La carga de la respuesta correcta es similar al siguiente resultado:

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 189
Amazon API Gateway Guía para desarrolladores

"MillisBehindLatest": 0,
"NextShardIterator": "AAAAAAAAAAF...",
"Records": [ ... ]
}

Definiciones de OpenAPI de la API de ejemplo como un proxy de Kinesis

A continuación se muestran las definiciones de OpenAPI de la API de ejemplo, utilizada en este

tutorial, como un proxy de Kinesis.

OpenAPI 3.0

{
"openapi": "3.0.0",
"info": {
"title": "KinesisProxy",
"version": "2016-03-31T18:25:32Z"
},
"paths": {
"/streams/{stream-name}/sharditerator": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
},
{
"name": "shard-id",
"in": "query",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 190
Amazon API Gateway Guía para desarrolladores

"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetShardIterator",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardId\": \"$input.params('shard-
id')\",\n \"ShardIteratorType\": \"TRIM_HORIZON\",\n \"StreamName\":
\"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/records": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
},
{
"name": "Shard-Iterator",

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 191
Amazon API Gateway Guía para desarrolladores

"in": "header",
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardIterator\": \"$input.params('Shard-
Iterator')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"put": {
"parameters": [
{
"name": "Content-Type",
"in": "header",

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 192
Amazon API Gateway Guía para desarrolladores

"schema": {
"type": "string"
}
},
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"requestBody": {
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/PutRecordsMethodRequestPayload"
}
},
"application/x-amz-json-1.1": {
"schema": {
"$ref": "#/components/schemas/PutRecordsMethodRequestPayload"
}
}
},
"required": true
},
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecords",

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 193
Amazon API Gateway Guía para desarrolladores

"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-
name')\",\n \"Records\": [\n {\n \"Data\":
\"$util.base64Encode($elem.data)\",\n \"PartitionKey\":
\"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}",
"application/x-amz-json-1.1": "{\n \"StreamName\":
\"$input.params('stream-name')\",\n \"records\" : [\n {\n \"Data
\" : \"$elem.data\",\n \"PartitionKey\" : \"$elem.partition-key\"\n
}#if($foreach.hasNext),#end\n ]\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}": {
"get": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 194
Amazon API Gateway Guía para desarrolladores

}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DescribeStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-
name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"post": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 195
Amazon API Gateway Guía para desarrolladores

"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/CreateStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardCount\": 5,\n \"StreamName\":
\"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"delete": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {
"application/json": {

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 196
Amazon API Gateway Guía para desarrolladores

"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
},
"400": {
"description": "400 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {}
},
"500": {
"description": "500 response",
"headers": {
"Content-Type": {
"schema": {
"type": "string"
}
}
},
"content": {}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DeleteStream",
"responses": {
"4\\d{2}": {
"statusCode": "400",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type"
}
},
"default": {
"statusCode": "200",
"responseParameters": {

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 197
Amazon API Gateway Guía para desarrolladores

"method.response.header.Content-Type":
"integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type"
}
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-
name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/record": {
"put": {
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"schema": {
"type": "string"
}
}
],
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 198
Amazon API Gateway Guía para desarrolladores

}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecord",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-
name')\",\n \"Data\": \"$util.base64Encode($input.json('$.Data'))\",\n
\"PartitionKey\": \"$input.path('$.PartitionKey')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams": {
"get": {
"responses": {
"200": {
"description": "200 response",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/Empty"
}
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 199
Amazon API Gateway Guía para desarrolladores

"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/ListStreams",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
}
},
"components": {
"schemas": {
"Empty": {
"type": "object"
},
"PutRecordsMethodRequestPayload": {
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": {
"type": "string"
},
"partition-key": {
"type": "string"
}
}
}
}
}
}

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 200
Amazon API Gateway Guía para desarrolladores

}
}
}

OpenAPI 2.0

{
"swagger": "2.0",
"info": {
"version": "2016-03-31T18:25:32Z",
"title": "KinesisProxy"
},
"basePath": "/test",
"schemes": [
"https"
],
"paths": {
"/streams": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/ListStreams",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 201
Amazon API Gateway Guía para desarrolladores

"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DescribeStream",
"responses": {
"default": {
"statusCode": "200"
}
},

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 202
Amazon API Gateway Guía para desarrolladores

"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-
name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"post": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/CreateStream",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 203
Amazon API Gateway Guía para desarrolladores

"requestTemplates": {
"application/json": "{\n \"ShardCount\": 5,\n \"StreamName\":
\"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"delete": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
},
"headers": {
"Content-Type": {
"type": "string"
}
}
},
"400": {
"description": "400 response",
"headers": {
"Content-Type": {
"type": "string"
}
}
},
"500": {

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 204
Amazon API Gateway Guía para desarrolladores

"description": "500 response",

"headers": {
"Content-Type": {
"type": "string"
}
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/DeleteStream",
"responses": {
"4\\d{2}": {
"statusCode": "400",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type"
}
},
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type"
}
},
"5\\d{2}": {
"statusCode": "500",
"responseParameters": {
"method.response.header.Content-Type":
"integration.response.header.Content-Type"
}
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-
name')\"\n}"
},
"passthroughBehavior": "when_no_match",

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 205
Amazon API Gateway Guía para desarrolladores

"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/record": {
"put": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecord",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 206
Amazon API Gateway Guía para desarrolladores

"application/json": "{\n \"StreamName\": \"$input.params('stream-

name')\",\n \"Data\": \"$util.base64Encode($input.json('$.Data'))\",\n
\"PartitionKey\": \"$input.path('$.PartitionKey')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
},
"/streams/{stream-name}/records": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "Shard-Iterator",
"in": "header",
"required": false,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetRecords",
"responses": {

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 207
Amazon API Gateway Guía para desarrolladores

"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"ShardIterator\": \"$input.params('Shard-
Iterator')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
},
"put": {
"consumes": [
"application/json",
"application/x-amz-json-1.1"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "Content-Type",
"in": "header",
"required": false,
"type": "string"
},
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"in": "body",
"name": "PutRecordsMethodRequestPayload",
"required": true,
"schema": {
"$ref": "#/definitions/PutRecordsMethodRequestPayload"
}

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 208
Amazon API Gateway Guía para desarrolladores

},
{
"in": "body",
"name": "PutRecordsMethodRequestPayload",
"required": true,
"schema": {
"$ref": "#/definitions/PutRecordsMethodRequestPayload"
}
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/PutRecords",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"
},
"requestTemplates": {
"application/json": "{\n \"StreamName\": \"$input.params('stream-
name')\",\n \"Records\": [\n {\n \"Data\":
\"$util.base64Encode($elem.data)\",\n \"PartitionKey\":
\"$elem.partition-key\"\n }#if($foreach.hasNext),#end\n ]\n}",
"application/x-amz-json-1.1": "{\n \"StreamName\":
\"$input.params('stream-name')\",\n \"records\" : [\n {\n \"Data
\" : \"$elem.data\",\n \"PartitionKey\" : \"$elem.partition-key\"\n
}#if($foreach.hasNext),#end\n ]\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 209
Amazon API Gateway Guía para desarrolladores

}
},
"/streams/{stream-name}/sharditerator": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "stream-name",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "shard-id",
"in": "query",
"required": false,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Empty"
}
}
},
"x-amazon-apigateway-integration": {
"type": "aws",
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"uri": "arn:aws:apigateway:us-east-1:kinesis:action/GetShardIterator",
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.header.Content-Type": "'application/x-amz-
json-1.1'"

Tutorial: Creación de una API de REST como proxy de Amazon Kinesis 210
Amazon API Gateway Guía para desarrolladores

},
"requestTemplates": {
"application/json": "{\n \"ShardId\": \"$input.params('shard-
id')\",\n \"ShardIteratorType\": \"TRIM_HORIZON\",\n \"StreamName\":
\"$input.params('stream-name')\"\n}"
},
"passthroughBehavior": "when_no_match",
"httpMethod": "POST"
}
}
}
},
"definitions": {
"Empty": {
"type": "object"
},
"PutRecordsMethodRequestPayload": {
"type": "object",
"properties": {
"records": {
"type": "array",
"items": {
"type": "object",
"properties": {
"data": {
"type": "string"
},
"partition-key": {
"type": "string"
}
}
}
}
}
}
}
}

Tutorial: creación de una API REST privada

En este tutorial, creará una API REST privada. Los clientes solo pueden acceder a la API desde su
Amazon VPC La API está aislada de la Internet pública, que es un requisito de seguridad común.

Crear una API REST privada 211

Amazon API Gateway Guía para desarrolladores

Este tutorial tarda aproximadamente 30 minutos en completarse. En primer lugar, utilice una plantilla
de AWS CloudFormation para crear una nube de Amazon VPC, un punto de enlace de la VPC, una
función de AWS Lambda y lanzar una instancia de Amazon EC2 que utilizará para probar la API. A
continuación, utilice la AWS Management Console para crear una API privada y adjuntar una política
de recursos que permita el acceso solo desde el punto de enlace de la VPC. Por último, se prueba la
API.

Para completar este tutorial, necesita una cuenta de AWS y un usuario de AWS Identity and Access
Management con acceso a la consola. Para obtener más información, consulte Requisitos previos.

En este tutorial, se utiliza la AWS Management Console. Para obtener una plantilla de AWS
CloudFormation que cree esta API y todos los recursos relacionados, consulte template.yaml.

Temas

• Paso 1: crear dependencias

• Paso 2: crear una API privada

• Paso 3: crear un método e integración

• Paso 4: adjuntar una política de recursos

• Paso 5: implemente su API

• Paso 6: compruebe que su API no sea accesible públicamente

• Paso 7: conéctese a una instancia de su VPC e invoque su API

• Paso 8: Eliminar

• Próximos pasos: automatice con AWS CloudFormation

Crear una API REST privada 212

Amazon API Gateway Guía para desarrolladores

Paso 1: crear dependencias

Descargue y descomprima esta plantilla de AWS CloudFormation. Utilice la plantilla para crear todas
las dependencias de su API privada, incluidas una VPC de Amazon, un punto de enlace de la VPC y
una función Lambda que sirve como backend de la API. Creará la API privada más tarde.

Para crear una pila de AWS CloudFormation

1. Abra la consola de AWS CloudFormation en https://console.aws.amazon.com/cloudformation.

2. Seleccione Create stack (Crear pila) y, a continuación, seleccione With new resources (standard)
(Con nuevos recursos [estándar]).
3. En Specify template (Especificar plantilla), elija Upload a template file (Cargar un archivo de
plantilla).
4. Seleccione la plantilla que ha descargado.
5. Elija Next (Siguiente).
6. En Stack name (Nombre de pila), escriba private-api-tutorial y, a continuación, elija Next
(Siguiente).
7. En Configure stack options (Configurar opciones de pila), elija Next (Siguiente).
8. Para Capabilities (Capacidades), sepa que AWS CloudFormation puede crear recursos de IAM
en su cuenta.
9. Elija Create stack.

AWS CloudFormation aprovisiona las dependencias para su API. Puede tardar unos minutos.
Cuando el estado de la pila de AWS CloudFormation sea CREATE_COMPLETE, elija Outputs
(Salidas). Anote el ID del punto de enlace de la VPC. Los va a necesitar en pasos más adelante de
este tutorial.

Paso 2: crear una API privada

Cree una API privada para permitir que solo los clientes de su VPC accedan a ella.

Creación de una API privada

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Seleccione Create API (Crear API)y, a continuación, para API REST, seleccione Build
(Construir).

Crear una API REST privada 213

Amazon API Gateway Guía para desarrolladores

3. En API name (Nombre de la API), escribaprivate-api-tutorial.

4. En Tipo de punto de conexión de la API, seleccione Privado.
5. Para ID del punto de conexión de la VPC, introduzca el ID de punto de conexión de la VPC en
las Salidas de la pila de AWS CloudFormation.
6. Elija Crear API.

Paso 3: crear un método e integración

Usted crea un método y la integración de Lambda GET para manejar solicitudes de GET a su API.
Cuando un cliente invoca su API, API Gateway envía la solicitud a la función Lambda que creó en el
paso 1 y, a continuación, devuelve una respuesta al cliente.

Para crear un método e integración

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.
3. Seleccione el recurso / y, a continuación, elija Crear método.
4. En Tipo de método, seleccione GET.
5. En Tipo de integración, seleccione Función de Lambda.
6. Active Integración de proxy de Lambda. Con una integración de proxy de Lambda, API Gateway
envía un evento a Lambda con una estructura definida y transforma la respuesta de su función
Lambda a una respuesta HTTP.
7. En la Lambda function (Función de Lambda), elija la función que creó con la plantilla de AWS
CloudFormation en el paso 1. El nombre de la función comienza con private-api-tutorial.
8. Elija Crear método.

Paso 4: adjuntar una política de recursos

Adjuntar una política de recursos a la API que permite a los clientes invocar la API sólo a través del
punto de enlace de la VPC. Para restringir aún más el acceso a la API, también puede configurar una
política de punto de enlace de la VPC para el punto de enlace de su VPC, pero esto no es necesario
para este tutorial.

Para adjuntar una política de recursos

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

Crear una API REST privada 214

Amazon API Gateway Guía para desarrolladores

2. Elija la API.
3. Elija Política de recursos y, a continuación, elija Crear política.
4. Escriba la siguiente política. Reemplace vpceID por su ID de punto de enlace de la VPC desde
las Outputs (Salidas) de su pila de AWS CloudFormation.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": "execute-api:/*",
"Condition": {
"StringNotEquals": {
"aws:sourceVpce": "vpceID"
}
}
},
{
"Effect": "Allow",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": "execute-api:/*"
}
]
}

5. Elija Guardar cambios.

Paso 5: implemente su API

A continuación, implemente su API para ponerla a disposición de los clientes de su Amazon VPC

Para implementar una API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.
3. Elija Deploy API (Implementar API).
4. En Etapa, seleccione Nueva etapa.

Crear una API REST privada 215

Amazon API Gateway Guía para desarrolladores

5. En Stage name (Nombre de etapa), escriba test.

6. (Opcional) En Description (Descripción), introduzca una descripción.
7. Elija Deploy (Implementar).

Ya está listo para probar su API.

Paso 6: compruebe que su API no sea accesible públicamente

Use curl para verificar que no puede invocar la API desde fuera de su Amazon VPC

Para probar la API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.
3. En el panel de navegación principal, elija Etapas y, a continuación, elija la etapa test.
4. En Detalles de la etapa, elija el icono de copia para copiar la URL de invocación de la API. La
URL se ve así https://abcdef123.execute-api.us-west-2.amazonaws.com/test.
El punto de enlace de la VPC que creó en el paso 1 tiene el DNS privado habilitado, por lo que
puede utilizar la URL proporcionada para invocar la API.
5. Utilice curl para intentar invocar la API desde fuera de su VPC.

curl https://abcdef123.execute-api.us-west-2.amazonaws.com/test

Curl indica que el punto de enlace de su API no se puede resolver. Si obtiene una respuesta
diferente, vuelva al paso 2 y asegúrese de elegir Private (Privado) para el tipo de punto de
enlace de su API.

curl: (6) Could not resolve host: abcdef123.execute-api.us-west-2.amazonaws.com/

test

A continuación, se conecta a una instancia de Amazon EC2 en la VPC para invocar su API.

Paso 7: conéctese a una instancia de su VPC e invoque su API

A continuación, pruebe la API desde su Amazon VPC Para acceder a su API privada, se conecta a
una instancia de Amazon EC2 en su VPC y, a continuación, utilice curl para invocar su API. Utilice el
Administrador de sesiones de Systems Manager para conectarse a la instancia en el navegador.

Crear una API REST privada 216

Amazon API Gateway Guía para desarrolladores

Para probar la API

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.

2. Elija Instances.

3. Elija la instancia denominada private-api-tutorial que creó con la plantilla de AWS

CloudFormation en el paso 1.

4. Elija Connect (Conectar) y, a continuación, elija Session Manager (Administrador de sesiones).

5. Elija Connect (Conectar) para iniciar una sesión basada en explorador en la instancia.

6. En su sesión de Session Manager, use curl para invocar su API. Puede invocar la API porque
está utilizando una instancia en su Amazon VPC

curl https://abcdef123.execute-api.us-west-2.amazonaws.com/test

Verifique que obtiene la respuesta Hello from Lambda!.

Ha creado correctamente una API a la que solo se puede acceder desde su VPC de Amazon y, a
continuación, verificó que funciona.

Paso 8: Eliminar

Para evitar costos innecesarios, elimine los recursos creados como parte de este tutorial Los
siguientes pasos eliminan su API REST y su pila de AWS CloudFormation.

Para eliminar una API REST

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

Crear una API REST privada 217

Amazon API Gateway Guía para desarrolladores

2. En la página API, seleccione una API. Elija Acciones de API, elija Eliminar API y confirme su
elección.

Para eliminar una pila de AWS CloudFormation

1. Abra la consola de AWS CloudFormation en https://console.aws.amazon.com/cloudformation.

2. Seleccione su pila de AWS CloudFormation.

3. Elija Delete (Eliminar) y, a continuación, confirme su elección.

Próximos pasos: automatice con AWS CloudFormation

Puede automatizar la creación y la limpieza de todos los recursos de AWS involucrados en

este tutorial. Para obtener una plantilla de AWS CloudFormation de ejemplo completa, consulte
template.yaml.

Tutoriales sobre API HTTP de Amazon API Gateway

Los siguientes tutoriales proporcionan ejercicios prácticos para ayudar a saber más sobre las API
HTTP de API Gateway.

Temas

• Tutorial: crear una API CRUD con Lambda y DynamoDB

• Tutorial: creación de una API HTTP con una integración privada en un Servicio Amazon ECS

Tutorial: crear una API CRUD con Lambda y DynamoDB

En este tutorial, creará una API sin servidor para crear, leer, actualizar y eliminar elementos de una
tabla de DynamoDB. DynamoDB es un servicio de bases de datos NoSQL totalmente administrado
que proporciona un rendimiento rápido y predecible, así como una perfecta escalabilidad. Completar
este tutorial lleva aproximadamente 30 minutos, y puede hacerse dentro del nivel gratuito de AWS.

En primer lugar, se crea una tabla DynamoDB utilizando la consola de DynamoDB. Luego, se
crea una función de Lambda con la consola de AWS Lambda. A continuación, crea una API HTTP
mediante la consola de API Gateway. Por último, se prueba la API.

Tutoriales sobre API HTTP 218

Amazon API Gateway Guía para desarrolladores

Cuando invoca su API HTTP, API Gateway enruta la solicitud a su función de Lambda. La función
Lambda interactúa con DynamoDB y devuelve una respuesta a API Gateway. API Gateway, a
continuación, le devuelve una respuesta.

Para completar este ejercicio, necesita una cuenta de AWS y un usuario de AWS Identity and Access
Management con acceso a la consola. Para obtener más información, consulte Requisitos previos.

En este tutorial, se utiliza la AWS Management Console. Para obtener una plantilla de AWS SAM
que cree esta API y todos los recursos relacionados, consulte template.yaml.

Temas
• Paso 1: crear una tabla de DynamoDB
• Paso 2: crear una función Lambda
• Paso 3: crear una API HTTP
• Paso 4: crear rutas
• Paso 5: crear una integración
• Paso 6: conectar la integración a las rutas
• Paso 7: probar la API
• Paso 8: Eliminar
• Pasos siguientes: automatización con AWS SAM o AWS CloudFormation

Paso 1: crear una tabla de DynamoDB

Se utiliza una tabla DynamoDB para almacenar datos para la API.

Cada elemento tiene un ID único, que usamos como clave de partición para la tabla.

Cree una tabla de DynamoDB

1. Abra la consola de DynamoDB en https://console.aws.amazon.com/dynamodb/.

2. Seleccione Create table.

API CRUD con Lambda y DynamoDB 219

Amazon API Gateway Guía para desarrolladores

3. En Nombre de la tabla, introduzca http-crud-tutorial-items.

4. En Partition key (Clave de partición), ingrese id.
5. Seleccione Create table (Crear tabla).

Paso 2: crear una función Lambda

Se crea una función Lambda para el backend de la API. Esta función Lambda crea, lee, actualiza y
elimina elementos de DynamoDB. La función utiliza eventos de API Gateway para determinar cómo
interactuar con DynamoDB. Para simplificar el proceso, este tutorial utiliza una sola función Lambda.
Como práctica recomendada, se deben crear funciones separadas para cada ruta.

Para crear una función Lambda, realice el siguiente procedimiento:

1. Inicie sesión en la consola de Lambda en https://console.aws.amazon.com/lambda/.

2. Elija Create function (Crear función).
3. En Function name (Nombre de función), introduzca http-crud-tutorial-function.
4. En Permisos, seleccione Cambiar el rol de ejecución predeterminado.
5. Seleccione Create a new role from AWS policy templates (Crear un nuevo rol en plantillas de
políticas de AWS).
6. En Nombre del rol, introduzca http-crud-tutorial-role.
7. En Plantillas de políticas, seleccione Simple microservice permissions. Esta política
concede a la función Lambda permiso para interactuar con DynamoDB.

Note
Para simplificar el proceso, este tutorial utiliza una política administrada. Como práctica
recomendada, se deben crear políticas de IAM propias para otorgar los permisos
mínimos requeridos.

8. Elija Create function (Crear función).

9. Abra index.mjs en el editor de código de la consola y reemplace su contenido con el siguiente
código. Seleccione Implementar para actualizar la función.

import { DynamoDBClient } from "@aws-sdk/client-dynamodb";

import {

API CRUD con Lambda y DynamoDB 220

Amazon API Gateway Guía para desarrolladores

DynamoDBDocumentClient,
ScanCommand,
PutCommand,
GetCommand,
DeleteCommand,
} from "@aws-sdk/lib-dynamodb";

const client = new DynamoDBClient({});

const dynamo = DynamoDBDocumentClient.from(client);

const tableName = "http-crud-tutorial-items";

export const handler = async (event, context) => {

let body;
let statusCode = 200;
const headers = {
"Content-Type": "application/json",
};

try {
switch (event.routeKey) {
case "DELETE /items/{id}":
await dynamo.send(
new DeleteCommand({
TableName: tableName,
Key: {
id: event.pathParameters.id,
},
})
);
body = `Deleted item ${event.pathParameters.id}`;
break;
case "GET /items/{id}":
body = await dynamo.send(
new GetCommand({
TableName: tableName,
Key: {
id: event.pathParameters.id,
},
})
);
body = body.Item;
break;

API CRUD con Lambda y DynamoDB 221

Amazon API Gateway Guía para desarrolladores

case "GET /items":

body = await dynamo.send(
new ScanCommand({ TableName: tableName })
);
body = body.Items;
break;
case "PUT /items":
let requestJSON = JSON.parse(event.body);
await dynamo.send(
new PutCommand({
TableName: tableName,
Item: {
id: requestJSON.id,
price: requestJSON.price,
name: requestJSON.name,
},
})
);
body = `Put item ${requestJSON.id}`;
break;
default:
throw new Error(`Unsupported route: "${event.routeKey}"`);
}
} catch (err) {
statusCode = 400;
body = err.message;
} finally {
body = JSON.stringify(body);
}

return {
statusCode,
body,
headers,
};
};

Paso 3: crear una API HTTP

La API HTTP proporciona un punto de enlace HTTP para su función de Lambda. En este paso, se
crea una API vacía. En los siguientes pasos, se configuran rutas e integraciones para conectar la API
y la función Lambda.

API CRUD con Lambda y DynamoDB 222

Amazon API Gateway Guía para desarrolladores

Para crear una API HTTP

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Seleccione Crear APIy, a continuación, para API HTTP, seleccione Crear.
3. En API name (Nombre de la API), escribahttp-crud-tutorial-api.
4. Elija Next (Siguiente).
5. En Configurar rutas, seleccione Siguiente para omitir la creación de rutas. Se crearán rutas más
adelante.
6. Revise la etapa que API Gateway crea y, a continuación, seleccione Siguiente.
7. Seleccione Create (Crear).

Paso 4: crear rutas

Las rutas son una manera de enviar solicitudes entrantes de API a los recursos de backend. Las
rutas constan de dos partes: un método HTTP y una ruta de recurso, por ejempl, GET /items. Para
este ejemplo de API, creamos cuatro rutas:

• GET /items/{id}
• GET /items
• PUT /items
• DELETE /items/{id}

Para crear rutas

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.
3. Elija Routes (Rutas).
4. Seleccione Create (Crear).
5. En Method (Método), seleccione GET.
6. En la ruta de acceso, introduzca /items/{id}. El {id} al final de la ruta es un parámetro de
ruta que API Gateway recupera de la ruta de solicitud cuando un cliente realiza una solicitud.
7. Seleccione Create (Crear).
8. Repita los pasos 4 a 7 para GET /items, DELETE /items/{id}, y PUT /items.

API CRUD con Lambda y DynamoDB 223

Amazon API Gateway Guía para desarrolladores

Paso 5: crear una integración

Se crea una integración para conectar una ruta a los recursos de backend. Para este ejemplo de API,
se crea una integración Lambda que se utiliza para todas las rutas.

Para crear una integración

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.

3. Seleccione Integraciones.
4. Seleccione Administrar integraciones y, a continuación, seleccione Crear.

5. Omitir Conectar esta integración a una ruta. Esta etapa se completará más adelante.

6. En Tipo de integración, seleccione Función Lambda.

7. En Función Lambda, introduzca http-crud-tutorial-function.

8. Seleccione Create (Crear).

API CRUD con Lambda y DynamoDB 224

Amazon API Gateway Guía para desarrolladores

Paso 6: conectar la integración a las rutas

Para este ejemplo de API, se utiliza la misma integración Lambda para todas las rutas. Después de
conectar la integración a todas las rutas de la API, la función Lambda se invoca cuando un cliente
llama a cualquiera de sus rutas.

Para conectar integraciones a rutas

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.
3. Seleccione Integraciones.
4. Seleccione una ruta.
5. En Elegir una integración existente, seleccione http-crud-tutorial-function.
6. Seleccione Conectar integración.
7. Repita los pasos 4 a 6 para todas las rutas.

Todas las rutas muestran que se adjuntó una integración de AWS Lambda.

API CRUD con Lambda y DynamoDB 225

Amazon API Gateway Guía para desarrolladores

Ahora que se tiene una API HTTP con rutas e integraciones, se puede probar la API.

Paso 7: probar la API

Para asegurarse de que la API está funcionando, se utiliza curl.

Para obtener la URL para invocar la API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.

3. Tenga en cuenta la URL de invocación de la API. Aparece en Invocar URL en la página Detalles.

4. Copie la URL de invocación de la API.

La totalidad de la URL se parece a https://abcdef123.execute-api.us-

west-2.amazonaws.com.

Para crear o actualizar un elemento

• Utilice el siguiente comando para crear o actualizar un artículo. El comando incluye un cuerpo de
solicitud con el ID, el precio y el nombre del artículo.

API CRUD con Lambda y DynamoDB 226

Amazon API Gateway Guía para desarrolladores

curl -X "PUT" -H "Content-Type: application/json" -d "{\"id\": \"123\",

\"price\": 12345, \"name\": \"myitem\"}" https://abcdef123.execute-api.us-
west-2.amazonaws.com/items

Para ver todos los artículos

• Utilice el siguiente comando para enumerar todos los artículos.

curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items

Para ver un artículo

• Utilice el siguiente comando para ver un artículo por su ID.

curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123

Para eliminar un elemento

1. Utilice el siguiente comando para eliminar un artículo.

curl -X "DELETE" https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123

2. Ver todos los artículos para verificar que el artículo se eliminó.

curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items

Paso 8: Eliminar

Para evitar costos innecesarios, elimine los recursos creados como parte de este ejercicio
introductorio. Los siguientes pasos eliminan la API HTTP, la función de Lambda y los recursos
asociados.

Para eliminar una tabla de DynamoDB

1. Abra la consola de DynamoDB en https://console.aws.amazon.com/dynamodb/.

2. Seleccionar la tabla.

API CRUD con Lambda y DynamoDB 227

Amazon API Gateway Guía para desarrolladores

3. Elija Delete table (Eliminar tabla).

4. Confirme la elección y seleccione Eliminar.

Para eliminar una API HTTP

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. En la página API, seleccione una API. Seleccione Actions y, luego, Delete.

3. Elija Eliminar.

Para eliminar una función de Lambda

1. Inicie sesión en la consola de Lambda en https://console.aws.amazon.com/lambda/.

2. En la página Functions (Funciones), seleccione una función. Seleccione Actions y, luego, Delete.

3. Elija Eliminar.

Para eliminar el grupo de registro de una función de Lambda

1. En la consola de Amazon CloudWatch, abra la página de grupos de registro.

2. En la página Grupos de registro, seleccione el grupo de registro de la función (/aws/lambda/

http-crud-tutorial-function). Elija Actions (Acciones) y, a continuación, elija Delete log
group (Eliminar grupo de registro).

3. Elija Eliminar.

Para eliminar el rol de ejecución de una función de Lambda

1. En la consola de AWS Identity and Access Management, abra la página Roles (Roles).
2. Seleccione el rol de la función, por ejempl, http-crud-tutorial-role.

3. Elija Delete role (Eliminar rol).

4. Elija Sí, eliminar.

API CRUD con Lambda y DynamoDB 228

Amazon API Gateway Guía para desarrolladores

Pasos siguientes: automatización con AWS SAM o AWS CloudFormation

Puede automatizar la creación y la limpieza de los recursos de AWS mediante el uso de AWS
CloudFormation o AWS SAM. Para obtener un ejemplo de plantilla de AWS SAM para este tutorial,
consulte template.yaml.

Para obtener plantillas de AWS CloudFormation de ejemplo, consulte las plantillas de AWS
CloudFormation de ejemplo.

Tutorial: creación de una API HTTP con una integración privada en un

Servicio Amazon ECS

En este tutorial, creará una API sin servidor que se conecta a un Servicio Amazon ECS que se
ejecuta en una Amazon VPC Los clientes fuera de su VPC de Amazon pueden utilizar la API para
acceder al Servicio Amazon ECS.

Para completar este tutorial se necesita aproximadamente una hora. En primer lugar, utilice una
plantilla de AWS CloudFormation para crear una nube de Amazon VPC y un servicio Amazon ECS.
Luego, utilice la consola de API Gateway para crear un enlace de VPC. El vínculo VPC permite a API
Gateway acceder al Servicio Amazon ECS que se ejecuta en su Amazon VPC A continuación, cree
una API HTTP que utilice el vínculo VPC para conectarse al Servicio Amazon ECS. Por último, se
prueba la API.

Al invocar la API HTTP, API Gateway envía la solicitud al Servicio Amazon ECS a través del vínculo
VPC y, a continuación, devuelve la respuesta del servicio.

Para completar este tutorial, necesita una cuenta de AWS y un usuario de AWS Identity and Access
Management con acceso a la consola. Para obtener más información, consulte Requisitos previos.

Integración privada en Amazon ECS 229

Amazon API Gateway Guía para desarrolladores

En este tutorial, se utiliza la AWS Management Console. Para obtener una plantilla de AWS
CloudFormation que cree esta API y todos los recursos relacionados, consulte template.yaml.

Temas
• Paso 1: crear un Servicio Amazon ECS
• Paso 2: crear un enlace de VPC
• Paso 3: crear una API HTTP
• Paso 4: creación de una ruta
• Paso 5: crear una integración
• Paso 6: probar la API
• Paso 7: Limpieza
• Próximos pasos: automatice con AWS CloudFormation

Paso 1: crear un Servicio Amazon ECS

Amazon ECS es un servicio de administración de contenedores que le facilita la tarea de ejecutar,

detener y administrar contenedores de Docker en un clúster. En este tutorial, ejecute el clúster en
una infraestructura sin servidor administrada por Amazon ECS.

Descargue y descomprima esta plantilla de AWS CloudFormation que crea todas las dependencias
del servicio, incluida una nube de Amazon VPC. Utilice la plantilla para crear un Servicio Amazon
ECS que utilice un Application Load Balancer.

Para crear una pila de AWS CloudFormation

1. Abra la consola de AWS CloudFormation en https://console.aws.amazon.com/cloudformation.

2. Seleccione Create stack (Crear pila) y, a continuación, seleccione With new resources (standard)
(Con nuevos recursos [estándar]).
3. En Specify template (Especificar plantilla), elija Upload a template file (Cargar un archivo de
plantilla).
4. Seleccione la plantilla que ha descargado.
5. Elija Next (Siguiente).
6. En Stack name (Nombre de pila), escriba http-api-private-integrations-tutorial y,
a continuación, elija Next (Siguiente).

Integración privada en Amazon ECS 230

Amazon API Gateway Guía para desarrolladores

7. En Configure stack options (Configurar opciones de pila), elija Next (Siguiente).

8. Para Capabilities (Capacidades), sepa que AWS CloudFormation puede crear recursos de IAM
en su cuenta.
9. Elija Create stack.

AWS CloudFormation aprovisiona al Servicio ECS. Puede tardar unos minutos. Cuando el estado de
la pila de AWS CloudFormation sea CREATE_COMPLETE, estará listo para continuar con el paso
siguiente.

Paso 2: crear un enlace de VPC

Un enlace de VPC permite a API Gateway acceder a recursos privados en una Amazon VPC Utilice
un enlace de VPC para permitir a los clientes acceder al Servicio Amazon ECS a través de su API
HTTP.

Para crear un enlace de VPC

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija VPC links (Enlaces de VPC) y, a continuación, elija Create (Crear).
3. En Choose a VPC link version (Elegir una versión de enlace de VPC), seleccione VPC link for
HTTP APIs (Enlace de VPC para API HTTP).
4. En Name (Nombre) escriba private-integrations-tutorial.
5. En VPC, elija la VPC que ha creado en el paso 1. El nombre debe comenzar con
PrivateIntegrationsStack.
6. En Subnets (Subredes), seleccione las dos subredes privadas de la VPC. Los nombres terminan
en PrivateSubnet.
7. Seleccione Create (Crear).

Después de crear el vínculo VPC, API Gateway aprovisiona las interfaces de red elásticas para
acceder a la VPC. El proceso puede demorar unos minutos. Mientras tanto, puede crear su API.

Paso 3: crear una API HTTP

La API HTTP proporciona un punto de enlace HTTP para su Servicio Amazon ECS. En este paso, se
crea una API vacía. En los pasos 4 y 5, va a configurar una ruta y una integración para conectar la
API y el Servicio Amazon ECS.

Integración privada en Amazon ECS 231

Amazon API Gateway Guía para desarrolladores

Para crear una API HTTP

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Seleccione Crear APIy, a continuación, para API HTTP, seleccione Crear.
3. En API name (Nombre de la API), escribahttp-private-integrations-tutorial.
4. Elija Next (Siguiente).
5. En Configurar rutas, seleccione Siguiente para omitir la creación de rutas. Se crearán rutas más
adelante.
6. Revise la etapa que API Gateway le crea. API Gateway crea una etapa $default con
implementaciones automáticas habilitadas, que es la mejor opción para este tutorial. Elija Next
(Siguiente).
7. Seleccione Create (Crear).

Paso 4: creación de una ruta

Las rutas son una manera de enviar solicitudes entrantes de API a los recursos de backend. Las
rutas constan de dos partes: un método HTTP y una ruta de recurso, por ejempl, GET /items. Para
este ejemplo de API, creamos una ruta.

Para crear una ruta

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.
3. Elija Routes (Rutas).
4. Seleccione Create (Crear).
5. En Method (Método), seleccione ANY.
6. En la ruta de acceso, introduzca /{proxy+}. El {proxy+} al final de la ruta es una variable de
ruta voraz. API Gateway envía todas las solicitudes a su API por esta ruta.
7. Seleccione Create (Crear).

Paso 5: crear una integración

Se crea una integración para conectar una ruta a los recursos de backend.

Integración privada en Amazon ECS 232

Amazon API Gateway Guía para desarrolladores

Para crear una integración

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.

3. Seleccione Integraciones.

4. Seleccione Administrar integraciones y, a continuación, seleccione Crear.

5. En Atach this intergration to a route (Adjuntar esta integración a una ruta), seleccione la ruta
ANY/{proxy+} que creó anteriormente.

6. En Integration type (Tipo de integración), elija Private resource (Recurso privado).

7. En Integration details (Detalles de integración), elija Select manually (Seleccionar manualmente).

8. En Target service (Servicio de destino), seleccione ALB/NLB.

9. En Load balancer (Equilibrador de carga), elija el equilibrador de carga que creó con la plantilla
de AWS CloudFormation en el paso 1. El nombre debería comenzar con http-Priva.

10. En Listener (Agente de escucha), elija HTTP 80.

11. Para VPC link (Enlace de VPC), elija el enlace de VPC que creó en el paso 2. El nombre debería
ser private-integrations-tutorial.

12. Seleccione Create (Crear).

Para comprobar que la ruta y la integración están configuradas correctamente, seleccione Attach
integrations to routes (Adjuntar las integraciones a las rutas). La consola muestra que tiene una ruta
ANY /{proxy+} con una integración a un balanceador de carga de VPC.

Integración privada en Amazon ECS 233

Amazon API Gateway Guía para desarrolladores

Ya está listo para probar su API.

Paso 6: probar la API

A continuación, pruebe su API para asegurarse de que se encuentra en funcionamiento. Para mayor
simplicidad, utilice un navegador web para invocar la API.

Para probar la API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.

3. Tenga en cuenta la URL de invocación de la API.

Integración privada en Amazon ECS 234

Amazon API Gateway Guía para desarrolladores

4. En un navegador web, vaya a la URL que invoca a su API.

La URL completa debería ser https://abcdef123.execute-api.us-

east-2.amazonaws.com.

Su navegador envía una GET solicitud a la API.

5. Compruebe que la respuesta de la API sea un mensaje de bienvenida que le indique que su
aplicación se está ejecutando en Amazon ECS.

Si ve el mensaje de bienvenida, ha creado correctamente un Servicio Amazon ECS que se

ejecuta en la VPC de Amazon y ha utilizado una API HTTP de API Gateway con un vínculo VPC
para acceder al servicio Amazon ECS.

Paso 7: Limpieza

Para evitar costos innecesarios, elimine los recursos creados como parte de este tutorial Los pasos
siguientes eliminan el enlace de la VPC, la pila de AWS CloudFormation y la API HTTP.

Para eliminar una API HTTP

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

Integración privada en Amazon ECS 235

Amazon API Gateway Guía para desarrolladores

2. En la página API, seleccione una API. Elija Action (Acciones), elija Delete (Eliminar)y, a
continuación, confirme su elección.

Para eliminar un enlace de VPC

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija VPC link (Enlace de VPC).

3. Seleccione el enlace de VPC, elija Delete (Eliminar)y, a continuación, confirme su elección.

Para eliminar una pila de AWS CloudFormation

1. Abra la consola de AWS CloudFormation en https://console.aws.amazon.com/cloudformation.

2. Seleccione su pila de AWS CloudFormation.

3. Elija Delete (Eliminar) y, a continuación, confirme su elección.

Próximos pasos: automatice con AWS CloudFormation

Puede automatizar la creación y la limpieza de todos los recursos de AWS involucrados en

este tutorial. Para obtener una plantilla de AWS CloudFormation de ejemplo completa, consulte
template.yaml.

Tutoriales de la API REST de Amazon API Gateway

Los siguientes tutoriales proporcionan ejercicios prácticos que le ayudarán a obtener información
sobre las API de WebSocket de API Gateway.

Temas

• Tutorial: Creación de una aplicación de chat sin servidor con una API de WebSocket, Lambda y
DynamoDB

Tutoriales de la API de WebSocket 236

Amazon API Gateway Guía para desarrolladores

Tutorial: Creación de una aplicación de chat sin servidor con una API de
WebSocket, Lambda y DynamoDB

En este tutorial, creará una aplicación de chat sin servidor con una API de WebSocket. Con una
API de WebSocket, puede admitir la comunicación bidireccional entre clientes. Los clientes pueden
recibir mensajes sin tener que sondear para comprobar si hay actualizaciones.

Se tardan aproximadamente 30 minutos en completar este tutorial. En primer lugar, usará una
plantilla de AWS CloudFormation para crear funciones Lambda que gestionarán las solicitudes de
API, así como una tabla de DynamoDB que almacena los ID de cliente. A continuación, utilizará
la consola de API Gateway para crear una API de WebSocket que se integra con las funciones
Lambda. Por último, probarás la API para verificar que se envían y reciben mensajes.

Para completar este tutorial, necesita una cuenta de AWS y un usuario de AWS Identity and Access
Management con acceso a la consola. Para obtener más información, consulte Requisitos previos.

También es necesario wscat para conectarse a la API. Para obtener más información, consulte the
section called “Utilice wscat para conectarse y enviar mensajes a una API de WebSocket”.

En este tutorial, se utiliza AWS Management Console. Para obtener una plantilla de AWS
CloudFormation que cree esta API y todos los recursos relacionados, consulte chat-app.yaml.

Aplicación de chat de WebSocket 237

Amazon API Gateway Guía para desarrolladores

Temas
• Paso 1: Crear funciones Lambda y una tabla de DynamoDB
• Paso 2: Crear una API de WebSocket
• Paso 3: probar la API
• Paso 4: Limpiar
• Próximos pasos: automatice con AWS CloudFormation

Paso 1: Crear funciones Lambda y una tabla de DynamoDB

Descargue y descomprima la plantilla de creación de aplicaciones para AWS CloudFormation.

Utilizará esta plantilla para crear una tabla de Amazon DynamoDB para almacenar los ID de cliente
de la aplicación. Cada cliente conectado tiene un ID único que utilizaremos como clave de partición
de la tabla. Esta plantilla también crea funciones Lambda que actualizan las conexiones de clientes
en DynamoDB y gestionan el envío de mensajes a los clientes conectados.

Para crear una pila de AWS CloudFormation

1. Abra la consola de AWS CloudFormation en https://console.aws.amazon.com/cloudformation.

2. Seleccione Create stack (Crear pila) y, a continuación, seleccione With new resources (standard)
(Con nuevos recursos [estándar]).
3. En Specify template (Especificar plantilla), elija Upload a template file (Cargar un archivo de
plantilla).
4. Seleccione la plantilla que ha descargado.
5. Elija Next (Siguiente).
6. En Stack name (Nombre de pila), escriba websocket-api-chat-app-tutorial y, a
continuación, elija Next (Siguiente).
7. En Configure stack options (Configurar opciones de pila), elija Next (Siguiente).
8. Para Capabilities (Capacidades), sepa que AWS CloudFormation puede crear recursos de IAM
en su cuenta.
9. Elija Create stack.

AWS CloudFormation aprovisiona los recursos especificados en la plantilla. Puede tardar varios
minutos en finalizar el aprovisionamiento de los recursos. Cuando el estado de la pila de AWS
CloudFormation sea CREATE_COMPLETE, estará listo para continuar con el paso siguiente.

Aplicación de chat de WebSocket 238

Amazon API Gateway Guía para desarrolladores

Paso 2: Crear una API de WebSocket

Creará una API de WebSocket para gestionar las conexiones de clientes y enrutar solicitudes a las
funciones Lambda que creó en el paso 1.

Para crear una API de WebSocket

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Seleccione Create API (Crear API). En WebSocket API (API de WebSocket), elija Build (Crear).

3. En API name (Nombre de la API), escribawebsocket-chat-app-tutorial.

4. Para Route selection expression (Expresión de selección de ruta), ingrese

request.body.action. La expresión de selección de ruta determina la ruta que API Gateway
invoca cuando un cliente envía un mensaje.
5. Elija Next (Siguiente).

6. Para Predefined routes (Rutas predefinidas), elija Add $connect (Agregar $connect), Add
$disconnect (Agregar $disconnect) y Add $default (Agregar $default). Las rutas $connect y
$disconnect son rutas especiales que API Gateway invoca automáticamente cuando un cliente
se conecta o se desconecta de una API. API Gateway invoca la ruta $default cuando ninguna
otra ruta coincide con una solicitud.

7. Para Custom routes (Rutas personalizadas), elija Add custom route (Agregar ruta
personalizada). Para Route key (Clave de ruta), ingrese sendmessage. Esta ruta personalizada
gestiona los mensajes que se envían a los clientes conectados.

8. Elija Next (Siguiente).

9. En Attach integrations (Adjuntar integraciones), para cada ruta e Integration type (Tipo de
integración), elija Lambda.

Para Lambda, elija la función Lambda correspondiente que creó con AWS CloudFormation en
el paso 1. El nombre de cada función coincide con una ruta. Por ejemplo, para la ruta $connect,
elija la función denominada websocket-chat-app-tutorial-ConnectHandler.

10. Revise la etapa que API Gateway le crea. De forma predeterminada, API Gateway crea un
nombre de etapa production e implementa automáticamente la API en esa fase. Elija Next
(Siguiente).

11. Elija Create and deploy (Crear e implementar).

Aplicación de chat de WebSocket 239

Amazon API Gateway Guía para desarrolladores

Paso 3: probar la API

A continuación, pruebe la API para asegurarse de que funciona correctamente. Utilice el comando
wscat para conectarse a la API.

Para obtener la URL para invocar la API

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija la API.
3. Elija Stages (Etapas) y, a continuación, elija production (producción).
4. Tenga en cuenta la WebSocket URL (URL de WebSocket) de la API. La dirección URL
debe tener un aspecto similar al siguiente: wss://abcdef123.execute-api.us-
east-2.amazonaws.com/production.

Para conectarse a la API

1. Para conectarse a la API, utilice el siguiente comando. Cuando se conecte a la API, API
Gateway invoca la ruta $connect. Cuando se invoca esta ruta, llama a una función Lambda
que almacena el ID de conexión en DynamoDB.

wscat -c wss://abcdef123.execute-api.us-west-2.amazonaws.com/production

Connected (press CTRL+C to quit)

2. Abra un nuevo terminal y ejecute el comando wscat de nuevo con los siguientes parámetros.

wscat -c wss://abcdef123.execute-api.us-west-2.amazonaws.com/production

Connected (press CTRL+C to quit)

Esto le proporciona dos clientes conectados que pueden intercambiar mensajes.

Para enviar un mensaje

• API Gateway determina qué ruta invocar en función de la expresión de selección de rutas de
la API. La expresión de selección de rutas de la API es $request.body.action. Como
resultado, API Gateway invoca la ruta sendmessage cuando envía el siguiente mensaje:

Aplicación de chat de WebSocket 240

Amazon API Gateway Guía para desarrolladores

{"action": "sendmessage", "message": "hello, everyone!"}

La función Lambda asociada a la ruta invocada recopila los ID de cliente de DynamoDB. A

continuación, la función llama a la API de administración de API Gateway y envía el mensaje a
esos clientes. Todos los clientes conectados reciben el siguiente mensaje:

< hello, everyone!

Para invocar la ruta $default de la API

• API Gateway invoca la ruta predeterminada de la API cuando un cliente envía un mensaje que
no coincide con las rutas definidas. La función Lambda asociada a la ruta $default utiliza la
API de administración de API Gateway para enviar información al cliente sobre la conexión.

test

Use the sendmessage route to send a message. Your info:

{"ConnectedAt":"2022-01-25T18:50:04.673Z","Identity":
{"SourceIp":"192.0.2.1","UserAgent":null},"LastActiveAt":"2022-01-25T18:50:07.642Z","connec

Para desconectarse de la API

• Pulse CTRL+C para desconectarse de la API. Cuando un cliente se desconecta de la API,

API Gateway invoca la ruta $disconnect de la API. La integración de Lambda para la ruta
$disconnect de la API elimina el ID de conexión de DynamoDB.

Paso 4: Limpiar

Para evitar costos innecesarios, elimine los recursos creados como parte de este tutorial Los
siguientes pasos eliminan la pila y API de WebSocket de AWS CloudFormation.

Para eliminar una API de WebSocket

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

Aplicación de chat de WebSocket 241

Amazon API Gateway Guía para desarrolladores

2. En la página de las API, seleccione la API websocket-chat-app-tutorial. Elija Action

(Acciones), elija Delete (Eliminar)y, a continuación, confirme su elección.

Para eliminar una pila de AWS CloudFormation

1. Abra la consola de AWS CloudFormation en https://console.aws.amazon.com/cloudformation.

2. Seleccione su pila de AWS CloudFormation.
3. Elija Delete (Eliminar) y, a continuación, confirme su elección.

Próximos pasos: automatice con AWS CloudFormation

Puede automatizar la creación y la limpieza de todos los recursos de AWS involucrados en este
tutorial. Para ver un ejemplo de plantilla de AWS CloudFormation que automatiza estas acciones,
consulte chat-app.yaml.

Aplicación de chat de WebSocket 242

Amazon API Gateway Guía para desarrolladores

Uso de API de REST

Una API de REST en API Gateway es una colección de recursos y métodos que se integran con
puntos de enlace de HTTP del backend, funciones de Lambda u otros servicios de AWS. Puede
utilizar características de API Gateway para ayudarle con todos los aspectos del ciclo de vida de la
API, desde la creación hasta el monitoreo de sus API de producción.

Las API de REST de API Gateway utilizan un modelo de solicitud/respuesta en el que un cliente
envía una solicitud a un servicio y el servicio responde de forma sincrónica. Este tipo de modelo
es adecuado para muchos tipos diferentes de aplicaciones que dependen de la comunicación
sincrónica.

Temas
• Desarrollo de una API REST en API Gateway
• Publicación de una API de REST para que los clientes la invoquen
• Optimización del rendimiento de las API REST
• Distribución de la API de REST a los clientes
• Protección de la API REST
• Monitoreo de las API de REST

Desarrollo de una API REST en API Gateway

En esta sección se proporciona información detallada acerca de las capacidades de API Gateway
que necesitará para desarrollar las API de API Gateway.

A medida que se desarrolla la API de API Gateway, se decide sobre una serie de características de
la API. Estas características dependen del uso de la API. Por ejemplo, es posible que quiera permitir
solo a ciertos clientes llamar a la API o puede que quiera que esté disponible para todos. Puede
querer que una llamada a la API ejecute una función de Lambda, haga una consulta a la base de
datos o llame a una aplicación.

Temas
• Creación de una API REST en Amazon API Gateway
• Control y administración del acceso a una API REST en API Gateway

Desarrollo 243
Amazon API Gateway Guía para desarrolladores

• Configuración de integraciones de la API REST

• Uso de la validación de solicitudes en API Gateway
• Configuración de transformaciones de datos para API REST
• Respuestas de gateway en API Gateway
• Habilitación de CORS para un recurso de la API de REST
• Trabajar con tipos de medios binarios para API REST
• Invocación de una API REST en Amazon API Gateway
• Configuración de una API de REST mediante OpenAPI

Creación de una API REST en Amazon API Gateway

En Amazon API Gateway, las API REST se crean como una colección de entidades programables
conocidas como recursos de API Gateway. Por ejemplo, se utiliza un recurso RestApi para
representar una API que puede contener una colección de entidades Resource. Cada entidad
Resource a su vez puede tener uno o más recursos Method. Expresado en los parámetros de
solicitud y en el cuerpo, un Method define la interfaz de programación de aplicaciones del cliente
para obtener acceso al Resource expuesto y representa una solicitud entrante enviada por el
cliente. A continuación, se crea un recurso Integration para integrar el Method con un punto
de enlace de backend, también conocido como punto de enlace de integración, reenviando la
solicitud entrante a un URI de punto de enlace de integración especificado. Si es necesario, puede
transformar los parámetros de solicitud o el cuerpo para que cumplan los requisitos del backend.
Para las respuestas, puede crear un recurso MethodResponse para representar una respuesta
de solicitud recibida por el cliente y crear un recurso IntegrationResponse para representar la
respuesta de solicitud que devuelve el backend. Puede configurar la respuesta de integración para
transformar los datos de respuesta del backend antes de devolver los datos al cliente o transferir la
respuesta del backend tal y como está al cliente.

Para ayudar a sus clientes a comprender su API, también puede proporcionar documentación para la
API, como parte de la creación de la API o una vez que se ha creado. Para ello, agregue un recurso
DocumentationPart para una entidad de API compatible.

Para controlar el modo en que los clientes llaman a la API, utilice permisos de IAM, un autorizador de
Lambda o un grupo de usuarios de Amazon Cognito. Para medir el uso de la API, configure planes
de uso para limitar las solicitudes a la API. Puede habilitar estos elementos al crear o al actualizar la
API.

Crear y configurar 244

Amazon API Gateway Guía para desarrolladores

Puede realizar estas y otras tareas a través de la consola de API Gateway, la API REST de API
Gateway, la AWS CLI o uno de los AWS SDK. A continuación, trataremos cómo realizar estas tareas.

Temas
• Elección de un tipo de punto de enlace para configurarlo para una API de API Gateway
• Inicialización de la configuración de una API REST en API Gateway
• Configurar métodos de API REST en API Gateway

Elección de un tipo de punto de enlace para configurarlo para una API de API
Gateway

Los tipos de punto de enlace de API hacen referencia al nombre de host de la API. El punto de
enlace de la API puede ser de tres tipos, optimizado para sistemas perimetrales, regional o privado,
en función de dónde se origine la mayoría del tráfico de la API.

Punto de enlace de API optimizado para bordes

Un punto de conexión de API optimizada para límites normalmente dirige las solicitudes al punto
de presencia (POP) de CloudFront más cercano, lo que podría ayudar en caso de que sus clientes
estén en distintas ubicaciones geográficas. Este es el tipo de punto de enlace predeterminado para
las API REST de API Gateway.

Las API optimizadas para sistemas perimetrales utilizan mayúsculas en la inicial de los nombres de
los encabezados HTTP (por ejemplo, Cookie).

CloudFront ordena las cookies HTTP según su nombre antes de reenviar la solicitud al origen.
Para obtener más información sobre el modo en que CloudFront procesa las cookies, consulte
Almacenamiento en caché de contenido en función de cookies.

Cualquier nombre de dominio personalizado que se utilice con una API optimizada para sistemas
perimetrales se aplicará a todas las regiones.

Puntos de enlace de API regionales

Los puntos de enlace de API regionales están destinados a los clientes que se encuentran en la
misma región. Cuando un cliente que se ejecuta en una instancia EC2 llama a una API en la misma
región, o cuando una API tiene por objeto servir a una cantidad reducida de clientes con altas
demandas, una API regional reduce la sobrecarga de conexión.

Crear y configurar 245

Amazon API Gateway Guía para desarrolladores

En una API regional, el nombre de dominio personalizado es específico de la región en la que está
implementada la API. Si implementa una API regional en varias regiones, esta puede tener el mismo
nombre de dominio personalizado en todas las regiones. Puede utilizar dominios personalizados
junto con Amazon Route 53 para realizar tareas como el direccionamiento basado en latencia.
Para obtener más información, consulte the section called “Configuración de un nombre de dominio
regional personalizado” y the section called “Creación de un nombre de dominio personalizado
optimizado para bordes”.

Los puntos de enlace de API regionales transfieren todos los nombres de encabezado tal y como
están.

Puntos de enlace de API privados

Un punto de enlace de API privado es un punto de enlace de la API al que solo se pueda obtener
acceso desde una Amazon Virtual Private Cloud (VPC) mediante un punto de enlace de la VPC
de tipo interfaz, que es una interfaz de red de punto de enlace (ENI) que se crea en la VPC. Para
obtener más información, consulte the section called “API privadas”.

Los puntos de enlace de API privados transfieren todos los nombres de encabezado tal y como
están.

Cambiar el tipo de punto de enlace de una API pública o privada en API Gateway

Para cambiar el tipo de un punto de enlace de la API, es preciso actualizar la configuración de la API.
Puede cambiar un tipo de API existente a través de la consola de API Gateway, la AWS CLI o un
AWS SDK para API Gateway. El tipo de punto de conexión no puede volver a cambiarse hasta que
se complete el cambio actual, pero la API estará disponible.

Se admiten los siguientes cambios de tipo de puntos de enlace:

• De "optimizado para sistemas perimetrales" a "regional" o "privado"

• De "regional" a "optimizado para sistemas perimetrales" o "privado"
• De "privado" a "regional"

No puede transformar una API privada en una API optimizada para límites.

Si va a cambiar una API pública optimizada para límites a regional o viceversa, tenga en cuenta que
las API optimizadas para sistemas perimetrales pueden comportarse de forma distinta que las API
regionales. Por ejemplo, una API optimizada para límites elimina el encabezado Content-MD5.

Crear y configurar 246

Amazon API Gateway Guía para desarrolladores

Cualquier valor de hash MD5 transmitido al backend se puede expresar en un parámetro de cadena
de solicitud o una propiedad del cuerpo. Sin embargo, la API regional transmite este encabezado,
aunque puede reasignar el nombre de encabezado a otro nombre. Comprender estas diferencias le
ayuda a decidir cómo actualizar una API optimizada para límites a una regional o bien de una API
regional a una optimizada para límites.

Temas
• Uso de la consola de API Gateway para cambiar el tipo de punto de enlace de la API
• Uso de la AWS CLI para cambiar el tipo de punto de enlace de una API

Uso de la consola de API Gateway para cambiar el tipo de punto de enlace de la API

Para cambiar el tipo de punto de enlace de la API, siga uno de estos procedimientos:

Para convertir un punto de conexión público de regional u optimizado para límites y viceversa

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija una API de REST.
3. Elija Configuración de la API.
4. En la sección Detalles de la API, elija Editar.
5. En Tipo de punto de conexión de la API, seleccione Optimizado para límites o Regional.
6. Elija Guardar cambios.
7. Vuelva a implementar la API para que los cambios surtan efecto.

Para convertir un punto de enlace privado en un punto de enlace regional

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija una API de REST.
3. Modifique la política de recursos de la API para eliminar cualquier mención a las VPC o los
puntos de enlace de la VPC, de modo que tanto las llamadas a la API que se realicen desde
fuera de la VPC como las que se realicen desde dentro se ejecuten correctamente.
4. Elija Configuración de la API.
5. En la sección Detalles de la API, elija Editar.
6. En Tipo de punto de conexión de la API, seleccione Regional.
7. Elija Guardar cambios para iniciar la actualización.

Crear y configurar 247

Amazon API Gateway Guía para desarrolladores

8. Quite la política de recursos de la API.

9. Vuelva a implementar la API para que los cambios surtan efecto.

Uso de la AWS CLI para cambiar el tipo de punto de enlace de una API

Si desea utilizar la AWS CLI para actualizar una API optimizada para sistemas perimetrales cuyo ID
es {api-id}, llame a update-resto-api tal y como se indica a continuación:

aws apigateway update-rest-api \

--rest-api-id {api-id} \
--patch-operations op=replace,path=/endpointConfiguration/types/EDGE,value=REGIONAL

La respuesta correcta tiene un código de estado 200 OK y una carga similar a la siguiente:

"createdDate": "2017-10-16T04:09:31Z",
"description": "Your first API with Amazon API Gateway. This is a sample API that
integrates via HTTP with our demo Pet Store endpoints",
"endpointConfiguration": {
"types": "REGIONAL"
},
"id": "0gsnjtjck8",
"name": "PetStore imported as edge-optimized"
}

De igual forma, actualice una API regional a una API optimizada para límites del modo siguiente:

aws apigateway update-rest-api \

--rest-api-id {api-id} \
--patch-operations op=replace,path=/endpointConfiguration/types/REGIONAL,value=EDGE

Dado que put-rest-api se utiliza para actualizar definiciones de API, no puede utilizarse para
actualizar un tipo de punto de enlace de API.

Inicialización de la configuración de una API REST en API Gateway

Para este ejemplo, utilizamos una API PetStore simplificada, con la integración HTTP, que expone
los métodos GET /pets y GET /pets/{petId}. Los métodos se integran con los dos puntos de

Crear y configurar 248

Amazon API Gateway Guía para desarrolladores

enlace HTTP, respectivamente, de http://petstore-demo-endpoint.execute-api.com/

petstore/pets y http://petstore-demo-endpoint.execute-api.com/petstore/
pets/{petId}. La API gestiona las respuestas 200 OK. Los ejemplos se centran en las tareas
de programación esenciales para crear una API en API Gateway, aprovechando los ajustes
predeterminados cuando sea posible.

Debido a los ajustes predeterminados, la API resultante está optimizada para límites. Una alternativa
es configurar una API regional. Para configurar una API regional, debe establecer explícitamente el
tipo de punto de enlace de la API como REGIONAL. Para configurar una API optimizada para límites
explícitamente, puede establecer EDGE como tipo de endpointConfiguration.

Al configurar una API, debe elegir una región. Cuando se implementa, la API es específica de una
región. En el caso de una API optimizada para bordes, la URL base tiene el formato http[s]://
{restapi-id}.execute-api.amazonaws.com/stage, donde {restapi-id} es el valor de
id de la API generado por API Gateway. Puede asignar un nombre de dominio personalizado (por
ejemplo, apis.example.com) como nombre de host de la API y llamar a la API con una URL base
con el formato https://apis.example.com/myApi.

Temas
• Configuración de una API con la consola de API Gateway
• Configurar una API optimizada para bordes mediante comandos de AWS CLI
• Configurar una API optimizada para bordes con el SDK de AWS para Node.js
• Configurar una API optimizada para bordes importando definiciones de OpenAPI
• Configuración de una API regional en API Gateway

Configuración de una API con la consola de API Gateway

Para configurar una API de API Gateway mediante la consola de API Gateway, consulte Tutorial:
Desarrollo de una API de REST con integración HTTP no de proxy.

Puede obtener información sobre cómo configurar una API siguiendo un ejemplo. Para obtener más
información, consulte Tutorial: Crear una API de REST importando un ejemplo.

Como alternativa, puede crear una API a través de la función Importar API de API Gateway
para cargar una definición de API externa, como la expresada en OpenAPI 2.0 con Trabajar con
extensiones de API Gateway para OpenAPI. En el ejemplo proporcionado en Tutorial: Crear una API
de REST importando un ejemplo se utiliza la característica Import API.

Crear y configurar 249

Amazon API Gateway Guía para desarrolladores

Configurar una API optimizada para bordes mediante comandos de AWS CLI

Para configurar una API mediante la AWS CLI, es necesario trabajar con los comandos create-
rest-api, create-resource o get-resources, put-method, put-method-response, put-
integration y put-integration-response. Los siguientes procedimientos muestran cómo
trabajar con estos comandos de la AWS CLI para crear la API de PetStore del tipo de integración
HTTP.

Para crear una API PetStore sencilla mediante la AWS CLI

1. Llame al comando create-rest-api para configurar la RestApi en una región concreta (us-
west-2).

aws apigateway create-rest-api --name 'Simple PetStore (AWS CLI)' --region us-
west-2

A continuación se muestra la salida de este comando:

{
"id": "vaz7da96z6",
"name": "Simple PetStore (AWS CLI)",
"createdDate": "2022-12-15T08:07:04-08:00",
"apiKeySource": "HEADER",
"endpointConfiguration": {
"types": [
"EDGE"
]
},
"disableExecuteApiEndpoint": false
}

Anote el id devuelto de la RestApi recién creada. Lo necesitará para configurar otras partes de
la API.

2. Llame al comando get-resources para recuperar el identificador del recurso raíz de la

RestApi.

aws apigateway get-resources --rest-api-id vaz7da96z6 --region us-west-2

A continuación se muestra la salida de este comando:

Crear y configurar 250

Amazon API Gateway Guía para desarrolladores

{
"items": [
{
"id": "begaltmsm8",
"path": "/"
}
]
}

Anote el del recurso raí Id. Lo necesitará para comenzar a establecer el árbol de recursos de la
API y para configurar métodos e integraciones.

3. Llame al comando create-resource para asociar un recurso secundario (pets) bajo el

recurso raíz (begaltmsm8):

aws apigateway create-resource --rest-api-id vaz7da96z6 \

--region us-west-2 \
--parent-id begaltmsm8 \
--path-part pets

A continuación se muestra la salida de este comando:

{
"id": "6sxz2j",
"parentId": "begaltmsm8",
"pathPart": "pets",
"path": "/pets"
}

Para asociar un recurso secundario bajo la raíz, se especifica el Id del recurso raíz como
valor de la propiedad parentId. Del forma similar, para asociar un recurso secundario bajo el
recurso pets, se repite el paso anterior y se sustituye el valor parent-id por el pets id del
recurso de 6sxz2j:

aws apigateway create-resource --rest-api-id vaz7da96z6 \

--region us-west-2 \
--parent-id 6sxz2j \
--path-part '{petId}'

Crear y configurar 251

Amazon API Gateway Guía para desarrolladores

Para hacer de una parte de la ruta un parámetro de ruta, sitúela entre llaves. Si se ejecuta
correctamente, este comando devuelve la siguiente respuesta:

{
"id": "rjkmth",
"parentId": "6sxz2j",
"path": "/pets/{petId}",
"pathPart": "{petId}"
}

Ahora que ha creado dos recursos, /pets (6sxz2j) y /pets/{petId} (rjkmth), puede
continuar configurando métodos sobre ellos.

4. Llame al comando put-method para añadir el método HTTP GET en el recurso /pets. Esto
crea un Method de API de GET /pets con acceso abierto, haciendo referencia al recurso /
pets mediante su valor de ID de 6sxz2j.

aws apigateway put-method --rest-api-id vaz7da96z6 \

--resource-id 6sxz2j \
--http-method GET \
--authorization-type "NONE" \
--region us-west-2

Si se ejecuta correctamente, el resultado de este comando sería el siguiente:

{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": false
}

El método es de acceso abierto porque authorization-type está ajustado en NONE. Para

permitir que solo puedan llamar al método los usuarios autenticados, puede utilizar políticas
y roles de IAM, un autorizador de Lambda (que anteriormente se denominaba autorizador
personalizado) o un grupo de usuarios de Amazon Cognito. Para obtener más información,
consulte the section called “Control de acceso”.

Para habilitar el acceso de lectura al recurso /pets/{petId} (rjkmth), añada el método

HTTP GET para crear un Method de API de GET /pets/{petId} del siguiente modo.

Crear y configurar 252

Amazon API Gateway Guía para desarrolladores

aws apigateway put-method --rest-api-id vaz7da96z6 \

--resource-id rjkmth --http-method GET \
--authorization-type "NONE" \
--region us-west-2 \
--request-parameters method.request.path.petId=true

Si se ejecuta correctamente, el resultado de este comando sería el siguiente:

{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": false,
"requestParameters": {
"method.request.path.petId": true
}
}

Tenga en cuenta que el parámetro de ruta de solicitud de método de petId debe especificarse
como un parámetro de solicitud necesario para que su valor establecido dinámicamente se
asigne a un parámetro de solicitud de integración correspondiente y se transfiera al backend.

5. Llame al comando put-method-response para configurar la respuesta 200 OK del método

GET /pets, especificando el recurso /pets mediante su valor de ID de 6sxz2j.

aws apigateway put-method-response --rest-api-id vaz7da96z6 \

--resource-id 6sxz2j --http-method GET \
--status-code 200 --region us-west-2

A continuación se muestra la salida de este comando:

{
"statusCode": "200"
}

De forma similar, para establecer la respuesta 200 OK del método GET /pets/{petId},
realice lo siguiente, especificando el recurso /pets/{petId} mediante su valor de ID de
recurso de rjkmth:

aws apigateway put-method-response --rest-api-id vaz7da96z6 \

Crear y configurar 253

Amazon API Gateway Guía para desarrolladores

--resource-id rjkmth --http-method GET \

--status-code 200 --region us-west-2

Tras configurar una interfaz de cliente sencilla para la API, puede continuar y configurar la
integración de los métodos de la API con el backend.

6. Llame al comando put-integration para configurar una Integration con un punto de

enlace HTTP especificado para el método GET /pets. El recurso /pets se identifica mediante
su id de recurso 6sxz2j:

aws apigateway put-integration --rest-api-id vaz7da96z6 \

--resource-id 6sxz2j --http-method GET --type HTTP \
--integration-http-method GET \
--uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets' \
--region us-west-2

A continuación se muestra la salida de este comando:

{
"type": "HTTP",
"httpMethod": "GET",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"connectionType": "INTERNET",
"passthroughBehavior": "WHEN_NO_MATCH",
"timeoutInMillis": 29000,
"cacheNamespace": "6sxz2j",
"cacheKeyParameters": []
}

Tenga en cuenta que el uri de integración de http://petstore-demo-

endpoint.execute-api.com/petstore/pets especifica el punto de enlace de integración
del método GET /pets.

De forma similar, se crea una solicitud de integración para el método GET /pets/{petId} del
siguiente modo:

aws apigateway put-integration \

--rest-api-id vaz7da96z6 \
--resource-id rjkmth \
--http-method GET \
--type HTTP \
Crear y configurar 254
Amazon API Gateway Guía para desarrolladores

--integration-http-method GET \
--uri 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}' \
--request-parameters
'{"integration.request.path.id":"method.request.path.petId"}' \
--region us-west-2

Aquí, el punto de enlace de integración, uri de http://petstore-demo-

endpoint.execute-api.com/petstore/pets/{id}, también utiliza un parámetro de ruta
(id). Su valor se asigna a partir del parámetro de ruta de solicitud de método correspondiente de
{petId}. La asignación se define como parte de request-parameters. Si esta asignación
no se define aquí, el cliente recibe una respuesta de error al intentar llamar al método.

A continuación se muestra la salida de este comando:

{
"type": "HTTP",
"httpMethod": "GET",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"connectionType": "INTERNET",
"requestParameters": {
"integration.request.path.id": "method.request.path.petId"
},
"passthroughBehavior": "WHEN_NO_MATCH",
"timeoutInMillis": 29000,
"cacheNamespace": "rjkmth",
"cacheKeyParameters": []
}

7. Llame al comando put-integration-response para crear una entidad

IntegrationResponse del método GET /pets integrada con un backend HTTP.

aws apigateway put-integration-response --rest-api-id vaz7da96z6 \

--resource-id 6sxz2j --http-method GET \
--status-code 200 --selection-pattern "" \
--region us-west-2

A continuación se muestra la salida de este comando:

{
"statusCode": "200",
"selectionPattern": ""

Crear y configurar 255

Amazon API Gateway Guía para desarrolladores

Del forma similar, llame al siguiente comando put-integration-response para crear una
IntegrationResponse del método GET /pets/{petId}:

aws apigateway put-integration-response --rest-api-id vaz7da96z6 \

--resource-id rjkmth --http-method GET
--status-code 200 --selection-pattern ""
--region us-west-2

Con los pasos anteriores, ha terminado la configuración de una API sencilla que permite a
sus clientes consultar las mascotas disponibles en el sitio web de PetStore y ver una mascota
concreta con un identificador especificado. Para que el cliente pueda llamar a la API, debe
implementarla.
8. Implemente la API en una etapa stage llamando, por ejemplo, a create-deployment:

aws apigateway create-deployment --rest-api-id vaz7da96z6 \

--region us-west-2 \
--stage-name test \
--stage-description 'Test stage' \
--description 'First deployment'

A continuación se muestra la salida de este comando:

{
"id": "ab1c1d",
"description": "First deployment",
"createdDate": "2022-12-15T08:44:13-08:00"
}

Puede probar esta API escribiendo la URL https://vaz7da96z6.execute-api.us-

west-2.amazonaws.com/test/pets en un navegador y sustituyendo vaz7da96z6 por el
identificador de la API. La salida esperada debe ser la siguiente:

[
{
"id": 1,
"type": "dog",

Crear y configurar 256

Amazon API Gateway Guía para desarrolladores

"price": 249.99
},
{
"id": 2,
"type": "cat",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]

Para probar el método GET /pets/{petId}, escriba https://vaz7da96z6.execute-api.us-

west-2.amazonaws.com/test/pets/3 en el navegador. Debería recibir la siguiente respuesta:

{
"id": 3,
"type": "fish",
"price": 0.99
}

Configurar una API optimizada para bordes con el SDK de AWS para Node.js

Como ejemplo, utilizamos el AWS SDK para Node.js para describir cómo se puede utilizar un AWS
SDK para crear una API de API Gateway. Para obtener más información sobre el uso de un SDK de
AWS, incluida la configuración del entorno de desarrollo, consulte SDK de AWS.

La configuración de una API mediante el SDK de AWS para Node.js implica la llamada
a las funciones createRestApi, createResource o getResources, putMethod,
putMethodResponse, putIntegration y putIntegrationResponse.

Los siguientes procedimientos le guiarán por los pasos necesarios para utilizar estos comandos del
SDK con el fin de configurar una sencilla API de PetStore que admita los métodos GET /pets y
GET /pets/{petId}.

Para configurar una API sencilla de PetStore con el SDK de AWS para Node.js

1. Inicie el SDK:

var AWS = require('aws-sdk');

Crear y configurar 257

Amazon API Gateway Guía para desarrolladores

AWS.config.region = 'us-west-2';
var apig = new AWS.APIGateway({apiVersion: '2015/07/09'});

2. Llame a la función createRestApi para configurar la entidad RestApi.

apig.createRestApi({
name: "Simple PetStore (node.js SDK)",
binaryMediaTypes: [
'*'
],
description: "Demo API created using the AWS SDK for node.js",
version: "0.00.001"
}, function(err, data){
if (!err) {
console.log(data);
} else {
console.log('Create API failed:\n', err);
}
});

La función devuelve un resultado similar al siguiente:

{
id: 'iuo308uaq7',
name: 'PetStore (node.js SDK)',
description: 'Demo API created using the AWS SDK for node.js',
createdDate: 2017-09-05T19:32:35.000Z,
version: '0.00.001',
binaryMediaTypes: [ '*' ]
}

El identificador de API resultante es iuo308uaq7. Debe facilitarlo para continuar la

configuración de la API.

3. Llame a la función getResources para recuperar el identificador de recurso raíz de la

RestApi.

apig.getResources({
restApiId: 'iuo308uaq7'
}, function(err, data){
if (!err) {

Crear y configurar 258

Amazon API Gateway Guía para desarrolladores

console.log(data);
} else {
console.log('Get the root resource failed:\n', err);
}
})

Esta función devuelve un resultado similar al siguiente:

{
"items": [
{
"path": "/",
"id": "s4fb0trnk0"
}
]
}

El identificador de recurso raíz es s4fb0trnk0. Este es el punto de partida para la crear el árbol
de recursos de la API, que es el siguiente paso.

4. Llame a la función createResource para configurar el recurso /pets para la API,

especificando el identificador de recurso raíz (s4fb0trnk0) en la propiedad parentId.

apig.createResource({
restApiId: 'iuo308uaq7',
parentId: 's4fb0trnk0',
pathPart: 'pets'
}, function(err, data){
if (!err) {
console.log(data);
} else {
console.log("The '/pets' resource setup failed:\n", err);
}
})

El resultado correcto es el siguiente:

{
"path": "/pets",
"pathPart": "pets",
"id": "8sxa2j",
"parentId": "s4fb0trnk0'"
Crear y configurar 259
Amazon API Gateway Guía para desarrolladores

Para configurar el recurso /pets/{petId}, llame a la siguiente función createResource,

especificando el recurso /pets recién creado (8sxa2j) en la propiedad parentId.

apig.createResource({
restApiId: 'iuo308uaq7',
parentId: '8sxa2j',
pathPart: '{petId}'
}, function(err, data){
if (!err) {
console.log(data);
} else {
console.log("The '/pets/{petId}' resource setup failed:\n", err);
}
})

El resultado correcto devuelve el valor id del recurso recién creado:

{
"path": "/pets/{petId}",
"pathPart": "{petId}",
"id": "au5df2",
"parentId": "8sxa2j"
}

A lo largo de este procedimiento, se hace referencia al recurso /pets especificando su ID de

recurso de 8sxa2j y al recurso /pets/{petId} especificando su ID de recurso de au5df2.
5. Llame a la función putMethod para añadir el método HTTP GET en el recurso /pets (8sxa2j).
Esto configura el GET /pets Method con acceso abierto.

apig.putMethod({
restApiId: 'iuo308uaq7',
resourceId: '8sxa2j',
httpMethod: 'GET',
authorizationType: 'NONE'
}, function(err, data){
if (!err) {
console.log(data);
} else {

Crear y configurar 260

Amazon API Gateway Guía para desarrolladores

console.log("The 'GET /pets' method setup failed:\n", err);

}
})

Esta función devuelve un resultado similar al siguiente:

{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE"
}

Para añadir el método HTTP GET en el recurso /pets/{petId} (au5df2), que configura el
método de API de GET /pets/{petId} con acceso abierto, llame a la función putMethod del
siguiente modo.

apig.putMethod({
restApiId: 'iuo308uaq7',
resourceId: 'au5df2',
httpMethod: 'GET',
authorizationType: 'NONE',
requestParameters: {
"method.request.path.petId" : true
}
}, function(err, data){
if (!err) {
console.log(data);
} else {
console.log("The 'GET /pets/{petId}' method setup failed:\n", err);
}
})

Esta función devuelve un resultado similar al siguiente:

{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE",
"requestParameters": {
"method.request.path.petId": true
}

Crear y configurar 261

Amazon API Gateway Guía para desarrolladores

Debe establecer la propiedad requestParameters tal y como se muestra en el ejemplo

anterior para asignar y transferir el valor petId suministrado por el cliente al backend.

6. Llame a la función putMethodResponse para configurar una respuesta de método para el

método GET /pets.

apig.putMethodResponse({
restApiId: 'iuo308uaq7',
resourceId: "8sxa2j",
httpMethod: 'GET',
statusCode: '200'
}, function(err, data){
if (!err) {
console.log(data);
} else {
console.log("Set up the 200 OK response for the 'GET /pets' method failed:\n",
err);
}

})

Esta función devuelve un resultado similar al siguiente:

{
"statusCode": "200"
}

Para establecer la respuesta 200 OK del método GET /pets/{petId}, llame a la función
putMethodResponse, especificando el identificador de recurso /pets/{petId} (au5df2) en
la propiedad resourceId.

apig.putMethodResponse({
restApiId: 'iuo308uaq7',
resourceId: "au5df2",
httpMethod: 'GET',
statusCode: '200'
}, function(err, data){
if (!err) {
console.log(data);

Crear y configurar 262

Amazon API Gateway Guía para desarrolladores

} else {
console.log("Set up the 200 OK response for the 'GET /pets/{petId}' method
failed:\n", err);
}

})

7. Llame a la función putIntegration para configurar la Integration con un punto de enlace

HTTP especificado para el método GET /pets, facilitando el identificador del recurso /pets
(8sxa2j) en la propiedad parentId.

apig.putIntegration({
restApiId: 'iuo308uaq7',
resourceId: '8sxa2j',
httpMethod: 'GET',
type: 'HTTP',
integrationHttpMethod: 'GET',
uri: 'http://perstore-demo-endpoint.execute-api.com/pets'
}, function(err, data){
if (!err) {
console.log(data);
} else {
console.log("Set up the integration of the 'GET /' method of the API failed:\n",
err);
}

})

Esta función devuelve un resultado similar al siguiente:

{
"httpMethod": "GET",
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"type": "HTTP",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"cacheNamespace": "8sxa2j"
}

Para configurar la integración del método GET /pets/{petId} con el punto de enlace HTTP
de http://perstore-demo-endpoint.execute-api.com/pets/{id} del backend, llame

Crear y configurar 263

Amazon API Gateway Guía para desarrolladores

a la siguiente función putIntegration, facilitando el identificador de recurso /pets/{petId}

de la API (au5df2) en la propiedad parentId.

apig.putIntegration({
restApiId: 'iuo308uaq7',
resourceId: 'au5df2',
httpMethod: 'GET',
type: 'HTTP',
integrationHttpMethod: 'GET',
uri: 'http://perstore-demo-endpoint.execute-api.com/pets/{id}',
requestParameters: {
"integration.request.path.id": "method.request.path.petId"
}
}, function(err, data){
if (!err) {
console.log(data);
} else {
console.log("The 'GET /pets/{petId}' method integration setup failed:\n", err);
}

})

Esta función devuelve un resultado correcto similar al siguiente:

{
"httpMethod": "GET",
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"type": "HTTP",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"cacheNamespace": "au5df2",
"requestParameters": {
"integration.request.path.id": "method.request.path.petId"
}
}

8. Llame a la función putIntegrationResponse para configurar la respuesta de integración

200 OK para el método GET /pets, especificando el identificador de recurso /pets de la API
(8sxa2j) en la propiedad resourceId.

apig.putIntegrationResponse({
restApiId: 'iuo308uaq7',

Crear y configurar 264

Amazon API Gateway Guía para desarrolladores

resourceId: '8sxa2j',
httpMethod: 'GET',
statusCode: '200',
selectionPattern: ''
}, function(err, data){
if (!err) {
console.log(data);
} else
console.log("The 'GET /pets' method integration response setup failed:\n", err);

})

Esta función devolverá un resultado similar al siguiente:

{
"selectionPattern": "",
"statusCode": "200"
}

Para configurar la respuesta de integración 200 OK del método GET /pets/{petId}, llame
a la función putIntegrationResponse, especificando el identificador del recurso /pets/
{petId} de la API (au5df2) en la propiedad resourceId.

apig.putIntegrationResponse({
restApiId: 'iuo308uaq7',
resourceId: 'au5df2',
httpMethod: 'GET',
statusCode: '200',
selectionPattern: ''
}, function(err, data){
if (!err) {
console.log(data);
} else
console.log("The 'GET /pets/{petId}' method integration response setup failed:
\n", err);

})

9. Como buena práctica, pruebe a invocar la API antes de implementarla. Para probar la invocación
del método GET /pets, llame al testInvokeMethod, especificando el identificador de recurso
/pets (8sxa2j) en la propiedad resourceId:

Crear y configurar 265

Amazon API Gateway Guía para desarrolladores

apig.testInvokeMethod({
restApiId: 'iuo308uaq7',
resourceId: '8sxa2j',
httpMethod: "GET",
pathWithQueryString: '/'
}, function(err, data){
if (!err) {
console.log(data)
} else {
console.log('Test-invoke-method on 'GET /pets' failed:\n', err);
}
})

Para probar la invocación del método GET /pets/{petId}, llame al testInvokeMethod,

especificando el identificador de recurso /pets/{petId} (au5df2) en la propiedad
resourceId:

apig.testInvokeMethod({
restApiId: 'iuo308uaq7',
resourceId: 'au5df2',
httpMethod: "GET",
pathWithQueryString: '/'
}, function(err, data){
if (!err) {
console.log(data)
} else {
console.log('Test-invoke-method on 'GET /pets/{petId}' failed:\n', err);
}
})

10. Por último, puede implementar la API para que la llamen sus clientes.

apig.createDeployment({
restApiId: 'iuo308uaq7',
stageName: 'test',
stageDescription: 'test deployment',
description: 'API deployment'
}, function(err, data){
if (err) {
console.log('Deploying API failed:\n', err);

Crear y configurar 266

Amazon API Gateway Guía para desarrolladores

} else {
console.log("Deploying API succeeded\n", data);
}
})

Configurar una API optimizada para bordes importando definiciones de OpenAPI

Puede configurar una API en API Gateway especificando definiciones de OpenAPI de las entidades
API de API Gateway correspondientes e importando las definiciones de OpenAPI en API Gateway.

Las siguientes definiciones de OpenAPI describen la API sencilla, que expone solo el método
GET / integrado con un punto de enlace HTTP del sitio web PetStore en el backend y devuelve una
respuesta 200 OK.

OpenAPI 2.0

{
"swagger": "2.0",
"info": {
"title": "Simple PetStore (OpenAPI)"
},
"schemes": [
"https"
],
"paths": {
"/pets": {
"get": {
"responses": {
"200": {
"description": "200 response"
}
},
"x-amazon-apigateway-integration": {
"responses": {
"default": {
"statusCode": "200"
}
},
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "http"

Crear y configurar 267

Amazon API Gateway Guía para desarrolladores

}
}
},
"/pets/{petId}": {
"get": {
"parameters": [
{
"name": "petId",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response"
}
},
"x-amazon-apigateway-integration": {
"responses": {
"default": {
"statusCode": "200"
}
},
"requestParameters": {
"integration.request.path.id": "method.request.path.petId"
},
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"passthroughBehavior": "when_no_match",
"httpMethod": "GET",
"type": "http"
}
}
}
}
}

El siguiente procedimiento describe cómo importar estas definiciones de OpenAPI en API Gateway
mediante la consola de API Gateway.

Crear y configurar 268

Amazon API Gateway Guía para desarrolladores

Para importar las definiciones de OpenAPI de la API sencilla utilizando la consola de API Gateway

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Elija Crear APIy, a continuación, para API de REST, elija Importar.
3. Si guardó las definiciones de OpenAPI anteriores en un archivo, elija Elegir archivo. También
puede copiar las definiciones de OpenAPI y pegarlas en el editor de texto de importación.
4. En Tipo de punto de conexión de la API, seleccione Optimizado para límites.
5. Elija Crear API para importar las definiciones de OpenAPI.

Para importar las definiciones de OpenAPI utilizando la AWS CLI, guarde las definiciones de
OpenAPI en un archivo y, a continuación, ejecute el siguiente comando, en el que se supone que
la región es us-west-2 y que la ruta absoluta del archivo de OpenAPI es file:///path/to/
API_OpenAPI_template.json:

aws apigateway import-rest-api --body 'file:///path/to/API_OpenAPI_template.json' --

region us-west-2

Configuración de una API regional en API Gateway

Cuando las solicitudes de API se originan predominantemente desde una instancia EC2 o servicios
dentro de la misma región donde se ha implementado la API, normalmente un punto de enlace
de API regional reducirá la latencia de las conexiones, lo que se recomienda para este tipo de
situaciones.

Note
En los casos en que los clientes de la API están dispersos geográficamente, sigue teniendo
sentido utilizar un punto de enlace de API regional, junto con su propia distribución de
Amazon CloudFront para garantizar que API Gateway no asocia la API con distribuciones de
CloudFront controladas por servicios. Para obtener más información acerca de este caso de
uso, consulte la sección sobre cómo configurar API Gateway con mi propia distribución de
CloudFront.

Para crear una API regional, siga los pasos que se indican en la sección de creación de una API
optimizada para bordes, pero debe definir de forma explícita el tipo REGIONAL como única opción de
endpointConfiguration en la API.

Crear y configurar 269

Amazon API Gateway Guía para desarrolladores

A continuación, mostramos cómo crear una API regional utilizando la consola de API Gateway, la
AWS CLI y el AWS SDK para JavaScript en Node.js.

Temas
• Crear una API regional mediante la consola de API Gateway
• Creación de una API regional con la AWS CLI
• Creación de una API regional con el SDK de AWS para JavaScript
• Prueba de una API regional

Crear una API regional mediante la consola de API Gateway

Para crear una API regional mediante la consola de API Gateway

1. Inicie sesión en la consola de API Gateway en https://console.aws.amazon.com/apigateway.

2. Realice una de las siguientes acciones:
• Para crear la primera API, para API de REST, elija Crear.
• Si ha creado una API antes, elija Crear API y, a continuación, elija Crear para API de REST.
3. En Nombre, ingrese un nombre.
4. (Opcional) En Description (Descripción), introduzca una descripción.
5. Mantenga Tipo de punto de conexión de la API establecido en Regional.
6. Elija Crear API.

Creación de una API regional con la AWS CLI

Para crear una API regional con la AWS CLI, llame al comando create-rest-api:

aws apigateway create-rest-api \

--name 'Simple PetStore (AWS CLI, Regional)' \
--description 'Simple regional PetStore API' \
--region us-west-2 \
--endpoint-configuration '{ "types": ["REGIONAL"] }'

Una respuesta correcta devuelve una carga similar a la siguiente:

{
"createdDate": "2017-10-13T18:41:39Z",

Crear y configurar 270

Amazon API Gateway Guía para desarrolladores

"description": "Simple regional PetStore API",

"endpointConfiguration": {
"types": "REGIONAL"
},
"id": "0qzs2sy7bh",
"name": "Simple PetStore (AWS CLI, Regional)"
}

A partir de aquí, puede seguir las mismas instrucciones dadas en the section called “Configurar
una API optimizada para bordes mediante comandos de AWS CLI” para configurar métodos e
integraciones para esta API.

Creación de una API regional con el SDK de AWS para JavaScript

Para crear una API regional con el SDK de AWS para JavaScript:

apig.createRestApi({
name: "Simple PetStore (node.js SDK, regional)",
endpointConfiguration: {
types: ['REGIONAL']
},
description: "Demo regional API created using the AWS SDK for node.js",
version: "0.00.001"
}, function(err, data){
if (!err) {
console.log('Create API succeeded:\n', data);
restApiId = data.id;
} else {
console.log('Create API failed:\n', err);
}
});

Una respuesta correcta devuelve una carga similar a la siguiente:

{
"createdDate": "2017-10-13T18:41:39Z",
"description": "Demo regional API created using the AWS SDK for node.js",
"endpointConfiguration": {
"types": "REGIONAL"
},
"id": "0qzs2sy7bh",
"name": "Simple PetStore (node.js SDK, regional)"

Crear y configurar 271

Amazon API Gateway Guía para desarrolladores

Una vez realizados los pasos anteriores, puede seguir las instrucciones en the section called
“Configurar una API optimizada para bordes con el SDK de AWS para Node.js” para configurar
métodos e integraciones para esta API.

Prueba de una API regional

Una vez implementada, el nombre de host de la URL predeterminada de la API regional tiene el
siguiente formato:

{restapi-id}.execute-api.{region}.amazonaws.com

La URL base para invocar la API es como la siguiente:

https://{restapi-id}.execute-api.{region}.amazonaws.com/{stage}

Suponiendo que configura los métodos GET /pets y GET /pets/{petId} en este ejemplo, puede
probar la API escribiendo las siguientes URL en un navegador:

https://0qzs2sy7bh.execute-api.us-west-2.amazonaws.com/test/pets

Protección de los datos

https://0qzs2sy7bh.execute-api.us-west-2.amazonaws.com/test/pets/1

También puede utilizar los comandos de cURL:

curl -X GET https://0qzs2sy7bh.execute-api.us-west-2.amazonaws.com/test/pets

curl -X GET https://0qzs2sy7bh.execute-api.us-west-2.amazonaws.com/test/pets/2

Configurar métodos de API REST en API Gateway

En API Gateway, un método de API incluye una solicitud de método y una respuesta de método.
Se configura un método de API para definir lo que un cliente debería o debe hacer para enviar

Crear y configurar 272

Amazon API Gateway Guía para desarrolladores

una solicitud de acceso al servicio en el backend y para definir las respuestas que recibe a
cambio el cliente. Para la entrada, puede elegir los parámetros de solicitud de método, o bien una
carga aplicable, para que el cliente proporcione los datos necesarios u opcionales en el tiempo
de ejecución. Para la salida, se determina el código de estado de respuesta del método, los
encabezados y el cuerpo aplicable como destinos a los que asignar los datos de respuesta del
backend, antes de que se devuelvan al cliente. Para ayudar al desarrollador cliente a comprender los
comportamientos y los formatos de entrada y salida de su API, puede documentar la API y ofrecer
mensajes de error adecuados para solicitudes no válidas.

Una solicitud de método de API es una solicitud HTTP. Para configurar la solicitud de método, debe
configurar un método (o verbo) HTTP, la ruta a un recurso de API, los encabezados y los parámetros
de cadenas de consulta aplicables. También configura una carga cuando el método HTTP es POST,
PUTo PATCH. Por ejemplo, para recuperar una mascota con la API de muestra PetStore, define la
solicitud de método de API de GET /pets/{petId}, donde {petId} es un parámetro de ruta que
puede tomar un número en tiempo de ejecución.

GET /pets/1
Host: apigateway.us-east-1.amazonaws.com
...

Si el cliente especifica una ruta incorrecta, por ejemplo, /pet/1 o /pets/one en lugar de /pets/1,
se lanza una excepción.

Una respuesta de método de API es una respuesta HTTP con un código de estado determinado.
Para una integración que no sea de proxy, debe configurar respuestas de método para especificar
los destinos necesarios u opcionales de las asignaciones. Estos transforman los encabezados o
el cuerpo de respuesta de la integración en encabezados o en cuerpo de respuesta de método. El
mapeo puede ser tan sencillo como una transformación de identidad que pasa los encabezados o
el cuerpo a través de la integración tal y como están. Por ejemplo, la siguiente respuesta de método
200 muestra un ejemplo de transferencia de una respuesta de integración correcta tal y como está.

200 OK
Content-Type: application/json
...

{
"id": "1",
"type": "dog",
"price": "$249.99"

Crear y configurar 273

Amazon API Gateway Guía para desarrolladores

En principio, puede definir una respuesta de método correspondiente a una respuesta específica
desde el backend. Normalmente, esto implica cualquier respuesta 2XX, 4XX y 5XX. Sin embargo,
puede que no sea práctico, porque a menudo es posible que no sepa con antelación todas las
respuestas que puede devolver un backend. En la práctica, puede designar una respuesta de
método como predeterminada para gestionar las respuestas desconocidas o no asignadas desde el
backend. Es una buena práctica designar la respuesta 500 como predeterminada. En cualquier caso,
debe configurar al menos una respuesta de método para integraciones que no sean de proxy. De lo
contrario, API Gateway devuelve una respuesta de error 500 al cliente incluso cuando la solicitud se
completa correctamente en el backend.

Para admitir un SDK con establecimiento inflexible de tipos para la API, como un SDK de Java, debe
definir el modelo de datos de entrada para la solicitud de método y definir el modelo de datos de
salida de la respuesta de método.

Temas
• Configurar una solicitud de método en API Gateway
• Configurar respuestas de método en API Gateway
• Configuración de un método con la consola de API Gateway

Configurar una solicitud de método en API Gateway

Configurar una solicitud de método implica realizar las siguientes tareas, después de la creación de
un recurso RestApi:

1. Creación de una nueva API o elección de una entidad Resource de API existente.
2. Creación de un recurso Method de API que sea un verbo HTTP específico en el Resource nuevo
o elegido de la API. Esta tarea se puede dividir aún más en las siguientes subtareas:
• Añadido de un método HTTP a la solicitud de métodos
• Configuración de parámetros de solicitudes
• Definición de un modelo para el cuerpo de la solicitud
• Aplicación de un esquema de autorización
• Habilitación de la validación de la solicitud

Puede realizar estas tareas con los siguientes métodos:

Crear y configurar 274

Amazon API Gateway Guía para desarrolladores

• Consola de API Gateway

• Comandos de la AWS CLI (create-resource y put-method)
• Función del SDK de AWS (como, en Node.js, createResource y putMethod)
• API REST de API Gateway (resource:create y method:put).

Para ver ejemplos del uso de estas herramientas, consulte Inicialización de la configuración de una
API REST en API Gateway.

Temas
• Configurar recursos de API
• Configurar un método HTTP
• Configurar parámetros de solicitud de método
• Configurar un modelo de solicitud de método
• Configurar la autorización de solicitud de método
• Configurar la validación de solicitud de método

Configurar recursos de API

En una API de API Gateway, los recursos que se pueden dirigir se exponen como un árbol de
entidades Resources de API, con el recurso de raíz (/) en la parte superior de la jerarquía. El recurso
de raíz depende de la URL base de la API, que se compone del punto de enlace de la API y un
nombre de etapa. En la consola de API Gateway, este URI base se denomina Invoke URI y se
muestra en el editor de etapas de la API una vez que se implementa la API.

El punto de enlace de la API puede ser un nombre de host predeterminado o un nombre de dominio
personalizado. El nombre de host predeterminado tiene el siguiente formato:

{api-id}.execute-api.{region}.amazonaws.com

En este formato, la {api-id} representa el identificador de la API que genera API Gateway.
La variable {region} representa la región de AWS (por ejemplo, us-east-1) que eligió al
crear la API. Un nombre de dominio personalizado es cualquier nombre fácil de recordar en un
dominio de Internet válido. Por ejemplo, si ha registrado un dominio de Internet de example.com,
*.example.com es un nombre de dominio personalizado válido. Para obtener más información,
consulte configurar nombres de dominio personalizados.

Crear y configurar 275

Amazon API Gateway Guía para desarrolladores

Para la API de ejemplo de PetStore, el recurso de raíz (/) expone la tienda de mascotas. El recurso
/pets representa la variedad de mascotas disponibles en la tienda. El /pets/{petId} expone una
mascota individual de un identificador concreto (petId). El parámetro de la ruta de {petId} forma
parte de los parámetros de solicitudes.

Para configurar un recurso de API, se elige un recurso existente como principal y, a continuación, se
crea el recurso secundario bajo el recurso principal. Se empieza con el recurso raíz como principal,
se añade un recurso a este principal, se añade otro recurso a este recurso secundario como nuevo
principal, etc., a su identificador principal. A continuación, se añade el recurso designado al principal.

Con la AWS CLI, puede llamar al comando get-resources para averiguar qué recursos de una
API están disponibles:

aws apigateway get-resources --rest-api-id <apiId> \

--region <region>

El resultado es una lista de los recursos disponibles de la API actualmente. En la API de nuestro
ejemplo de PetStore, esta lista sería similar a la siguiente:

{
"items": [
{
"path": "/pets",
"resourceMethods": {
"GET": {}
},
"id": "6sxz2j",
"pathPart": "pets",
"parentId": "svzr2028x8"
},
{
"path": "/pets/{petId}",
"resourceMethods": {
"GET": {}
},
"id": "rjkmth",
"pathPart": "{petId}",
"parentId": "6sxz2j"
},
{
"path": "/",
"id": "svzr2028x8"

Crear y configurar 276

Amazon API Gateway Guía para desarrolladores

}
]
}

Cada elemento enumera los identificadores del recurso (id) y, excepto el recurso raíz, su recurso
principal inmediato (parentId), así como el nombre del recurso (pathPart). El recurso raíz es
especial, ya que no tiene ninguno principal. Después de elegir un recurso como principal, llame al
siguiente comando para añadir un recurso secundario.

aws apigateway create-resource --rest-api-id <apiId> \

--region <region> \
--parent-id <parentId> \
--path-part <resourceName>

Por ejemplo, para añadir alimentos de mascotas para la venta en el sitio web de PetStore, añada un
recurso food a la raíz (/), estableciendo path-part para food y parent-id para svzr2028x8. El
resultado es similar al siguiente:

{
"path": "/food",
"pathPart": "food",
"id": "xdsvhp",
"parentId": "svzr2028x8"
}

Utilizar un recurso proxy para simplificar la configuración de API

A medida que crece el negocio, el propietario de PetStore puede que decida añadir a la venta
alimentos, juguetes y otros artículos relacionados con mascotas. Para sustentarlo, puede añadir
/food, /toys y otros recursos debajo del recurso raíz. Debajo de cada categoría de venta, es
posible que también desee añadir más recursos, como por ejemplo /food/{type}/{item},
/toys/{type}/{item}, etc. Esto puede ser una tarea tediosa. Si decide añadir una capa
intermedia {subtype} a las rutas de recursos para cambiar la jerarquía de rutas a /food/{type}/
{subtype}/{item}, /toys/{type}/{subtype}/{item}, etc., los cambios afectarán a la
configuración existente de la API. Para evitarlo, puede utilizar un recurso de proxy de API Gateway
para exponer un conjunto de recursos de la API a la vez.

API Gateway define un recurso de proxy como un marcador de posición para que un recurso se
especifique cuando se envíe la solicitud. Un recurso de proxy se expresa mediante un parámetro

Crear y configurar 277

Amazon API Gateway Guía para desarrolladores

de ruta especial de {proxy+}, a menudo denominado parámetro de ruta expansiva. El signo +

indica los recursos secundarios que lleva asociados. El marcador de posición /parent/{proxy
+} equivale a cualquier recurso que coincida con el patrón de ruta de /parent/*. El nombre de
parámetro de ruta expansiva, proxy, se puede sustituir con otra cadena, del mismo modo que se
trata un nombre de parámetro de ruta normal.

Con la AWS CLI, llama al siguiente comando para configurar un recurso de proxy bajo la raíz (/
{proxy+}):

aws apigateway create-resource --rest-api-id <apiId> \

--region <region> \
--parent-id <rootResourceId> \
--path-part {proxy+}

El resultado es similar al siguiente:

{
"path": "/{proxy+}",
"pathPart": "{proxy+}",
"id": "234jdr",
"parentId": "svzr2028x8"
}

Para el ejemplo de API de PetStore, puede utilizar /{proxy+} para representar tanto /pets
como /pets/{petId}. Este recurso de proxy también puede hacer referencia a cualquier otro
recurso (existente o que se vaya a añadir), como por ejemplo /food/{type}/{item}, /toys/
{type}/{item}, etc., o /food/{type}/{subtype}/{item}, /toys/{type}/{subtype}/
{item}, etc. El desarrollador del backend determina la jerarquía de recursos y el desarrollador
cliente es responsable de comprenderlo. API Gateway simplemente transfiere lo que envíe el cliente
al backend.

Una API puede tener más de un recurso de proxy. Por ejemplo, los siguientes recursos de proxy
están permitidos dentro de una API.

/{proxy+}
/parent/{proxy+}
/parent/{child}/{proxy+}

Cuando un recurso de proxy tiene elementos secundarios que no son de proxy, los recursos
secundarios se excluyen de la representación del recurso de proxy. En los ejemplos anteriores, /

Crear y configurar 278

Amazon API Gateway Guía para desarrolladores

{proxy+} hace referencia a cualquier recurso bajo el recurso raíz, excepto los recursos /parent[/
*]. En otras palabras, una solicitud de método realizada para un recurso específico prevalece sobre
una solicitud de método realizada para un recurso genérico en el mismo nivel de la jerarquía de
recursos.

Un recurso de proxy no puede tener cualquier recurso secundario. Un recurso de API después de
{proxy+} es redundante y ambiguo. Los siguientes recursos de proxy no se permiten dentro de una
API.

/{proxy+}/child
/parent/{proxy+}/{child}
/parent/{child}/{proxy+}/{grandchild+}

Configurar un método HTTP

Una solicitud de métodos de API se encapsula mediante el recurso Method de API Gateway. Para
configurar la solicitud de método, primero debe iniciar el recurso Method, configurando al menos un
método HTTP y un tipo de autorización en el método.

API Gateway, estrechamente asociado con el recurso de proxy, admite un método HTTP de ANY.
Este método ANY representa cualquier método HTTP que se suministre en el tiempo de ejecución. Le
permite utilizar una sola configuración de método de API para todos los métodos HTTP admitidos de
DELETE, GET, HEAD, OPTIONS, PATCH, POST y PUT.

También puede configurar el método ANY en un recurso que no sea de proxy. Al combinar el método
ANY con un recurso de proxy, obtiene una configuración de método de API único para todos los
métodos compatibles con HTTP frente a cualquier recurso de una API. Además, el backend puede
evolucionar sin que afecte a la configuración de API existente.

Antes de configurar un método de API, tenga en cuenta quién puede llamar al método. Establezca
el tipo de autorización según su plan. Para un acceso abierto, establézcalo en NONE. Para utilizar
permisos de IAM, establezca el tipo de autorización en AWS_IAM. Para utilizar una función de
autorizador de Lambda, establezca esta propiedad en CUSTOM. Para utilizar un grupo de usuarios de
Amazon Cognito, establezca el tipo de autorización en COGNITO_USER_POOLS.

El siguiente comando de la AWS CLI muestra cómo crear una solicitud de método del verbo ANY
frente a un recurso especificado (6sxz2j), mediante los permisos de IAM para controlar su acceso.

aws apigateway put-method --rest-api-id vaz7da96z6 \

--resource-id 6sxz2j \

Crear y configurar 279

Amazon API Gateway Guía para desarrolladores

--http-method ANY \
--authorization-type AWS_IAM \
--region us-west-2

Para crear una solicitud de método de API con un tipo de autorización distinta, consulte the section
called “Configurar la autorización de solicitud de método”.

Configurar parámetros de solicitud de método

Los parámetros de solicitud de método son una forma para que un cliente proporcione los datos de
entrada o el contexto de ejecución necesarios para completar la solicitud de métodos. Un parámetro
de método puede ser un método de ruta, un encabezado o un parámetro de cadena de consulta.
Como parte de la configuración de solicitud de método, debe declarar los parámetros de solicitud
necesarios para que estén disponibles para el cliente. Para la integración que no sea de proxy,
puede traducir estos parámetros de solicitud en un formato que sea compatible con el requisito del
backend.

Por ejemplo, para la solicitud de métodos GET /pets/{petId}, la variable de ruta {petId} es un
parámetro de solicitud necesario. Puede declarar este parámetro de ruta cuando llame al comando
put-method de la AWS CLI. Esto se detalla de la siguiente manera:

aws apigateway put-method --rest-api-id vaz7da96z6 \

--resource-id rjkmth \
--http-method GET \
--authorization-type "NONE" \
--region us-west-2 \
--request-parameters method.request.path.petId=true

Si un parámetro no es necesario, puede establecerlo en false en request-parameters. Por

ejemplo, si el método GET /pets utiliza un parámetro de cadena de consulta opcional de type y un
parámetro de encabezado opcional de breed, puede declararlos usando el siguiente comando de la
CLI, suponiendo que el recurso /pets sea id 6sxz2j:

aws apigateway put-method --rest-api-id vaz7da96z6 \

--resource-id 6sxz2j \
--http-method GET \
--authorization-type "NONE" \
--region us-west-2 \
--request-parameters
method.request.querystring.type=false,method.request.header.breed=false

Crear y configurar 280

Amazon API Gateway Guía para desarrolladores

En lugar de esta forma abreviada, puede utilizar una cadena de JSON para establecer el valor
request-parameters:

'{"method.request.querystring.type":false,"method.request.header.breed":false}'

Con esta configuración, el cliente puede consultar las mascotas por tipo:

GET /pets?type=dog

Además, el cliente puede consultar los perros de raza caniche de la siguiente manera:

GET /pets?type=dog
breed:poodle

Para obtener información sobre cómo asignar parámetros de solicitud de método a parámetros de
solicitud de integración, consulte the section called “Integraciones”.

Configurar un modelo de solicitud de método

Para un método de API que pueda tomar datos de entrada en una carga, puede utilizar un modelo.
Un modelo se expresa en un esquema JSON, borrador 4 y describe la estructura de datos del cuerpo
de la solicitud. Con un modelo, un cliente puede determinar cómo construir una carga de solicitud
de métodos como entrada. Y lo que es más importante, API Gateway utiliza el modelo para validar
una solicitud, generar un SDK e inicializar una plantilla de mapeo para configurar la integración
en la consola de API Gateway. Para obtener información sobre cómo crear un modelo, consulte
Comprensión de los modelos de datos.

En función de los tipos de contenido, una carga de método puede tener diferentes formatos. Un
modelo se indexa frente al tipo de medio de la carga aplicada. API Gateway utiliza el encabezado
de la solicitud Content-Type para determinar el tipo de contenido. Para configurar modelos de
solicitud de método, añada pares de clave-valor con el formato "<media-type>":"<model-
name>" al mapa requestModels cuando llame al comando put-method de la AWS CLI.

Para utilizar el mismo modelo independientemente del tipo de contenido, especifique $default
como la clave.

Por ejemplo, para establecer un modelo en la carga de JSON de la solicitud de método POST /pets
de la API de ejemplo de PetStore, puede llamar al siguiente comando de la AWS CLI:

aws apigateway put-method \

Crear y configurar 281

Amazon API Gateway Guía para desarrolladores

--rest-api-id vaz7da96z6 \
--resource-id 6sxz2j \
--http-method POST \
--authorization-type "NONE" \
--region us-west-2 \
--request-models '{"application/json":"petModel"}'

Aquí, petModel es el valor de propiedad name de un recurso Model que describe una mascota. La
definición del esquema real se expresa como un valor de cadena JSON de la propiedad schema del
recurso Model.

En un SDK Java de la API, u otro tipo de SDK con establecimiento inflexible de tipos, los datos de
entrada se forman como la clase petModel derivada de la definición del esquema. Con el modelo
de solicitud, los datos de entrada en el SDK generado se forman en la clase Empty, que se deriva
del modelo Empty predeterminado. En este caso, el cliente no puede crear una instancia de la clase
de datos correcta para proporcionar la entrada necesaria.

Configurar la autorización de solicitud de método

Para controlar quién puede llamar al método de la API, puede configurar el tipo de autorización en
el método. Puede utilizar este tipo para aplicar uno de los autorizadores admitidos, incluidos roles y
políticas de IAM (AWS_IAM), un grupo de usuarios de Amazon Cognito (COGNITO_USER_POOLS), o
un autorizador de Lambda basado en funciones de Lambda (CUSTOM).

Para utilizar permisos de IAM para autorizar el acceso al método de la API, establezca la propiedad
de entrada authorization-type en AWS_IAM. Cuando esta opción está establecida, API
Gateway verifica la firma del intermediario en la solicitud en función de las credenciales del
intermediario. Si el usuario verificado tiene permiso para llamar al método, se acepta la solicitud. De
lo contrario, rechaza la solicitud y el intermediario recibe una respuesta de error no autorizado. La
llamada al método no se realiza correctamente a menos que el intermediario tenga permiso para
invocar el método de la API. La siguiente política de IAM concede permiso al intermediario para
llamar a cualquier método de API creado dentro de la misma Cuenta de AWS:

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [

Crear y configurar 282

Amazon API Gateway Guía para desarrolladores

"execute-api:Invoke"
],
"Resource": "arn:aws:execute-api:*:*:*"
}
]
}

Para obtener más información, consulte the section called “Usar permisos de IAM”.

Actualmente, solo puedes conceder esta política a los usuarios, grupos y roles de la Cuenta de AWS
del propietario de la API. Los usuarios de una Cuenta de AWS diferente pueden llamar a los métodos
de la API solo si se les permite asumir un rol de la Cuenta de AWS del propietario de la API con los
permisos necesarios para llamar a la acción execute-api:Invoke. Para obtener más información
sobre los permisos entre cuentas, consulte Uso de roles de IAM.

Puede utilizar la AWS CLI, un AWS SDK o un cliente de API REST, como ser, Postman, que
implementa el proceso de firma Signature Version 4.

Para utilizar un autorizador de Lambda con el fin de autorizar el acceso al método de la API,
establezca la propiedad de entrada authorization-type en CUSTOM y establezca la propiedad de
entrada authorizer-id en el valor de propiedad id de un autorizador de Lambda que ya exista. El
autorizador de Lambda al que se hace referencia puede ser del tipo TOKEN o REQUEST. Para obtener
información acerca de cómo crear un autorizador de Lambda, consulte the section called “Uso de
autorizadores Lambda”.

Para utilizar un grupo de usuarios de Amazon Cognito con el fin de autorizar el acceso al método
de la API, establezca la propiedad de entrada authorization-type en COGNITO_USER_POOLS
y establezca la propiedad de entrada authorizer-id en el valor de propiedad id del autorizador
COGNITO_USER_POOLS que ya se creó. Para obtener información sobre la creación de un
autorizador de grupo de usuarios de Amazon Cognito, consulte the section called “Uso de grupos de
usuarios de Amazon Cognito como autorizador para una API REST”.

Configurar la validación de solicitud de método

Puede habilitar la validación de solicitud al configurar una solicitud de método de API. Primero tiene
que crear un validador de solicitudes:

aws apigateway create-request-validator \

--rest-api-id 7zw9uyk9kl \
--name bodyOnlyValidator \

Crear y configurar 283

Amazon API Gateway Guía para desarrolladores

--validate-request-body \
--no-validate-request-parameters

Este comando de la CLI crea un validador de solicitud de solo cuerpo. A continuación, se muestra un
ejemplo de resultado:

{
"validateRequestParameters": false,
"validateRequestBody": true,
"id": "jgpyy6",
"name": "bodyOnlyValidator"
}

Con este validador de solicitud, puede habilitar la validación de solicitud como parte de la
configuración de solicitud de método:

aws apigateway put-method \

--rest-api-id 7zw9uyk9kl
--region us-west-2
--resource-id xdsvhp
--http-method PUT
--authorization-type "NONE"
--request-parameters '{"method.request.querystring.type": false,
"method.request.querystring.page":false}'
--request-models '{"application/json":"petModel"}'
--request-validator-id jgpyy6

Para que se incluya en la validación de solicitud, debe declararse un parámetro de

solicitud como sea necesario. Si el parámetro de cadena de consulta de la página se utiliza
en la validación de solicitud, el mapa de request-parameters del ejemplo anterior
debe especificarse como '{"method.request.querystring.type": false,
"method.request.querystring.page":true}'.

Configurar respuestas de método en API Gateway

Una respuesta de método de API encapsula el resultado de una solicitud de método de API que el
cliente recibirá. Los datos de salida incluyen un código de estado HTTP, algunos encabezados y
posiblemente un cuerpo.

Con las integraciones que no sean de proxy, los parámetros de respuesta especificados y el cuerpo
se pueden asignar desde los datos de respuesta de integración asociados o se les pueden asignar

Crear y configurar 284

Amazon API Gateway Guía para desarrolladores

determinados valores estáticos según las asignaciones. Estas asignaciones se especifican en la

respuesta de integración. La asignación puede ser una transformación idéntica que transfiere la
respuesta de integración tal y como es.

Con una integración de proxy, API Gateway transfiere la respuesta del backend a la respuesta del
método automáticamente. No es necesario configurar la respuesta del método de API. Sin embargo,
con la integración proxy de Lambda, la función de Lambda debe devolver un resultado de este
formato de salida para que API Gateway asigne correctamente la respuesta de integración a una
respuesta de método.

Mediante programación, la configuración de la respuesta de método equivale a crear un

recurso MethodResponse de API Gateway y a establecer las propiedades de statusCode,
responseParameters y responseModels.

Al establecer códigos de estado para un método de API, debe elegir uno como predeterminado
para gestionar cualquier respuesta de integración de un código de estado no previsto. Es razonable
establecer 500 como predeterminado, ya que esto equivale a emitir respuestas que de otro modo
no estarían asignadas como un error del servidor. Por motivos de instrucción, la consola de API
Gateway establece la respuesta 200 como la opción predeterminada. Pero puede restablecerla en la
respuesta 500.

Para configurar una respuesta de método, debe haber creado la solicitud de método.

Configurar el código de estado de la respuesta de método

El código de estado de una respuesta de método define un tipo de respuesta. Por ejemplo, las
respuestas de 200, 400 y 500 indican respuestas de éxito, de error del lado del cliente y de error del
lado del servidor, respectivamente.

Para configurar un código de estado de respuesta de método, establezca la propiedad statusCode

en un código de estado HTTP. El siguiente comando de la AWS CLI crea una respuesta de método
de 200.

aws apigateway put-method-response \

--region us-west-2 \
--rest-api-id vaz7da96z6 \
--resource-id 6sxz2j \
--http-method GET \
--status-code 200

Crear y configurar 285

Amazon API Gateway Guía para desarrolladores

Configurar parámetros de respuesta de métodos

Los parámetros de respuesta de método definen qué encabezados recibe el cliente en respuesta a
la solicitud de método asociado. Los parámetros de respuesta también especifican un objetivo al que
API Gateway asigna un parámetro de respuesta de integración, según los mapeos prescritos en la
respuesta de integración del método de la API.

Para configurar los parámetros de respuesta de método, agregue al mapa responseParameters

de MethodResponse pares de clave-valor con el formato "{parameter-name}":"{boolean}".
El siguiente comando de CLI muestra un ejemplo de configuración del encabezado my-header, la
variable de rutas petId y el parámetro de consulta query como objetivos de la asignación:

aws apigateway put-method-response \

--region us-west-2 \
--rest-api-id vaz7da96z6 \
--resource-id 6sxz2j \
--http-method GET \
--status-code 200 \
--response-parameters method.request.header.my-
header=false,method.request.path.petId=true,method.request.querystring.query=false

Configurar modelos de respuesta de método

Un modelo de respuesta de método define un formato del cuerpo de la respuesta del método. Antes
de configurar el modelo de respuesta, primero debe crear el modelo en API Gateway. Para ello,
puede llamar al comando create-model. El siguiente ejemplo muestra cómo crear un modelo
PetStorePet para describir el cuerpo de la respuesta para la solicitud de método GET /pets/
{petId}.

aws apigateway create-model \

--region us-west-2 \
--rest-api-id vaz7da96z6 \
--content-type application/json \
--name PetStorePet \
--schema '{ \
"$schema": "http://json-schema.org/draft-04/schema#", \
"title": "PetStorePet", \
"type": "object", \
"properties": { \
"id": { "type": "number" }, \

Crear y configurar 286

Amazon API Gateway Guía para desarrolladores

"type": { "type": "string" }, \

"price": { "type": "number" } \
} \
}'

El resultado se crea como un recurso Model de API Gateway.

Para configurar los modelos de respuesta de método para definir el formato de la carga, agregue
el par de clave-valor "application/json":"PetStorePet" al mapa requestModels del recurso
MethodResponse. El siguiente comando de la AWS CLI de put-method-response muestra
cómo se realiza:

aws apigateway put-method-response \

--region us-west-2 \
--rest-api-id vaz7da96z6 \
--resource-id 6sxz2j \
--http-method GET \
--status-code 200 \
--response-parameters method.request.header.my-
header=false,method.request.path.petId=true,method.request.querystring.query=false \
--response-models '{"application/json":"PetStorePet"}'

Es necesario configurar un modelo de respuesta de método al generar un SDK con establecimiento

inflexible de tipos para la API. Garantiza que el resultado se emite en una clase apropiada en Java u
Objective-C. En otros casos, la configuración de un modelo es opcional.

Configuración de un método con la consola de API Gateway

Antes de configurar un método de API, verifique lo siguiente:

• El método debe estar disponible en API Gateway. Siga las instrucciones en Tutorial: Desarrollo de
una API de REST con integración HTTP no de proxy.
• Si desea que el método se comunique con una función de Lambda, debe haber creado ya el rol
de invocación de Lambda y el rol de ejecución de Lambda en IAM. También debe haber creado la
función de Lambda con la que el método se comunicará en AWS Lambda. Para crear los roles y
la función, utilice las instrucciones de Creación de una función de Lambda para la integración de
Lambda no de proxy de Desarrollo de una API de REST de API Gateway con integración Lambda.
• Si desea que el método se comunique con una integración HTTP o de proxy HTTP, debe haber
creado y tener acceso a la URL del punto de enlace HTTP con la que se comunicará el método.

Crear y configurar 287

Amazon API Gateway Guía para desarrolladores

• Compruebe que API Gateway admite los certificados de los puntos de enlace HTTP y proxy de
HTTP. Para obtener más información, consulte Entidades de certificación compatibles con API
Gateway para las integraciones HTTP y Proxy HTTP.

Temas
• Configurar una solicitud de método de API Gateway en la consola de API Gateway
• Configurar una respuesta de método de API Gateway en la consola de API Gateway

Configurar una solicitud de método de API Gateway en la consola de API Gateway

Para utilizar la consola de API Gateway para especificar una solicitud o respuesta del método de una
API y para configurar la forma en que el método autorizará las solicitudes, siga estas instrucciones.

Note
Estas instrucciones presuponen que ya ha completado los pasos que se detallan en
Configuración de una solicitud de integración de la API mediante la consola de API Gateway.
El mejor modo de utilizarlas es para complementar las conversaciones que se indican en
Desarrollo de una API de REST de API Gateway con integración Lambda.

1. Con el método seleccionado en el panel Recursos, elija la pestaña Solicitud de método.

2. En la sección Configuración de solicitud de método, elija Editar.
3. En Autorización, seleccione un autorizador disponible.

a. Para habilitar el acceso abierto al método a cualquier usuario, elija Ninguno. Este paso se
puede omitir si el ajuste predeterminado no se ha cambiado.
b. Para utilizar permisos de IAM para controlar el acceso de clientes al método, seleccione
AWS_IAM. Con esta opción, solo los usuarios de los roles de IAM con la política correcta de
IAM asociada pueden llamar a este método.

Para crear el rol de IAM, especifique una política de acceso con un formato como el
siguiente:

{
"Version": "2012-10-17",
"Statement": [

Crear y configurar 288

Amazon API Gateway Guía para desarrolladores

{
"Effect": "Allow",
"Action": [
"execute-api:Invoke"
],
"Resource": [
"resource-statement"
]
}
]
}

En esta política de acceso, resource-statement es el valor del campo ARN en

la sección Authorization Settings (Configuración de autorización). Para obtener más
información acerca de cómo establecer los permisos de IAM, consulte Control del acceso a
una API con permisos de IAM.

Para crear el rol de IAM, puede adaptar las instrucciones en “To create the Lambda
invocation role and its policy” (Para crear el rol de invocación de Lambda y su política) y “To
create the Lambda execution role and its policy” (Para crear el rol de ejecución de Lambda
y su política) de la sección Create Lambda Functions (Crear funciones de Lambda) de
Desarrollo de una API de REST de API Gateway con integración Lambda.

c. Para usar un autorizador de Lambda, seleccione un token o un autorizador de solicitudes.

Cree un autorizador de Lambda para que esta opción se muestre en el menú desplegable.
Para obtener más información sobre cómo crear un autorizador de Lambda, consulte Uso
de autorizadores Lambda de API Gateway.

d. Para utilizar un grupo de usuarios de Amazon Cognito, elija un grupo de usuarios disponible
en Cognito user pool authorizers (Autorizadores de grupos de usuarios de Cognito). Cree
un grupo de usuarios en Amazon Cognito y un autorizador de grupo de usuarios de Amazon
Cognito en API Gateway para que esta opción se muestre en el menú desplegable. Para
obtener información sobre cómo crear un autorizador de grupo de usuarios de Amazon
Cognito, consulte Control del acceso a una API de REST con grupos de usuarios de
Amazon Cognito como autorizador.

4. Para especificar la validación de la solicitud, seleccione un valor en el menú desplegable

Validador de solicitudes. Para desactivar la validación de solicitudes, seleccione Ninguna. Para
obtener más información acerca de cada opción, consulte Uso de la validación de solicitudes en
API Gateway.

Crear y configurar 289

Amazon API Gateway Guía para desarrolladores

5. Seleccione Clave de API obligatoria para que se requiera una clave de API. Cuando se habilita,
las claves de API se utilizan en planes de uso para limitar el tráfico del cliente.
6. De forma opcional, para asignar un nombre de operación en un SDK de Java de esta API,
generado por API Gateway, ingrese un nombre en Nombre de operación. Por ejemplo, para
la solicitud de método de GET /pets/{petId}, el nombre de operación de SDK de Java
correspondiente es por defecto GetPetsPetId. Este nombre se crea a partir del verbo
HTTP del método (GET) y los nombres de variables de la ruta de recursos (Pets y PetId). Si
establece el nombre de operación como getPetById, el nombre de operación de SDK pasa a
ser GetPetById.

7. Para añadir un parámetro de cadena de consulta al método, haga lo siguiente:

a. Elija Parámetros de cadenas de consulta de URL y, a continuación, elija Agregar cadena de

consulta.

b. En Nombre, escriba el nombre del parámetro de cadena de consulta.

c. Seleccione Obligatorio si el parámetro de cadena de consulta recién creado debe utilizarse

para la validación de solicitudes. Para obtener más información sobre la validación de
solicitud, consulte Uso de la validación de solicitudes en API Gateway.

d. Seleccione Almacenamiento en caché si el parámetro de cadena de consulta recién creado

va a utilizarse como parte de una clave de almacenamiento en caché. Para obtener más
información acerca del almacenamiento en caché, consulte Usar parámetros de método o
integración como claves de caché para indexar las respuestas almacenadas en caché.

Para eliminar el parámetro de cadena de consulta, seleccione Eliminar.

8. Para añadir un parámetro de encabezado al método, haga lo siguiente:

a. Elija Encabezados de solicitud HTTP y, a continuación, elija Agregar encabezado.

b. En Nombre, ingrese el nombre del encabezado.

c. Seleccione Obligatorio si el encabezado recién creado debe utilizarse para la validación de

solicitudes. Para obtener más información sobre la validación de solicitud, consulte Uso de
la validación de solicitudes en API Gateway.

d. Seleccione Almacenamiento en caché si el encabezado recién creado va a utilizarse como

parte de una clave de almacenamiento en caché. Para obtener más información acerca del
almacenamiento en caché, consulte Usar parámetros de método o integración como claves
de caché para indexar las respuestas almacenadas en caché.

Crear y configurar 290

Amazon API Gateway Guía para desarrolladores

Para eliminar el encabezado, elija Eliminar.

9. Para declarar el formato de carga de una solicitud de método con el verbo HTTP POST, PUT o
PATCH, elija Cuerpo de la solicitud y realice lo siguiente:

a. Elija Add model (Añadir modelo).

b. En Content-type, escriba un tipo de MIME (por ejemplo, application/json).
c. En Modelo, seleccione un modelo en el menú desplegable. Los modelos disponibles
actualmente para la API incluyen los modelos predeterminados Empty y Error, así como
cualquier modelo que haya creado y agregado a la colección Models de la API. Para
obtener más información acerca de la creación de un modelo, consulte Comprensión de los
modelos de datos.

Note
El modelo es útil para informar al cliente del formato de datos esperado de una
carga. Resulta útil para generar una plantilla de asignación de esqueleto. Es
importante para generar un SDK con establecimiento inflexible de tipos de la API
en idiomas como Java, C #, Objective-C y Swift. Solo es necesario si se habilita la
validación de solicitudes frente a la carga.

10. Seleccione Guardar.

Configurar una respuesta de método de API Gateway en la consola de API Gateway

Un método de API puede tener una o más respuestas. Cada respuesta se indexa mediante su código
de estado HTTP. De forma predeterminada, la consola de API Gateway agrega la respuesta 200 a
las respuestas de método. Puede modificarla, por ejemplo, para que el método devuelva 201 en su
lugar. Puede añadir otras respuestas, por ejemplo, 409 para la denegación de acceso y 500 para las
variables de etapa sin inicializar utilizadas.

Para utilizar la consola de API Gateway para modificar, eliminar o agregar una respuesta a un
método de API, siga estas instrucciones.

1. Con el método seleccionado en el panel Recursos, elija la pestaña Respuesta de método.

Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
2. En la sección Configuración de respuesta del método, elija Crear respuesta.

Crear y configurar 291