# 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. Para comenzar, le recomendamos que complete [Tutorial: Creación de una API de REST con una integración de proxy de Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).
**Tutoriales sobre API REST**
+ [Elección de un tutorial de integración de AWS Lambda](getting-started-with-lambda-integration.md)
+ [Tutorial: Crear una API de REST importando un ejemplo](api-gateway-create-api-from-example.md)
+ [Elección de un tutorial de integración de HTTP](getting-started-http-integrations.md)
+ [Tutorial: Creación de una API de REST con una integración privada](getting-started-with-private-integration.md)
+ [Tutorial: Creación de una API de REST con una integración de AWS](getting-started-aws-proxy.md)
+ [Tutorial: Creación de una API de REST de calculadora con dos integraciones de servicios de AWS y una integración de Lambda sin proxy](integrating-api-with-aws-services-lambda.md)
+ [Tutorial: Creación de una API de REST como proxy de Amazon S3](integrating-api-with-aws-services-s3.md)
+ [Tutorial: Creación de una API de REST como proxy de Amazon Kinesis](integrating-api-with-aws-services-kinesis.md)
+ [Tutorial: Creación de una API de REST mediante SDK de AWS o la AWS CLI](api-gateway-create-api-cli-sdk.md)
+ [Tutorial: Creación de una API de REST privada](private-api-tutorial.md)
**Tutoriales sobre API HTTP**
+ [Tutorial: Creación de una API de HTTP CRUD con Lambda y DynamoDB](http-api-dynamo-db.md)
+ [Tutorial: Creación de una API de HTTP con una integración privada en un servicio de Amazon ECS](http-api-private-integration.md)
**Tutoriales de la API de WebSocket**
+ [Tutorial: Creación de una aplicación de chat de WebSocket con una API de WebSocket, Lambda y DynamoDB](websocket-api-chat-app.md)
**Talleres**
+ [Desarrollar una aplicación web sin servidor ](https://webapp.serverlessworkshops.io)
+ [CI/CD para aplicaciones sin servidor](https://cicd.serverlessworkshops.io)
+ [Taller sobre seguridad sin servidor](https://github.com/aws-samples/aws-serverless-security-workshop)
+ [Administración, autenticación y autorización de identidades sin servidor](https://auth.serverlessworkshops.io)
+ [Taller sobre Amazon API Gateway](https://catalog.workshops.aws/apigateway/en-US)
# 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.
**Topics**
+ [Elección de un tutorial de integración de AWS Lambda](getting-started-with-lambda-integration.md)
+ [Tutorial: Crear una API de REST importando un ejemplo](api-gateway-create-api-from-example.md)
+ [Elección de un tutorial de integración de HTTP](getting-started-http-integrations.md)
+ [Tutorial: Creación de una API de REST con una integración privada](getting-started-with-private-integration.md)
+ [Tutorial: Creación de una API de REST con una integración de AWS](getting-started-aws-proxy.md)
+ [Tutorial: Creación de una API de REST de calculadora con dos integraciones de servicios de AWS y una integración de Lambda sin proxy](integrating-api-with-aws-services-lambda.md)
+ [Tutorial: Creación de una API de REST como proxy de Amazon S3](integrating-api-with-aws-services-s3.md)
+ [Tutorial: Creación de una API de REST como proxy de Amazon Kinesis](integrating-api-with-aws-services-kinesis.md)
+ [Tutorial: Creación de una API de REST mediante SDK de AWS o la AWS CLI](api-gateway-create-api-cli-sdk.md)
+ [Tutorial: Creación de una API de REST privada](private-api-tutorial.md)
# Elección de un tutorial de integración de AWS 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.
En la integración de proxy de Lambda, la entrada para la función de Lambda se puede expresar como cualquier combinación de encabezados de solicitud, variables de ruta, parámetros de cadena de consulta, cuerpo y datos de configuración de API. Solo tiene que elegir una función de Lambda. API Gateway configura la solicitud de integración y la respuesta de integración por usted. Una vez configurado, el método de la API puede evolucionar sin modificar la configuración existente. Esto es posible porque la función de Lambda del backend analiza los datos de la solicitud entrante y responde al cliente.
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. 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.
En una integración de proxy de Lambda o sin proxy de Lambda, puede usar una función de Lambda en una cuenta diferente de la cuenta en la que creó la API.
**Topics**
+ [Tutorial: Creación de una API de REST con una integración de proxy de Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md)
+ [Tutorial: Creación de una API de REST con una integración no de proxy de Lambda](getting-started-lambda-non-proxy-integration.md)
+ [Tutorial: Creación de una API de REST con integración de proxy de Lambda entre cuentas](apigateway-cross-account-lambda-integrations.md)
# Tutorial: Creación de una API de REST con una integración de proxy de Lambda
La [integración de proxy de Lambda](set-up-lambda-proxy-integrations.md) 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](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). 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\$1 Función de Lambda para que sea el backend de la API.
+ Creación y prueba de una función "Hello, World\$1" API con integración de proxy de Lambda.
**Topics**
+ [Creación de una función Hello, World\$1 Función de Lambda](#api-gateway-proxy-integration-create-lambda-backend)
+ [Creación de una función Hello, World\$1 API](#api-gateway-create-api-as-simple-proxy-for-lambda-build)
+ [Implementación y pruebas de API](#api-gateway-create-api-as-simple-proxy-for-lambda-test)
## Creación de una función Hello, World\$1 Función de Lambda
**Para crear un "Hello, World\$1" 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/](https://console.aws.amazon.com/lambda).
1. En la barra de navegación de AWS, elija una [Región de AWS](https://docs.aws.amazon.com/general/latest/gr/apigateway.html).
**nota**
Anote la región en la que ha creado la función de Lambda. La necesitará al crear la API.
1. Elija **Functions (Funciones)** en el panel de navegación.
1. Elija **Create function (Crear función)**.
1. Elija **Crear desde cero**.
1. Bajo **Basic information (Información básica)**, haga lo siguiente:
1. Bajo **Function name (Nombre de función)**, escriba **GetStartedLambdaProxyIntegration**.
1. En **Tiempo de ejecución**, elija el último tiempo de ejecución de **Node.js** o **Python** compatible.
1. Para **Arquitectura**, mantenga la configuración predeterminada.
1. 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**.
1. En **Role name (Nombre del rol)**, escriba **GetStartedLambdaBasicExecutionRole**.
1. Deje el campo **Policy templates** (Plantillas de política) en blanco.
1. Elija **Create function (Crear función)**.
1. 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 = async(event, context) => {
console.log('Received event:', JSON.stringify(event, null, 2));
var res ={
"statusCode": 200,
"headers": {
"Content-Type": "*/*"
}
};
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 + "!";
return 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'] is not None):
greeter = event['queryStringParameters']['greeter']
except KeyError:
print('No greeter')
try:
if (event['multiValueHeaders']) and (event['multiValueHeaders']['greeter']) and (
event['multiValueHeaders']['greeter'] is not None):
greeter = " and ".join(event['multiValueHeaders']['greeter'])
except KeyError:
print('No greeter')
try:
if (event['headers']) and (event['headers']['greeter']) and (
event['headers']['greeter'] is not None):
greeter = event['headers']['greeter']
except KeyError:
print('No greeter')
if (event['body']) and (event['body'] is not None):
body = json.loads(event['body'])
try:
if (body['greeter']) and (body['greeter'] is not None):
greeter = body['greeter']
except KeyError:
print('No greeter')
res = {
"statusCode": 200,
"headers": {
"Content-Type": "*/*"
},
"body": "Hello, " + greeter + "!"
}
return res
```
------
1. Elija **Deploy (Implementar)**.
## Creación de una función Hello, World\$1 API
Ahora cree una API para la función de Lamba "Hello, World\$1" La función de Lambda utilizando la consola de API Gateway.
**Para crear un "Hello, World\$1" API**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. 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)**.
1. En **API name (Nombre de la API)**, escriba**LambdaProxyAPI**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Mantenga **Tipo de punto de conexión de la API** establecido en **Regional**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Seleccione **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. Elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. Mantenga **Ruta del recurso** en `/`.
1. En **Nombre del recurso**, escriba **helloworld**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. 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**.
1. En **Tipo de método**, seleccione **CUALQUIERA**.
1. En **Tipo de integración**, seleccione **Función de Lambda**.
1. Active **Integración de proxy de Lambda**.
1. 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.
1. 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.
1. Elija **Crear método**.
## Implementación y pruebas de API
**Para implementar su API**
1. Elija **Implementar API**.
1. En **Etapa**, seleccione **Nueva etapa**.
1. En **Stage name (Nombre de etapa)**, escriba **test**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Elija **Implementar**.
1. 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](https://curl.se/) para probar la API.
Para probar solicitudes `GET` mediante solo los parámetros de cadena de consulta, puede ingresar la URL para el recurso `helloworld` de la API en la barra de direcciones del navegador.
Para crear la URL del recurso `helloworld` de la API, agregue el recurso `helloworld` y el parámetro de cadena de consulta `?greeter=John` a la URL de invocación. La URL debería tener el siguiente aspecto.
```
https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John
```
Para otros métodos, debe utilizar utilidades de prueba de la API de REST más avanzadas, tales como [POSTMAN](https://www.postman.com/) o [cURL](https://curl.se/). 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.
1. 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.
**nota**
Si está ejecutando el comando en Windows, utilice esta sintaxis:
```
curl -v -X POST "https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld" -H "content-type: application/json" -d "{ \"greeter\": \"John\" }"
```
1. 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'
```
1. 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'
```
1. 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: Creación de una API de REST con una 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](https://docs.aws.amazon.com/lambda/latest/dg/).
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 de REST de calculadora con dos integraciones de servicios de AWS y una integración de Lambda sin proxy](integrating-api-with-aws-services-lambda.md).
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.
**Topics**
+ [Creación de una función de Lambda para la integración de Lambda no de proxy](#getting-started-new-lambda)
+ [Creación de una API con la integración de Lambda no de proxy](#getting-started-new-api)
+ [Prueba que invoca el método de API](#getting-started-new-get)
+ [Implementar la API](#getting-started-deploy-api)
+ [Pruebe la API en una etapa de implementación](#getting-started-test)
+ [Eliminar recursos](#getting-started-clean-up)
## Creación de una función de Lambda para la integración de Lambda no de proxy
**nota**
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\$1" 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'];
export const handler = async(event) => {
console.log(event);
// Parse the input for the name, city, time and day property values
let name = event.name === null || event.name === undefined || event.name === "" ? '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
return {"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
name = event.get("name") or 'you'
city = event.get("city") or 'World'
try:
if event['time'] in times:
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](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html).
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](https://github.com/aws-samples/api-gateway-secure-pet-store/blob/master/src/main/resources/swagger.yaml#L39)), 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 de REST con permisos de IAM](permissions.md).
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/](https://console.aws.amazon.com/lambda/).
1. Realice una 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)**.
1. Elija **Author from scratch**.
1. En el panel **Author from scratch (Crear desde cero)**, haga lo siguiente:
1. En **Name (Nombre)**, escriba **GetStartedLambdaIntegration** como nombre de la función de Lambda.
1. En **Tiempo de ejecución**, elija el último tiempo de ejecución de **Node.js** o **Python** compatible.
1. Para **Arquitectura**, mantenga la configuración predeterminada.
1. 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**.
1. En **Role name (Nombre de la función)**, escriba un nombre para la función (por ejemplo, **GetStartedLambdaIntegrationRole**).
1. En **Policy templates (Plantillas de política)**, elija **Simple microservice permissions (Permisos para microservicios sencillos)**.
1. Elija **Create function (Crear función)**.
1. En el panel **Configure function (Configurar función)**, en **Function code (Código de función)**, configure los campos siguientes:
1. 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.
1. Deje las opciones predeterminadas para todos los demás campos en esta sección.
1. Elija **Deploy (Implementar)**.
1. Para probar la función recién creada, seleccione la pestaña **Probar**.
1. En **Nombre del evento**, escriba **HelloWorldTest**.
1. En **JSON de evento**, sustituya el código predeterminado por lo siguiente.
```
{
"name": "Jonny",
"city": "Seattle",
"time": "morning",
"day": "Wednesday"
}
```
1. 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.
```
{
"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 `GetStartedLambdaIntegration`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "logs:CreateLogGroup",
"Resource": "arn:aws:logs:us-east-1:111111111111:*"
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": [
"arn:aws:logs:us-east-1:111111111111: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:
------
#### [ JSON ]
****
```
{
"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.
## 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](https://console.aws.amazon.com/apigateway).
1. 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)**.
1. En **API name (Nombre de la API)**, escriba**LambdaNonProxyAPI**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Mantenga **Tipo de punto de conexión de la API** establecido en **Regional**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Seleccione **Crear API**.
Tras crear su API, cree un recurso **/\$1city\$1**. 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**.
1. Mantenga **Recurso proxy** desactivado.
1. Mantenga **Ruta del recurso** en `/`.
1. En **Nombre del recurso**, escriba **\$1city\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
Tras crear su recurso **/\$1city\$1**, 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 **/\$1city\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **CUALQUIERA**.
1. En **Tipo de integración**, seleccione **Función de Lambda**.
1. Mantenga desactivada la **Integración de proxy Lambda**.
1. 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.
1. Elija **Configuración de solicitud de método**.
Ahora, active un validador de la solicitud para una variable de ruta de la URL, un parámetro de cadena de consulta y un encabezado para garantizar que se hayan definido todos los datos necesarios. Para este ejemplo, se crea un parámetro de cadena de consulta `time` y un encabezado `day`.
1. En **Validador de solicitud**, seleccione **Validar parámetros de cadena de consulta y encabezados**.
1. Elija **Parámetros de cadenas de consulta de URL** y haga lo siguiente:
1. Elija **Añadir cadena de consulta**.
1. En **Nombre**, escriba **time**.
1. Active la opción **Obligatorio**.
1. Mantenga **Almacenamiento en caché** desactivado.
1. Elija **Encabezados de solicitudes HTTP** y haga lo siguiente:
1. Elija **Agregar encabezado**.
1. En **Nombre**, escriba **day**.
1. Active la opción **Obligatorio**.
1. Mantenga **Almacenamiento en caché** desactivado.
1. Elija **Crear método**.
Tras activar un validador de solicitudes, se configura la solicitud de integración para el método `ANY`añ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 pestaña **Solicitud de integración**, en **Configuración de solicitud de integración**, elija **Editar**.
1. En **Acceso directo de cuerpo de la solicitud**, elija **Cuando no haya plantillas definidas (recomendado)**.
1. Elija **Plantillas de mapeo**.
1. Elija **Add mapping template (Añadir plantilla de asignación)**.
1. En **Tipo de contenido**, ingrese **application/json**.
1. 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"
}
```
1. Seleccione **Save**.
## 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.
1. En **Tipo de método**, seleccione `POST`.
1. En **Ruta**, debajo de **ciudad**, introduzca **Seattle**.
1. En **Cadenas de consulta**, escriba **time=morning**.
1. En **Encabezados**, escriba **day:Wednesday**.
1. En **Cuerpo de la solicitud**, introduzca **\$1 "callerName": "John" \$1**.
1. 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=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, 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",
"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 **Implementar API**.
1. En **Etapa**, seleccione **Nueva etapa**.
1. En **Stage name (Nombre de etapa)**, escriba **test**.
**nota**
La entrada debe tener texto cifrado UTF-8 (es decir, no localizado).
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. 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](https://www.postman.com/) o [cURL](https://curl.se/).
**Para probar la API mediante cURL**
1. Abra una ventana de la terminal en su equipo local conectado a Internet.
1. 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:
```
{"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.
**aviso**
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 la función de Lambda**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de AWS Lambda en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. En la lista de funciones, elija **GetStartedLambdaIntegration**, **Acciones** y, a continuación, **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/](https://console.aws.amazon.com/iam/).
1. En **Details (Detalles)**, elija **Roles (Roles)**.
1. De entre la lista de roles, seleccione **GetStartedLambdaIntegrationRole**, elija **Acciones del rol** y, a continuación, **Eliminar rol**. Siga los pasos en la consola para eliminar el rol.
# Tutorial: Creación de una API de REST 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.
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](https://console.aws.amazon.com/apigateway).
1. 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)**.
1. En **API name (Nombre de la API)**, escriba**CrossAccountLambdaAPI**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Mantenga **Tipo de punto de conexión de la API** establecido en **Regional**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Seleccione **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.
1. Elija **Create function (Crear función)**.
1. Elija **Author from scratch**.
1. En **Author from scratch (Crear desde cero)**, haga lo siguiente:
1. En **Function name (Nombre de función)**, escriba un nombre.
1. En la lista desplegable **Runtime (Tiempo de ejecución)**, elija un tiempo de ejecución de Node.js compatible.
1. Para **Arquitectura**, mantenga la configuración predeterminada.
1. 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.
1. Elija **Create function (Crear función)** para continuar.
1. Desplácese hacia abajo en el panel **Function code (Código de la función)**.
1. Introduzca la implementación de la función de Node.js desde [Tutorial: Creación de una API de REST con una integración de proxy de Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).
1. Elija **Deploy (Implementar)**.
1. 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.
**nota**
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. Elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. Mantenga **Ruta del recurso** en `/`.
1. En **Nombre del recurso**, escriba **helloworld**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. 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.
**Para crear un método `GET`**
1. Seleccione el recurso **/helloworld** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Función de Lambda**.
1. Active **Integración de proxy de Lambda**.
1. 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.
1. 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.
1. 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 la Consola de administración de AWS y abra la consola AWS Lambda en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Elija su función de Lambda.
1. 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: 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`.
**nota**
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 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](https://console.aws.amazon.com/apigateway).
1. 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**.
1. En **Crear API de REST**, elija **API de ejemplo** y, a continuación, elija **Crear API** para crear la API de ejemplo.
![\[API de REST de ejemplo en la consola de API Gateway.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-new-console.png)
Puede desplazarse por la definición de OpenAPI para obtener información detallada sobre esta API de ejemplo antes de elegir **Crear API**.
1. En el panel de navegación principal, elija **Recursos**. La API recién creada se muestra de la siguiente forma:
![\[La API de ejemplo después de importarla a la consola de API Gateway.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-result-new-console.png)
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.
1. 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:
![\[El método POST /pets para la API de ejemplo en la consola de API Gateway.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-execution-new-console.png)
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.
1. Seleccione la pestaña **Pruebas**. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
1. Por ejemplo, para probar el método `POST /pets`, escriba la siguiente carga **\$1"type": "dog","price": 249.99\$1** en el **Cuerpo de la solicitud** antes de elegir el botón **Pruebas**.
![\[Pruebe el método POST en la consola de API Gateway.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-test-new-console.png)
La entrada especifica los atributos de la mascota que deseamos añadir a la lista de mascotas en el sitio web PetStore.
1. El resultado es el siguiente:
![\[El resultado de la prueba del método POST en la consola de API Gateway.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-post-method-test-result-new-console.png)
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.
1. Elija **Implementar API** para implementar la API de ejemplo.
![\[Utilice el botón de implementación para implementar la API, así los intermediarios de la API pueden invocar la API.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-create-api-by-importing-example-deploy-api-new-console.png)
1. En **Etapa**, seleccione **Nueva etapa** y, a continuación, ingrese **test**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Elija **Implementar**.
1. 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.
![\[Después de crear la API de REST, la consola muestra la URL de invocación de la API.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/getting-started-rest-invoke-url.png)
1. 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.
1. 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 `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](https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html) (SigV4) o [Signature Version 4a](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_sigv.html#how-sigv4a-works) (SigV4a). Para ver un ejemplo de una solicitud de este tipo, consulte [Tutorial: Creación de una API de REST con integración no de proxy HTTP](api-gateway-create-api-step-by-step.md).
# Elección de un tutorial de integración de HTTP
Para desarrollar una API con integración HTTP, puede utilizar una integración de proxy HTTP o una integración HTTP personalizada.
En una integración de proxy HTTP, solo tiene que establecer el método HTTP y el URI del punto de conexión HTTP, según los requisitos de backend. Le recomendamos utilizar integración de proxy HTTP cada vez que sea posible, para aprovechar la configuración de API simplificada.
Es posible que quiera usar una integración HTTP personalizada si necesita transformar los datos de la solicitud del cliente para el backend o transformar los datos de respuesta del backend para el cliente.
**Topics**
+ [Tutorial: Creación de una API de REST con integración de proxy HTTP](api-gateway-create-api-as-simple-proxy-for-http.md)
+ [Tutorial: Creación de una API de REST con integración no de proxy HTTP](api-gateway-create-api-step-by-step.md)
# Tutorial: Creación 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 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 [Notas importantes de Amazon API Gateway](api-gateway-known-issues.md).
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`.
**Topics**
+ [Creación de una API con integración de proxy HTTP con la consola de API Gateway](#api-gateway-create-api-as-simple-proxy-for-http-build)
+ [Probar una API con la integración de proxy HTTP](#api-gateway-create-api-as-simple-proxy-for-http-test)
## 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: Creación de una API de REST con integración no de proxy HTTP](api-gateway-create-api-step-by-step.md), 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.
**Creación de una API**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. 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)**.
1. En **API name (Nombre de la API)**, escriba**HTTPProxyAPI**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Mantenga **Tipo de punto de conexión de la API** establecido en **Regional**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Seleccione **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 **/\$1proxy\$1\$1****
1. Elija la API.
1. En el panel de navegación principal, elija **Recursos**.
1. Elija **Crear recurso**.
1. Active **Recurso proxy**.
1. Mantenga **Ruta del recurso** en `/`.
1. En **Nombre del recurso**, escriba **\$1proxy\$1\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
![\[Crear un recurso secundario.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-simple-proxy-create-proxy-resource-new-console.png)
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 **/\$1proxy\$1\$1**.
1. Elija el método **ANY**.
1. Bajo el símbolo de advertencia, seleccione **Editar integración**. No puede implementar una API que tenga un método sin una integración.
1. En **Tipo de integración**, seleccione **HTTP**.
1. Active **Integración de proxy HTTP**.
1. En **Método HTTP**, seleccione **ANY**.
1. En **URL del punto de conexión**, introduzca **http://petstore-demo-endpoint.execute-api.com/\$1proxy\$1**.
1. Seleccione **Save**.
## 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.
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.
1. En **Tipo de método**, seleccione `GET`.
1. En **Ruta**, debajo de **proxy**, introduzca **petstore/pets**.
1. En **Cadenas de consulta**, escriba **type=fish**.
1. Seleccione **Probar**.
![\[Utilice la característica de prueba para probar un método.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-simple-proxy-petstore-call-proxy-resource-new-console.png)
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
}
]
```
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 **Implementar API**.
1. En **Etapa**, seleccione **Nueva etapa**.
1. En **Stage name (Nombre de etapa)**, escriba **test**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. 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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. En el panel de navegación principal, elija **Etapa**.
1. 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.
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.
1. El resultado debe ser el mismo que el que se devuelve cuando utiliza **Prueba** desde la consola de API Gateway.
# Tutorial: Creación de una API de REST con integración no de proxy HTTP
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.
**Topics**
+ [Crear una API con integración de HTTP personalizada](#api-gateway-create-resource-and-methods)
+ [(Opcional) Parámetros de la solicitud de mapeo](#api-gateway-create-resources-and-methods-next-steps)
## 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.
**Creación de una API**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. 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)**.
1. En **API name (Nombre de la API)**, escriba**HTTPNonProxyAPI**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Mantenga **Tipo de punto de conexión de la API** establecido en **Regional**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Seleccione **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. Elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. Mantenga **Ruta del recurso** en `/`.
1. En **Nombre del recurso**, escriba **pets**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. 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.
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**.
1. Elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Integración HTTP**.
1. Mantenga desactivada **Integración de proxy HTTP**.
1. En **Método HTTP**, seleccione **GET**.
1. En **URL del punto de conexión**, introduzca **http://petstore-demo-endpoint.execute-api.com/petstore/pets**.
El sitio web de PetStore le permite recuperar una lista de elementos `Pet` por tipo de mascota, por ejemplo, "Perro" o "Gato", en una determinada página.
1. En **Tratamiento de contenido**, seleccione **Acceso directo**.
1. Elija **Parámetros de cadenas de consulta de URL**.
El sitio web de PetStore utiliza los parámetros de cadena de consulta `type` y `page` para aceptar una entrada. Se agregan los parámetros de cadena de consulta a la solicitud del método y se asignan a los parámetros de cadena de consulta correspondientes de la solicitud de integración.
1. Para agregar parámetros de cadena de consulta, haga lo siguiente:
1. Elija **Añadir cadena de consulta**.
1. En **Nombre**, introduzca **type**.
1. Mantenga desactivados **Obligatorio** y **Almacenamiento en caché**.
Repita los pasos anteriores para crear una cadena de consulta adicional con el nombre **page**.
1. Elija **Crear método**.
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. En la pestaña **Solicitud de integración**, en **Configuración de la solicitud de integración**, seleccione **Editar**.
1. Elija **Parámetros de cadenas de consulta de URL** y luego haga lo siguiente:
1. Seleccione **Añadir parámetro de cadena de consulta**.
1. En **Nombre**, escriba **type**.
1. En **Mapeado de**, introduzca **method.request.querystring.type**.
1. Mantenga **Almacenamiento en caché** desactivado.
1. Seleccione **Añadir parámetro de cadena de consulta**.
1. En **Nombre**, escriba **page**.
1. En **Mapeado de**, introduzca **method.request.querystring.page**.
1. Mantenga **Almacenamiento en caché** desactivado.
1. Seleccione **Save**.
**Para probar el API**
1. Elija la pestaña **Prueba**. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
1. En **Cadenas de consulta**, escriba **type=Dog&page=2**.
1. Seleccione **Probar**.
El resultado es similar al siguiente:
![\[Resultado del método Test-invoke GET en pets\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-create-api-step-by-step-test-invoke-get-on-pets-result-new-console.png)
Ahora que la prueba se ha realizado correctamente, podemos implementar la API para ponerla a disposición del público en general.
1. Elija **Implementar API**.
1. En **Etapa**, seleccione **Nueva etapa**.
1. En **Stage name (Nombre de etapa)**, escriba **Prod**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Elija **Implementar**.
1. (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](https://www.postman.com) y [cURL](https://curl.se/) 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](https://aws.amazon.com/developer/tools/) que desee.
**nota**
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 muestra cómo crear un parámetro de ruta `{petId}` en la solicitud de método de la API para especificar un ID de elemento, asignarlo al parámetro de ruta `{id}` en la URL de la solicitud de integración y enviar la solicitud al punto de conexión HTTP.
**nota**
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 \$1petId\$1.
**Para crear el recurso \$1petID\$1**
1. Seleccione el recurso **/pets** y, a continuación, elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. En **Ruta de recurso**, seleccione **/pets/**.
1. En **Nombre del recurso**, escriba **\$1petId\$1**.
Utilice llaves (`{ }`) alrededor de `petId` para que aparezca **/pets/\$1petId\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. 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 **/\$1petId\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Integración HTTP**.
1. Mantenga desactivada **Integración de proxy HTTP**.
1. En **Método HTTP**, seleccione **GET**.
1. En **URL del punto de conexión**, introduzca **http://petstore-demo-endpoint.execute-api.com/petstore/pets/\$1id\$1**
1. En **Tratamiento de contenido**, seleccione **Acceso directo**.
1. Mantenga activado **Tiempo de espera predeterminado**.
1. Elija **Crear método**.
Ahora, asigne el parámetro de ruta `{petId}` que acaba de crear al parámetro de ruta `{id}` en la URL del punto de conexión HTTP de la solicitud de integración. La URL del punto de conexión HTTP era **http://petstore-demo-endpoint.execute-api.com/petstore/pets/\$1id\$1**.
**Para mapear el parámetro de ruta `{petId}`**
1. En la pestaña **Solicitud de integración**, en **Configuración de la solicitud de integración**, seleccione **Editar**.
1. Elija los **Parámetros de la ruta URL**.
1. API Gateway crea un parámetro de ruta para la solicitud de integración denominado **petId**. Sin embargo, este parámetro de ruta no es válido para la URL del punto de conexión HTTP que ha configurado como integración de backend. El punto de conexión HTTP utiliza `{id}` como parámetro de ruta. En **Nombre**, elimine **petId** y escriba **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`.
1. Seleccione **Save**.
Ahora pruebe el método.
**Para probar el método**
1. Elija la pestaña **Prueba**. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
1. En **Ruta**, en **petId**, introduzca **4**.
1. 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 **Implementar API**.
1. En **Etapa**, seleccione **Prod**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. 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**.
1. 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:
```
https://my-api-id.execute-api.region-id.amazonaws.com/prod
```
1. 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.
1. El navegador devolverá lo siguiente:
```
{
"id": 4,
"type": "bird",
"price": 999.99
}
```
#### Pasos a seguir a continuación
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](api-gateway-request-validation-set-up.md).
+ Para obtener información sobre cómo transformar las cargas de solicitudes y respuestas, consulte [Tutorial: modificación de la solicitud y respuesta de integración para integraciones con servicios de AWS](set-up-data-transformations-in-api-gateway.md).
+ 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](set-up-gateway-response-using-the-console.md).
# Tutorial: Creación de una API de REST con una integración privada
En este tutorial, se crea una API de REST que se conecta a un servicio de 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 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 V2. El vínculo VPC permite a API Gateway acceder al Servicio Amazon ECS que se ejecuta en su Amazon VPC A continuación, se crea una API de REST que utilice el enlace de VPC V2 para conectarse al servicio de Amazon ECS. Por último, se prueba la API.
Al invocar la API de REST, API Gateway envía la solicitud al servicio de Amazon ECS a través del enlace de VPC V2 y, a continuación, devuelve la respuesta del servicio.
**nota**
Anteriormente, este tutorial era compatible con las API HTTP y ahora lo es con las API de REST que utilizan el enlace de VPC V2.
![\[Información general de la API de REST creada en este tutorial.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/private-integration-rest.png)
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 [Configuración para usar API Gateway](setting-up.md).
**Topics**
+ [Paso 1: crear un Servicio Amazon ECS](#rest-api-private-integration-create-ecs-service)
+ [Paso 2: crear un enlace de VPC](#http-api-private-integration-vpc-link)
+ [Paso 3: Crear una API de REST](#http-api-private-integration-create-api)
+ [Paso 4: probar la API](#rest-api-private-integration-test-api)
+ [Paso 5: implemente su API](#rest-api-private-integration-deploy-api)
+ [Paso 6: llamar a la API](#rest-api-private-integration-call)
+ [Paso 7: limpiar](#rest-api-private-integration-cleanup)
## 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 CloudFormation](samples/rest-private-integration-tutorial.zip) 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 CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione **Create stack (Crear pila)** y, a continuación, seleccione **With new resources (standard) (Con nuevos recursos [estándar])**.
1. En **Specify template (Especificar plantilla)**, elija **Upload a template file (Cargar un archivo de plantilla)**.
1. Seleccione la plantilla que ha descargado.
1. Elija **Next (Siguiente)**.
1. En **Stack name (Nombre de pila)**, escriba **rest-api-private-integrations-tutorial** y, a continuación, elija **Next (Siguiente)**.
1. En **Configure stack options (Configurar opciones de pila)**, elija **Next (Siguiente)**.
1. Para **Capabilities** (Capacidades), sepa que CloudFormation puede crear recursos de IAM en su cuenta.
1. Elija **Siguiente** y, a continuación, elija **Enviar**.
CloudFormation aprovisiona al Servicio ECS. Puede tardar unos minutos. Cuando el estado de la pila de CloudFormation sea **CREATE\$1COMPLETE**, 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 de Amazon ECS a través de la API de REST.
**Para crear un enlace de VPC**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. En el panel de navegación principal, elija **Enlaces de VPC** y, a continuación, elija **Crear**.
Es posible que necesite elegir el icono del menú para abrir el panel de navegación principal.
1. En **Elegir una versión de enlace de VPC**, seleccione **Enlace de VPC V2**.
1. En **Name (Nombre)** escriba **private-integrations-tutorial**.
1. En **VPC**, elija la VPC que ha creado en el paso 1. El nombre debe empezar por **RestApiStack**.
1. En **Subnets (Subredes)**, seleccione las dos subredes privadas de la VPC. Los nombres terminan en `PrivateSubnet`.
1. Para **Grupos de seguridad**, seleccione el ID de grupo que comience por `private-integrations-tutorial` y tenga la descripción `RestApiStack/RestApiTutorialService/Service/SecurityGroup`.
1. Seleccione **Crear**.
Después de crear el enlace de VPC V2, 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 de REST
La API de REST proporciona un punto de conexión HTTP para el servicio de Amazon ECS.
**Para crear una API de REST**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Seleccione **Create API (Crear API)**y, a continuación, para **API REST**, seleccione **Build (Construir)**.
1. En **Nombre**, escriba **private-integration-api**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Seleccione **Crear API**.
Después de crear la API, se crea un método.
1. Elija **Crear método** y luego haga lo siguiente:
1. En **Tipo de método**, seleccione `GET`.
1. En **Tipo de integración**, seleccione **Enlace de VPC**.
1. Active **Integración de proxy de VPC**.
1. En **Método HTTP**, seleccione `GET`.
1. Para el **enlace de la VPC**, elija el enlace de VPC V2 que creó en el paso anterior.
1. En **Objetivo de integración**, ingrese el equilibrador de carga que creó con la plantilla de CloudFormation en el paso 1. Su nombre debe empezar por **rest-**.
1. En **URL del punto de conexión**, introduzca `http://private-integrations-tutorial.com`.
La URL se utiliza para definir el encabezado `Host` de la solicitud de integración. En este caso, el encabezado del host es **private-integrations-tutorial**.
1. Elija **Crear método**.
Con la integración del proxy, la API está lista para probarse.
## Paso 4: probar la API
A continuación, se prueba a invocar el método de la API.
**Para probar la API**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Elija la pestaña **Prueba**. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
1. Seleccione **Probar**
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.
## Paso 5: implemente su API
A continuación, debe implementar la API.
**Para implementar su API**
1. Elija **Implementar API**.
1. En **Etapa**, seleccione **Nueva etapa**.
1. En **Stage name (Nombre de etapa)**, escriba **Prod**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Elija **Implementar**.
## Paso 6: llamar a la API
Después de implementar la API, puede llamarla.
**Llamada a la API**
1. Ingrese la URL de invocación en un navegador web.
La URL completa debería ser `https://abcd123.execute-api.us-east-2.amazonaws.com/Prod`.
Su navegador envía una `GET` solicitud a la API.
1. 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 de Amazon ECS que se ejecuta en una Amazon VPC y ha utilizado una API de REST de API Gateway con un enlace de VPC V2 para acceder al servicio de Amazon ECS.
## Paso 7: limpiar
Para evitar costos innecesarios, elimine los recursos creados como parte de este tutorial Los pasos siguientes eliminan el enlace de VPC V2, la pila de CloudFormation y la API de REST.
**Para eliminar una API REST**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. 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](https://console.aws.amazon.com/apigateway).
1. Elija **VPC link (Enlace de VPC)**.
1. Seleccione el enlace de VPC, elija **Delete (Eliminar)**y, a continuación, confirme su elección.
**Para eliminar una pila de CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione su pila de CloudFormation.
1. Elija **Delete (Eliminar)** y, a continuación, confirme su elección.
# Tutorial: Creación de una API de REST con una integración de AWS
Tanto los temas [Tutorial: Creación de una API de REST con una integración de proxy de Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md) como [Tutorial: Creación de una API de REST con una integración no de proxy de Lambda](getting-started-lambda-non-proxy-integration.md) 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](api-gateway-tutorials.md).
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.
API Gateway no vuelve a intentar las operaciones cuando se agota el tiempo de espera del punto de conexión. El intermediario de la API debe implementar una lógica de reintentos para administrar los tiempos de espera del punto de conexión.
Este tutorial se basa en las instrucciones y conceptos en [Tutorial: Creación de una API de REST con una integración no de proxy de Lambda](getting-started-lambda-non-proxy-integration.md). Si aún no ha completado ese tutorial, le sugerimos que lo haga primero.
**Topics**
+ [Requisitos previos](#getting-started-aws-proxy-prerequisites)
+ [Paso 1: Crear el rol de ejecución del proxy de servicio de AWS](#getting-started-aws-proxy-add-roles)
+ [Paso 2: Crear el recurso](#getting-started-aws-proxy-add-resources)
+ [Paso 3: Crear el método GET](#getting-started-aws-proxy-add-methods)
+ [Paso 4: Especificar la configuración del método y probar el método](#getting-started-aws-proxy-set-methods)
+ [Paso 5: Implementar la API](#getting-started-aws-proxy-deploy)
+ [Paso 6: Probar la API](#getting-started-aws-proxy-test)
+ [Paso 7: Limpieza](#getting-started-aws-proxy-clean-up)
## Requisitos previos
Antes de empezar este tutorial, haga lo siguiente:
1. Realice los pasos que se indican en [Configuración para usar API Gateway](setting-up.md).
1. Cree una nueva API llamada `MyDemoAPI`. Para obtener más información, consulte [Tutorial: Creación de una API de REST con integración no de proxy HTTP](api-gateway-create-api-step-by-step.md).
1. Implemente la API al menos una vez en una etapa denominada `test`. Para obtener más información, consulte [Implementar la API](getting-started-lambda-non-proxy-integration.md#getting-started-deploy-api) en [Elección de un tutorial de integración de AWS Lambda](getting-started-with-lambda-integration.md).
1. Realice el resto de los pasos de [Elección de un tutorial de integración de AWS Lambda](getting-started-with-lambda-integration.md).
1. 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](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html). (No es necesario que copie el ARN del tema mencionado en el paso 5).
## 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. En este paso, deberá crear un nuevo rol de IAM.
**Para crear el rol de ejecución del proxy de servicio de AWS**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Roles**.
1. Elija **Creación de rol**.
1. 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**.
1. Seleccione **Siguiente** y de nuevo **Siguiente**.
1. En **Role name (Nombre de rol)**, escriba **APIGatewaySNSProxyPolicy** y luego elija **Create role (Crear rol)**.
1. 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.
1. Para el rol seleccionado, seleccione la pestaña **Agregar permisos**.
1. Elija **Adjuntar políticas** en la lista desplegable.
1. En la barra de búsqueda, escriba **AmazonSNSReadOnlyAccess** y, a continuación, elija **Añadir permisos**.
**nota**
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.
1. 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.
**Para crear el recurso**
1. Inicie sesión en la consola de API Gateway, en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Seleccione el recurso raíz, **/**, representado por una única barra oblicua (**/**), y después elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. Mantenga **Ruta del recurso** en `/`.
1. En **Nombre del recurso**, escriba **mydemoawsproxy**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. 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**.
1. En el tipo de método, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS en la que ha creado el tema de Amazon SNS.
1. En **Servicio de AWS**, seleccione **Amazon SNS**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, seleccione **GET**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **ListTopics**.
1. En **Rol de ejecución**, escriba el ARN del rol para **APIGatewaySNSProxyPolicy**.
1. Elija **Crear método**.
## 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 **Prueba**. Puede que tenga que elegir el botón de flecha hacia la derecha para mostrar la pestaña.
1. Seleccione **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.
**Para implementar la API**
1. Elija **Implementar API**.
1. En **Etapa**, seleccione **Nueva etapa**.
1. En **Stage name (Nombre de etapa)**, escriba **test**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. 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**.
1. 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
```
1. Introduzca la URL en el cuadro de direcciones de una nueva pestaña del navegador.
1. 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.
**aviso**
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/](https://console.aws.amazon.com/iam/).
1. En el área **Details (Detalles)**, elija **Roles (Funciones)**.
1. Seleccione **APIGatewayAWSProxyExecRole** y, a continuación, elija **Role Actions (Acciones de rol)**, **Delete Role (Eliminar rol)**. Cuando se le pregunte, elija **Yes, Delete**.
1. En el área **Details (Detalles)**, elija **Policies (Políticas)**.
1. 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: Creación de una API de REST como proxy de Amazon S3](integrating-api-with-aws-services-s3.md), [Tutorial: Creación de una API de REST de calculadora con dos integraciones de servicios de AWS y una integración de Lambda sin proxy](integrating-api-with-aws-services-lambda.md) o [Tutorial: Creación de una API de REST como proxy de Amazon Kinesis](integrating-api-with-aws-services-kinesis.md).
# Tutorial: Creación de una API de REST de calculadora con dos integraciones de servicios de AWS y una integración de Lambda sin proxy
El [Tutorial: Creación de una API de REST con una integración no de proxy de Lambda](getting-started-lambda-non-proxy-integration.md) 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.
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`)
1. 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`)
1. 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](api-as-lambda-proxy-export-swagger-with-extensions.md) para la API de `Calc`, que puede importar a API Gateway siguiendo las instrucciones de [Desarrollo de API de REST mediante OpenAPI en API Gateway](api-gateway-import-api.md).
**Topics**
+ [Crear un rol de IAM asumible](#api-as-lambda-proxy-setup-iam-role-policies)
+ [Creación de una función `Calc` de Lambda](#api-as-lambda-proxy-create-lambda-function)
+ [Probar la función `Calc` de Lambda](#api-as-lambda-proxy-test-lambda-function-)
+ [Cree una API de `Calc`](#api-as-lambda-proxy-create-api-resources)
+ [Integración 1: Crear un método `GET` con parámetros de consulta para llamar a la función de Lambda](#api-as-lambda-proxy-expose-get-method-with-query-strings-to-call-lambda-function)
+ [Integración 2: Crear un método `POST` con una carga JSON para llamar a la función de Lambda](#api-as-lambda-proxy-expose-post-method-with-json-body-to-call-lambda-function)
+ [Integración 3: Crear un método `GET` con parámetros de ruta para llamar a la función de Lambda](#api-as-lambda-proxy-expose-get-method-with-path-parameters-to-call-lambda-function)
+ [Definiciones de OpenAPI de una API de ejemplo integrada con una función de Lambda](api-as-lambda-proxy-export-swagger-with-extensions.md)
## 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:
------
#### [ JSON ]
****
```
{
"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](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html) 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:
------
#### [ JSON ]
****
```
{
"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.
1. Elija **Roles**.
1. Elija **Create Role**.
1. En **Seleccionar el tipo de entidad de confianza**, elija **Servicio de AWS**.
1. En **Choose the service that will use this role (Elegir el servicio que usará este rol)**, elija **Lambda**.
1. Elija **Next: Permissions** (Siguiente: permisos).
1. Elija **Create Policy (Crear política)**.
Se abrirá una nueva ventana de consola **Create Policy (Crear política)**. En esa ventana, haga lo siguiente:
1. En la pestaña **JSON**, reemplace la política existente por la siguiente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}
```
------
1. Elija **Review policy (Revisar política)**.
1. En **Review Policy (Revisar política)** haga lo siguiente:
1. En **Nombre**, escriba un nombre, como **lambda\$1execute**.
1. Elija **Create Policy (Crear política)**.
1. En la ventana de consola **Create Role (Crear rol)** original, haga lo siguiente:
1. En **Attach permissions policies (Asociar políticas de permisos)**, elija la política **lambda\$1execute** 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\$1)
1. Elija **Next: Tags (Siguiente: Etiquetas)**.
1. Elija **Next: Review**.
1. En **Role name (Nombre de rol)**, escriba un nombre como **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. Elija **Create role (Crear rol)**.
1. Elija el rol **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** de la lista de roles.
1. Seleccione la pestaña **Trust Relationships (Relaciones de confianza)**.
1. Elija **Edit trust relationship (Editar relación de confianza)**.
1. Reemplace la política existente por la siguiente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"lambda.amazonaws.com",
"apigateway.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Elija **Update Trust Policy**.
1. 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)**.
1. Elija **Author from Scratch (Crear desde cero)**.
1. En **Name (Nombre)** escriba **Calc**.
1. En **Tiempo de ejecución**, elija el último tiempo de ejecución de **Node.js** o **Python** compatible.
1. Para todas las demás opciones, utilice la configuración predeterminada.
1. Seleccione **Creación de función**.
1. 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.
------
#### [ 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";
}
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
```
------
1. Bajo Execution role (Rol de ejecución) elija **Choose an existing role (Elegir un rol existente)**.
1. Escriba el ARN del rol para el rol **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** que creó anteriormente.
1. 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**.
1. Para el nombre del evento de prueba, escriba **calc2plus5**.
1. Sustituya la definición del evento de prueba por lo siguiente:
```
{
"a": "2",
"b": "5",
"op": "+"
}
```
1. Seleccione **Save**.
1. Seleccione **Probar**
1. 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](https://console.aws.amazon.com/apigateway).
1. 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)**.
1. En **API name (Nombre de la API)**, escriba**LambdaCalc**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Mantenga **Tipo de punto de conexión de la API** establecido en **Regional**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Seleccione **Create API (Crear API)**.
## 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**.
1. Mantenga **Recurso proxy** desactivado.
1. Mantenga **Ruta del recurso** en `/`.
1. En **Nombre del recurso**, escriba **calc**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. 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**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó la función de Lambda.
1. En **Servicio de AWS**, seleccione **Lambda**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, seleccione **POST**.
1. En **Tipo de acción**, elija **Usar sustitución de ruta**. Esta opción nos permite especificar el ARN de la acción [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) para ejecutar nuestra función `Calc`.
1. 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.
1. En **Rol de ejecución**, escriba el ARN del rol para **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. No cambie la configuración de **Caché de credenciales** ni **Tiempo de espera predeterminado**.
1. Elija **Configuración de solicitud de método**.
1. 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.
1. Elija **Parámetros de cadenas de consulta de URL**.
Ahora, debe configurar los parámetros de cadena 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 crear parámetros de cadena de consulta, haga lo siguiente:
1. Elija **Añadir cadena de consulta**.
1. En **Nombre**, escriba **operand1**.
1. Active la opción **Obligatorio**.
1. Mantenga **Almacenamiento en caché** desactivado.
Repita los mismos pasos y cree una cadena de consulta llamada **operand2** y una cadena de consulta llamada **operator**.
1. Elija **Crear método**.
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 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 pestaña **Solicitud de integración**, en **Configuración de la solicitud de integración**, seleccione **Editar**.
1. En **Acceso directo de cuerpo de la solicitud**, elija **Cuando no haya plantillas definidas (recomendado)**.
1. Elija **Plantillas de mapeo**.
1. Elija **Add mapping template (Añadir plantilla de asignación)**.
1. En **Tipo de contenido**, ingrese **application/json**.
1. En **Cuerpo de la plantilla**, introduzca el siguiente código:
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": "$input.params('operator')"
}
```
1. Seleccione **Save**.
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.
1. En **Cadenas de consulta**, escriba **operand1=2&operand2=3&operator=\$1**.
1. Seleccione **Test (Probar)**.
El resultado debe ser parecido al siguiente:
![\[Crear una API en API Gateway como proxy de Lambda\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_new_console.png)
## 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.
**Para crear un método `POST` con una carga JSON**
1. Seleccione el recurso **calc** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **POST**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó la función de Lambda.
1. En **Servicio de AWS**, seleccione **Lambda**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, seleccione **POST**.
1. En **Tipo de acción**, elija **Usar sustitución de ruta**. Esta opción nos permite especificar el ARN de la acción [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html) para ejecutar nuestra función `Calc`.
1. 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.
1. En **Rol de ejecución**, escriba el ARN del rol para **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**.
1. No cambie la configuración de **Caché de credenciales** ni **Tiempo de espera predeterminado**.
1. 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**.
1. Seleccione **Crear modelo**.
1. En **Nombre**, escriba **input**.
1. 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 **\$1default**.
1. En **Esquema del modelo**, escriba el siguiente modelo:
```
{
"type":"object",
"properties":{
"a":{"type":"number"},
"b":{"type":"number"},
"op":{"type":"string"}
},
"title":"input"
}
```
1. 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**.
1. En **Nombre**, escriba **output**.
1. 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 **\$1default**.
1. En **Esquema del modelo**, escriba el siguiente modelo:
```
{
"type":"object",
"properties":{
"c":{"type":"number"}
},
"title":"output"
}
```
1. Seleccione **Crear modelo**.
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**.
1. En **Nombre**, escriba **result**.
1. 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 **\$1default**.
1. 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"
}
```
1. 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.
**Habilitación de la validación de solicitudes en el método POST**
1. En el panel de navegación principal, seleccione **Recursos** y, a continuación, seleccione el método `POST` en el árbol de recursos.
1. En la pestaña **Solicitud de método**, en **Configuración de solicitud de método**, elija **Editar**.
1. En **Validador de solicitudes**, seleccione **Validar cuerpo**.
1. Seleccione **Cuerpo de la solicitud** y, a continuación, seleccione **Añadir modelo**.
1. 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 **\$1default**.
1. En **Modelo**, seleccione **entrada**.
1. Seleccione **Save**.
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.
1. En **Cuerpo de la solicitud**, pegue la siguiente carga JSON.
```
{
"a": 1,
"b": 2,
"op": "+"
}
```
1. Seleccione **Probar**
Debería ver los siguientes datos de salida:
```
{
"a": 1,
"b": 2,
"op": "+",
"c": 3
}
```
## 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:
![\[Crear una API en API Gateway como proxy de Lambda\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_lambda_create_api_resources_new_console.png)
**Para crear un recurso **/\$1operand1\$1/\$1operand2\$1/\$1operator\$1****
1. Elija **Crear recurso**.
1. En **Ruta de recurso**, seleccione `/calc`.
1. En **Nombre del recurso**, escriba **\$1operand1\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
1. En **Ruta de recurso**, seleccione `/calc/{operand1}/`.
1. En **Nombre del recurso**, escriba **\$1operand2\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
1. En **Ruta de recurso**, seleccione `/calc/{operand1}/{operand2}/`.
1. En **Nombre del recurso**, escriba **\$1operator\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. 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 **/\$1operand1\$1/\$1operand2\$1/\$1operator\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Lambda**.
1. Mantenga desactivada la **Integración de proxy Lambda**.
1. En **Función de Lambda**, seleccione la Región de AWS donde creó su función de Lambda e introduzca **Calc**.
1. Mantenga activado **Tiempo de espera predeterminado**.
1. 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/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**, 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 pestaña **Solicitud de integración**, en **Configuración de la solicitud de integración**, seleccione **Editar**.
1. En **Acceso directo de cuerpo de la solicitud**, elija **Cuando no haya plantillas definidas (recomendado)**.
1. Elija **Plantillas de mapeo**.
1. En **Tipo de contenido**, ingrese **application/json**.
1. En **Cuerpo de la plantilla**, introduzca el siguiente código:
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
}
```
1. Seleccione **Save**.
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.
1. Para **Ruta**, haga lo siguiente:
1. En **operand1**, introduzca **1**.
1. En **operand2**, introduzca **1**.
1. En **operator**, introduzca **\$1**.
1. Seleccione **Test (Probar)**.
1. El resultado debe tener el siguiente aspecto:
![\[Pruebe el método GET en la consola de API Gateway.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_path_parm_new_console.png)
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 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**.
1. En **Cuerpo de la respuesta**, seleccione **Agregar modelo**.
1. En **Tipo de contenido**, ingrese **application/json**.
1. En **Modelo**, seleccione **resultado**.
1. Seleccione **Save**.
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 pestaña **Respuesta de integración**, en **Predeterminado: respuesta**, seleccione **Editar**.
1. Elija **Plantillas de mapeo**.
1. En **Tipo de contenido**, ingrese **application/json**.
1. En **Cuerpo de la plantilla**, introduzca el siguiente código:
```
#set($inputRoot = $input.path('$'))
{
"input" : {
"a" : $inputRoot.a,
"b" : $inputRoot.b,
"op" : "$inputRoot.op"
},
"output" : {
"c" : $inputRoot.c
}
}
```
1. Seleccione **Save**.
**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.
1. Para **Ruta**, haga lo siguiente:
1. En **operand1**, introduzca **1**.
1. En **operand2**, introduzca **2**.
1. En **operator**, introduzca **\$1**.
1. Seleccione **Probar**
1. 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 **Implementar API**.
1. En **Etapa**, seleccione **Nueva etapa**.
1. En **Stage name (Nombre de etapa)**, escriba **Prod**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. Elija **Implementar**.
1. (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](https://www.postman.com) y [cURL](https://curl.se/) para probar la API.
**nota**
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": [
{
"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",
"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",
"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",
"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"
}
}
}
},
"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"
}
},
"title": "Result"
}
},
"x-amazon-apigateway-request-validators": {
"Validate body": {
"validateRequestParameters": false,
"validateRequestBody": true
},
"Validate query string parameters and headers": {
"validateRequestParameters": true,
"validateRequestBody": false
}
}
}
```
------
# Tutorial: Creación de una API de REST como proxy de Amazon S3
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](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html).
+ Exponer GET en un recurso de carpeta para [ver una lista de todos los objetos de un bucket de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html).
+ Exponer GET en un recurso de carpeta o elemento para [ver o descargar un objeto de un bucket de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html).
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](api-as-s3-proxy-export-swagger-with-extensions.md). Este ejemplo contiene métodos más expuestos. Para obtener instrucciones sobre cómo importar una API mediante la definición de OpenAPI, consulte [Desarrollo de API de REST mediante OpenAPI en API Gateway](api-gateway-import-api.md).
**nota**
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 conexión de Amazon API Gateway](https://docs.aws.amazon.com/general/latest/gr/apigateway.html).
**Topics**
+ [Configurar permisos de IAM para que la API invoque acciones de Amazon S3](#api-as-s3-proxy-iam-permissions)
+ [Crear recursos de API para representar recursos de Amazon S3](#api-as-s3-proxy-create-resources)
+ [Exponer un método de API para enumerar los buckets de Amazon S3 del intermediario](#api-root-get-as-s3-get-service)
+ [Exponer métodos de API para tener acceso a un bucket de Amazon S3](#api-folder-operations-as-s3-bucket-actions)
+ [Exponer métodos de API para tener acceso a un objeto de Amazon S3 en un bucket](#api-items-in-folder-as-s3-objects-in-bucket)
+ [Definiciones de OpenAPI de la API de ejemplo como un proxy de Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md)
+ [Llamada a la API mediante un cliente API de REST](api-as-s3-proxy-test-using-postman.md)
## 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. En este paso, deberá crear un nuevo rol de IAM.
**Para crear el rol de ejecución del proxy de servicio de AWS**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Roles**.
1. Elija **Creación de rol**.
1. 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**.
1. Seleccione **Siguiente** y de nuevo **Siguiente**.
1. En **Nombre de rol**, escriba **APIGatewayS3ProxyPolicy** y luego elija **Crear rol**.
1. En la lista **Roles**, elija el rol que acaba de crear. Puede que tenga que desplazarse o usar la barra de búsqueda para encontrar el rol.
1. Para el rol seleccionado, seleccione la pestaña **Agregar permisos**.
1. Elija **Adjuntar políticas** en la lista desplegable.
1. En la barra de búsqueda, escriba **AmazonS3FullAccess** y, a continuación, elija **Añadir permisos**.
**nota**
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.
1. 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
Debe utilizar el recurso raíz (`/`) de la API como contenedor de buckets de Amazon S3 de un intermediario autenticado. También debe crear 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.
**nota**
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,**/\$1folder\$1** y **/\$1item\$1**.
1. Elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. En **Ruta de recurso**, seleccione `/`.
1. En **Nombre del recurso**, escriba **\$1folder\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
1. Seleccione el recurso **/\$1folder\$1** y, a continuación, elija **Crear recurso**.
1. Siga los pasos anteriores para crear un recurso secundario de **/\$1folder\$1** denominado **\$1item\$1**.
Su API final debería parecerse a la siguiente:
![\[Crear una API en API Gateway como proxy de Amazon S3\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_s3_create_api-resources_new_console.png)
## 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](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html) 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**.
1. En el tipo de método, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. Para **Región de AWS**, seleccione la Región de AWS donde creó su bucket de Amazon S3.
1. Para **Servicio de AWS**, elija **Amazon Simple Storage Service**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, seleccione **GET**.
1. 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](https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAPI.html) 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.
1. En **Sustitución de ruta**, escriba **/**.
1. En **Rol de ejecución**, escriba el ARN del rol para **APIGatewayS3ProxyPolicy**.
1. Elija **Configuración de solicitud de método**.
Debe utilizar la configuración de solicitud de método para controlar quién puede llamar a este método de la API.
1. En **Autorización**, en el menú desplegable, seleccione `AWS_IAM`.
![\[Declarar tipos de respuestas de método\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_s3_setup_method_request_authorization_new_console.png)
1. 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.
Para que la API devuelva respuestas correctas y excepciones al intermediario, debe declarar las respuestas 200, 400 y 500 en **Respuesta de método**. Debe utilizar la asignación predeterminada 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**.
1. Elija **Añadir encabezado** y haga lo siguiente:
1. En **Nombre de encabezado**, escriba **Content-Type**.
1. Elija **Agregar encabezado**.
Repita estos pasos para crear un encabezado **Timestamp** y un encabezado **Content-Length**.
1. Seleccione **Guardar**.
1. En la pestaña **Método de respuesta**, en **Respuestas de método**, seleccione **Crear respuesta**.
1. En **Código de estado HTTP**, introduzca **400**.
No establezca ningún encabezado para esta respuesta.
1. Seleccione **Guardar**.
1. 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, debe 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 quiere mostrar al cliente otros parámetros de encabezado, como Date y Content-Length.
**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**.
1. Para el encabezado **Content-Length**, introduzca **integration.response.header.Content-Length** en el valor de mapeo.
1. Para el encabezado **Content-Type**, introduzca **integration.response.header.Content-Type** en el valor de mapeo.
1. Para el encabezado **Timestamp**, introduzca **integration.response.header.Date** en el valor de mapeo.
1. Seleccione **Guardar**. El resultado debería ser similar al siguiente:
![\[Asignar encabezados de respuesta de integración a encabezados de respuesta de método\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_s3_setup_integration_response_headers_new_console.png)
1. En la pestaña **Respuesta de integración**, en **Respuestas de integración**, seleccione **Crear respuesta**.
1. En **Expresión regular de estado de HTTP**, escriba **4\$1d\$12\$1**. Esto asigna todos los códigos de estado de respuesta HTTP 4xx a la respuesta del método.
1. En **Código de estado de respuesta del método**, seleccione **400**.
1. Seleccione **Crear**.
1. Repita los siguientes pasos para crear una respuesta de integración para la respuesta del método 500. En **Expresión regular de estado de HTTP**, escriba **5\$1d\$12\$1**.
Como práctica recomendada, puede probar la 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.
1. Seleccione **Probar**. El resultado debe ser similar al de la siguiente imagen:
![\[Probar el resultado de GET Bucket de la raíz de la API\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_s3_test_root_get_result_new_console.png)
## Exponer métodos de API para tener acceso a un bucket de Amazon S3
Para trabajar con un bucket de Amazon S3, exponga el método `GET` en el recurso /\$1folder\$1 para mostrar los objetos de un bucket. Las instrucciones son similares a las que se describen en [Exponer un método de API para enumerar los buckets de Amazon S3 del intermediario](#api-root-get-as-s3-get-service). 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](api-as-s3-proxy-export-swagger-with-extensions.md).
**Para exponer el método GET en un recurso de carpeta**
1. Seleccione el recurso **/\$1folder\$1** y, a continuación, elija **Crear método**.
1. En el tipo de método, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. Para **Región de AWS**, seleccione la Región de AWS donde creó su bucket de Amazon S3.
1. Para **Servicio de AWS**, elija **Amazon Simple Storage Service**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, seleccione **GET**.
1. En **Tipo de acción**, elija **Usar sustitución de ruta**.
1. En **Sustitución de ruta**, escriba **\$1bucket\$1**.
1. En **Rol de ejecución**, escriba el ARN del rol para **APIGatewayS3ProxyPolicy**.
1. 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**.
1. Elija **Parámetros de la ruta URL** y, a continuación, elija **Agregar parámetro de ruta**.
1. En **Nombre**, escriba **bucket**.
1. En **Asignado desde**, introduzca **method.request.path.folder**.
1. Seleccione **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.
1. En **Ruta**, para la **carpeta**, introduzca el nombre de tu bucket.
1. Seleccione **Probar**.
El resultado de la prueba incluirá una lista de los objetos del bucket.
![\[Pruebe el método GET para crear un bucket de Amazon S3.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_s3_test_api_folder_get_new_console.png)
## 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 recurso `{folder}/{item}`, consulte la API de ejemplo, [Definiciones de OpenAPI de la API de ejemplo como un proxy de Amazon S3](api-as-s3-proxy-export-swagger-with-extensions.md).
**Para exponer el método GET en un recurso de elemento**
1. Seleccione el recurso **/\$1item\$1** y, a continuación, elija **Crear método**.
1. En el tipo de método, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. Para **Región de AWS**, seleccione la Región de AWS donde creó su bucket de Amazon S3.
1. Para **Servicio de AWS**, elija **Amazon Simple Storage Service**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, seleccione **GET**.
1. En **Tipo de acción**, elija **Usar sustitución de ruta**.
1. En **Sustitución de ruta**, introduzca **\$1bucket\$1/\$1object\$1**.
1. En **Rol de ejecución**, escriba el ARN del rol para **APIGatewayS3ProxyPolicy**.
1. 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**.
1. Elija los **Parámetros de la ruta URL**.
1. Elija **Añadir parámetro de ruta**.
1. En **Nombre**, escriba **bucket**.
1. En **Asignado desde**, introduzca **method.request.path.folder**.
1. Elija **Añadir parámetro de ruta**.
1. En **Nombre**, escriba **object**.
1. En **Asignado desde**, introduzca **method.request.path.item**.
1. Seleccione **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.
1. En **Ruta**, para la **carpeta**, introduzca el nombre de tu bucket.
1. En **Ruta**, para el **elemento**, introduzca el nombre de un elemento.
1. Seleccione **Probar**.
El cuerpo de la respuesta incluirá el contenido del elemento.
![\[Pruebe el método GET para crear un bucket de Amazon S3.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/aws_proxy_s3_test_api_item_get_new_console.png)
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 (amzn-s3-demo-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:
1. Elija **Configuración de API** para la API.
1. En **Tipos de medios binarios**, seleccione **Gestionar tipos de medios**.
1. Seleccione **Añadir tipo de medio binario** y, a continuación, introduzca el tipo de medio requerido, por ejemplo, `image/png`.
1. Elija **Guardar cambios**, para guardar la configuración.
1. 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.
1. 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 [Transformaciones de datos para las API de REST en API Gateway](rest-api-data-transformations.md).
El límite de tamaño de carga es 10 MB. Consulte [Cuotas para configurar y ejecutar una API de REST en API Gateway](api-gateway-execution-service-limits-table.md).
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](api-gateway-payload-encodings-workflow.md).
# 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](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListBuckets.html).
+ Exponer GET en un recurso de carpeta para [ver una lista de todos los objetos de un bucket de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjects.html).
+ Exponer PUT en un recurso de carpeta para [agregar un bucket a Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucket.html).
+ Exponer DELETE en un recurso de carpeta para [eliminar un bucket de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucket.html).
+ Exponer GET en un recurso de carpeta o elemento para [ver o descargar un objeto de un bucket de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html).
+ Exponer PUT en un recurso de carpeta o elemento para [cargar un objeto en un bucket de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html).
+ Exponer HEAD en un recurso de carpeta o elemento para [obtener los metadatos de objeto en un bucket de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadObject.html).
+ Exponer DELETE en un recurso de carpeta o elemento para [eliminar un objeto de un bucket de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObject.html).
Para obtener instrucciones sobre cómo importar una API mediante la definición de OpenAPI, consulte [Desarrollo de API de REST mediante OpenAPI en API Gateway](api-gateway-import-api.md).
Para obtener instrucciones sobre cómo crear una API similar, consulte [Tutorial: Creación de una API de REST como proxy de Amazon S3](integrating-api-with-aws-services-s3.md).
Para obtener información sobre cómo invocar esta API mediante [Postman](https://www.postman.com/), que admite la autorización de IAM AWS, consulte [Llamada a la API mediante un cliente API de REST](api-as-s3-proxy-test-using-postman.md).
------
#### [ 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",
"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"
}
},
"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"
},
"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": [
{
"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}": {
"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"
},
"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",
"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"
}
},
"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",
"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": {
"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"
}
],
"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"
}
},
"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"
},
"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": {
"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" : {
"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" : {
"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" : { }
},
"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"
}
},
"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" : {
"$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"
}
}, {
"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" : {
"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"
}
} ],
"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",
"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",
"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"
},
"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" : {
"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" : { }
},
"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" : {
"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"
}
}
}
}
```
------
# Llamada a la API mediante un cliente API de REST
Para proporcionar un tutorial completo, ahora mostraremos cómo llamar a la API mediante [Postman](https://www.postman.com/), 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)**.
1. Inicie Postman.
1. Elija **Autorización** y, a continuación, elija `AWS Signature`. Ingrese 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. Ingrese la Región de AWS en la que va a implementar la API en el cuadro de texto **Región de AWS**. Ingrese `execute-api` en el campo de entrada **Nombre del servicio**.
Puede crear un par de claves desde la pestaña **Credenciales de seguridad** de su cuenta de usuario de IAM en la consola de administración de IAM.
1. Para agregar un bucket denominado `amzn-s3-demo-bucket` a su cuenta de Amazon S3 en la región `{region}`:
1. 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`)
1. 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.
1. Elija el elemento de menú **Body (Cuerpo)** y escriba el siguiente fragmento XML como cuerpo de la solicitud:
```
{region}
```
1. Elija **Send (Enviar)** para enviar la solicitud. Si todo va bien, debería recibir una respuesta `200 OK` con una carga vacía.
1. Para añadir un archivo de texto a un bucket, siga las instrucciones anteriores. Si especifica el nombre de bucket de **amzn-s3-demo-bucket** para `{folder}` y el nombre de archivo **Readme.txt** para `{item}` en la dirección URL y proporciona la cadena de texto **Hello, World\$1** como contenido de archivo (con lo que se convierte en la carga de la solicitud), la respuesta será
```
PUT /S3/amzn-s3-demo-bucket/Readme.txt HTTP/1.1
Host: 9gn28ca086.execute-api.{region}.amazonaws.com
Content-Type: application/xml
X-Amz-Date: 20161015T062647Z
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.
1. Para obtener el contenido del archivo `Readme.txt` que acaba de añadir al bucket `amzn-s3-demo-bucket`, envíe una solicitud GET como la siguiente:
```
GET /S3/amzn-s3-demo-bucket/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.
1. Para mostrar los elementos del bucket `amzn-s3-demo-bucket`, envíe la siguiente solicitud:
```
GET /S3/amzn-s3-demo-bucket 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.
```
apig-demo-5
1000
false
Readme.txt
2016-10-15T06:26:48.000Z
"65a8e27d8879283831b664bd8b7f0ad4"
13
06e4b09e9d...603addd12ee
user-name
STANDARD
```
**nota**
Para cargar o descargar una imagen, debe configurar el tratamiento de contenido como CONVERT\$1TO\$1BINARY.
# Tutorial: Creación de una API de REST como proxy de Amazon Kinesis
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.
**nota**
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 conexión y cuotas de servicio](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html).
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
1. Creación, descripción o eliminación de un flujo especificado
1. 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
1. La acción `CreateStream`, `DescribeStream` o `DeleteStream`
1. 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html) 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html) 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DescribeStream.html) 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_DeleteStream.html) 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html) 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html) 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html) de Kinesis. Esto permite que el cliente muestre registros de datos en el flujo con nombre, con un iterador de fragmento especificado. Un iterador 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetShardIterator.html) 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/Welcome.html).
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](https://docs.aws.amazon.com/apigateway/latest/api/API_ImportRestApi.html) de API Gateway. Para obtener información acerca de cómo utilizar Import API, consulte [Desarrollo de API de REST mediante OpenAPI en API Gateway](api-gateway-import-api.md).
## 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. En este paso, deberá crear un nuevo rol de IAM.
**Para crear el rol de ejecución del proxy de servicio de AWS**
1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Elija **Roles**.
1. Seleccione **Crear rol**.
1. 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**.
1. Seleccione **Siguiente** y de nuevo **Siguiente**.
1. En **Nombre de rol**, escriba **APIGatewayKinesisProxyPolicy** y luego elija **Crear rol**.
1. En la lista **Roles**, elija el rol que acaba de crear. Puede que tenga que desplazarse o usar la barra de búsqueda para encontrar el rol.
1. Para el rol seleccionado, seleccione la pestaña **Agregar permisos**.
1. Elija **Adjuntar políticas** en la lista desplegable.
1. En la barra de búsqueda, escriba **AmazonKinesisFullAccess** y, a continuación, elija **Añadir permisos**.
**nota**
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.
1. Anote el **ARN del rol** recién creado, ya que lo usará más adelante.
## Creación de una API como un 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](https://console.aws.amazon.com/apigateway).
1. 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)**.
1. Elija **New API (Nueva API)**.
1. En **API name (Nombre de la API)**, escriba **KinesisProxy**. Mantenga los valores predeterminados en todos los demás campos.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. 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..
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.1
Authorization:
X-Amz-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..
Content-Length:
User-Agent:
Content-Type: application/x-amz-json-1.1
Authorization:
X-Amz-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**.
1. En **Nombre del recurso**, escriba **streams**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
1. Elija el recurso `/streams` y luego **Crear método**. A continuación, haga lo siguiente:
1. En **Tipo de método**, seleccione **GET**.
**nota**
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.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
**nota**
Aquí elegimos `POST` porque Kinesis requiere que la acción `ListStreams` también se invoque.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **ListStreams**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. En la pestaña **Solicitud de integración**, en **Configuración de la solicitud de integración**, seleccione **Editar**.
1. En **Acceso directo de cuerpo de la solicitud**, elija **Cuando no haya plantillas definidas (recomendado)**.
1. Elija **Parámetros de encabezados de consulta de URL** y luego haga lo siguiente:
1. Seleccione **Añadir parámetros de encabezados de solicitud**.
1. En **Nombre**, escriba **Content-Type**.
1. En **Asignado desde**, introduzca **'application/x-amz-json-1.1'**.
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.
1. Elija **Plantillas de mapeo** y, a continuación, elija **Agregar plantilla de mapeo** y haga lo siguiente:
1. En **Content-Type**, indique **application/json**.
1. En **Cuerpo de plantilla**, escriba **\$1\$1**.
1. Seleccione **Save**.
La solicitud [ListStreams](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_ListStreams.html#API_ListStreams_RequestSyntax) 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.
1. Pruebe el método GET en el recurso **/streams** para invocar la acción `ListStreams` en Kinesis:
Elija la pestaña **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"
]
}
```
## 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
{
"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 \$1stream-name\$1**
1. Elija el recurso **/streams** y, a continuación, elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. En **Ruta de recurso**, seleccione `/streams`.
1. En **Nombre del recurso**, escriba **\$1stream-name\$1**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
**Para configurar y probar el método GET en un recurso de flujo**
1. Elija el recurso **/\$1stream-name\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **DescribeStream**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. 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`.
1. 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.
1. Para probar el método `GET /stream/{stream-name}` para invocar la acción `DescribeStream` en Kinesis, seleccione la pestaña **Prueba**.
1. En **Ruta**, en **stream-name**, introduzca el nombre de un flujo de Kinesis existente.
1. Seleccione **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"
},
"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. Elija el recurso **/\$1stream-name\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **POST**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **CreateStream**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. 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`.
1. 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.
1. Para probar el método `POST /stream/{stream-name}` para invocar la acción `CreateStream` en Kinesis, seleccione la pestaña **Prueba**.
1. En **Ruta**, en **stream-name**, introduzca el nombre de un flujo de Kinesis nuevo.
1. Seleccione **Probar**. Si la prueba tiene éxito, se devuelve una respuesta 200 OK sin datos.
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. Elija el recurso **/\$1stream-name\$1** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **DELETE**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **DeleteStream**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. 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`.
1. 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`.
1. Para probar el método `DELETE /stream/{stream-name}` para invocar la acción `DeleteStream` en Kinesis, seleccione la pestaña **Prueba**.
1. En **Ruta**, en **stream-name**, introduzca el nombre de un flujo de Kinesis existente.
1. Seleccione **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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecords.html#API_PutRecords_Examples) o [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html#API_PutRecord_Examples) de Kinesis. La primera acción añade varios registros, mientras que la última añade un solo registro al flujo.
```
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"
}
```
o
```
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 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](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_GetRecords.html#API_GetRecords_Examples):
```
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`.
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. Elija el recurso **/\$1stream-name\$1** y, a continuación, elija **Crear recurso**.
1. Mantenga **Recurso proxy** desactivado.
1. En **Ruta de recurso**, seleccione `/{stream-name}`.
1. En **Nombre del recurso**, escriba **record**.
1. Mantenga desactivado **CORS (uso compartido de recursos entre orígenes)**.
1. Elija **Crear recurso**.
1. Repita los pasos anteriores para crear un recurso **/records** y un recurso **/sharditerator**. La API final debe ser similar a la siguiente:
![\[Creación del método Records:GET|PUT|PUT|GET para la API.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/api-gateway-kinesis-proxy-setup-streams-stream-record-method-new-console.png)
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. Elija **/record** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **PUT**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **PutRecord**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. 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`.
1. 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" }
}
}
```
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.
1. 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. Elija el recurso **/records** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **PUT**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **PutRecords**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Crear método**.
1. 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`.
1. 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" }
}
}
}
}
}
```
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.
1.
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"
},
{
"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. Elija el recurso **/sharditerator** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **GetShardIterator**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Parámetros de cadenas de consulta de URL**.
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.
1. Elija **Añadir cadena de consulta**.
1. En **Nombre**, escriba **shard-id**.
1. Mantenga desactivados **Obligatorio** y **Almacenamiento en caché**.
1. Elija **Crear método**.
1. 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')"
}
```
1. 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. Elija el recurso **/records** y, a continuación, elija **Crear método**.
1. En **Tipo de método**, seleccione **GET**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. En **Región de AWS**, seleccione la Región de AWS donde creó el flujo de Kinesis.
1. En **Servicio de AWS**, seleccione **Kinesis**.
1. Deje **Subdominio de AWS** en blanco.
1. En **Método HTTP**, elija **POST**.
1. En **Tipo de acción**, elija **Usar nombre de acción**.
1. En **Nombre de la función**, introduzca **GetRecords**.
1. En **Rol de ejecución**, escriba el ARN del rol de ejecución.
1. Deje el valor predeterminado **Acceso directo** en **Tratamiento de contenido**.
1. Elija **Encabezados de solicitud HTTP**.
La acción `GetRecords` requiere una entrada de un valor de `ShardIterator`. Para pasar un valor de `ShardIterator` proporcionado por el cliente, agregamos un parámetro de encabezado `Shard-Iterator` a la solicitud del método.
1. Elija **Agregar encabezado**.
1. En **Nombre**, escriba **Shard-Iterator**.
1. Mantenga desactivados **Obligatorio** y **Almacenamiento en caché**.
1. Elija **Crear método**.
1. 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')"
}
```
1. 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:
```
{
"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": {
"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",
"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",
"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",
"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"
}
}
}
}
},
"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"
}
}
}
}
},
"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": {
"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": {
"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"
}
}
}
}
},
"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",
"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"
}
}
}
}
}
}
}
}
}
```
------
#### [ 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": {
"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"
}
},
"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'"
},
"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": {
"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",
"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": {
"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": {
"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"
}
},
{
"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"
}
}
},
"/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'"
},
"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 de REST mediante SDK de AWS o la AWS CLI
En el siguiente tutorial se muestra cómo crear una API de PetStore que sea compatible con los métodos `GET /pets` y `GET /pets/{petId}`. Los métodos están integrados con un punto de conexión HTTP. Puede seguir este tutorial con AWS SDK para JavaScript, SDK para Python (Boto3) o la AWS CLI. Se utilizan las siguientes funciones o comandos para configurar la API:
------
#### [ JavaScript v3 ]
+ [ CreateRestApiCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateRestApiCommand/)
+ [ CreateResourceCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateResourceCommand/)
+ [ PutMethodCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutMethodCommand/)
+ [ PutMethodResponseCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutMethodResponseCommand/)
+ [ PutIntegrationCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutIntegrationCommand/)
+ [ PutIntegrationResponseCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/PutIntegrationResponseCommand/)
+ [ CreateDeploymentCommand](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/api-gateway/command/CreateDeploymentCommand/)
------
#### [ Python ]
+ [ create\$1rest\$1api](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_rest_api.html)
+ [ create\$1resource](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_resource.html)
+ [ put\$1method](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_method.html)
+ [ put\$1method\$1response](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_method_response.html)
+ [ put\$1integration](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_integration.html)
+ [ put\$1integration\$1response](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/put_integration_response.html)
+ [ create\$1deployment](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/apigateway/client/create_deployment.html)
------
#### [ AWS CLI ]
+ [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-rest-api.html)
+ [create-resource](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-resource.html)
+ [put-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html)
+ [put-method-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method-response.html)
+ [put-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html)
+ [put-integration-response](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration-response.html)
+ [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-deployment.html)
------
Para obtener más información sobre AWS SDK para JavaScript v3, consulte [¿Qué es AWS SDK para JavaScript?](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/welcome.html). Para obtener más información sobre el SDK para Python (Boto3), consulte [AWS SDK para Python (Boto3)](https://docs.aws.amazon.com/pythonsdk). Para obtener más información sobre la AWS CLI, consulte [¿Qué es la AWS CLI?](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html).
## Configuración de una API PetStore optimizada para sistemas perimetrales
En este tutorial, los comandos de ejemplo utilizan valores de marcador de posición para los ID de valor, como el ID de API y el ID de recurso. Según complete el tutorial, sustituya estos valores por los suyos.
**Configuración de una API de PetStore optimizada para sistemas perimetrales con AWS SDK**
1. Utilice el siguiente ejemplo para crear una entidad `RestApi`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateRestApiCommand} from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateRestApiCommand({
name: "Simple PetStore (JavaScript v3 SDK)",
description: "Demo API created using the AWS SDK for JavaScript v3",
version: "0.00.001",
binaryMediaTypes: [
'*']
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.error(Couldn't create API:\n", err)
}
})();
```
Una llamada correcta devuelve el ID de API y el ID de recurso raíz de la API en un resultado como el siguiente:
```
{
id: 'abc1234',
name: 'PetStore (JavaScript v3 SDK)',
description: 'Demo API created using the AWS SDK for node.js',
createdDate: 2017-09-05T19:32:35.000Z,
version: '0.00.001',
rootResourceId: 'efg567'
binaryMediaTypes: [ '*' ]
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_rest_api(
name='Simple PetStore (Python SDK)',
description='Demo API created using the AWS SDK for Python',
version='0.00.001',
binaryMediaTypes=[
'*'
]
)
except botocore.exceptions.ClientError as error:
logger.exception("Couldn't create REST API %s.", error)
raise
attribute=["id","name","description","createdDate","version","binaryMediaTypes","apiKeySource","endpointConfiguration","disableExecuteApiEndpoint","rootResourceId"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve el ID de API y el ID de recurso raíz de la API en un resultado como el siguiente:
```
{'id': 'abc1234', 'name': 'Simple PetStore (Python SDK)', 'description': 'Demo API created using the AWS SDK for Python', 'createdDate': datetime.datetime(2024, 4, 3, 14, 31, 39, tzinfo=tzlocal()), 'version': '0.00.001', 'binaryMediaTypes': ['*'], 'apiKeySource': 'HEADER', 'endpointConfiguration': {'types': ['EDGE']}, 'disableExecuteApiEndpoint': False, 'rootResourceId': 'efg567'}
```
------
#### [ AWS CLI ]
```
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": "abcd1234",
"name": "Simple PetStore (AWS CLI)",
"createdDate": "2022-12-15T08:07:04-08:00",
"apiKeySource": "HEADER",
"endpointConfiguration": {
"types": [
"EDGE"
]
},
"disableExecuteApiEndpoint": false,
"rootResourceId": "efg567"
}
```
------
La API que ha creado tiene el ID de API `abcd1234` y el ID de recurso raíz `efg567`. Se utilizan estos valores en la configuración de la API.
1. A continuación, se agrega un recurso secundario en la raíz, se especifica `RootResourceId` como valor de la propiedad `parentId`. Use el siguiente ejemplo para crear un recurso de `/pets` para la API:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateResourceCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateResourceCommand({
restApiId: 'abcd1234',
parentId: 'efg567',
pathPart: 'pets'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The '/pets' resource setup failed:\n", err)
}
})();
```
Una llamada correcta devuelve información sobre el recurso en un resultado como el siguiente:
```
{
"path": "/pets",
"pathPart": "pets",
"id": "aaa111",
"parentId": "efg567'"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_resource(
restApiId='abcd1234',
parentId='efg567',
pathPart='pets'
)
except botocore.exceptions.ClientError as error:
logger.exception("The '/pets' resource setup failed: %s.", error)
raise
attribute=["id","parentId", "pathPart", "path",]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve información sobre el recurso en un resultado como el siguiente:
```
{'id': 'aaa111', 'parentId': 'efg567', 'pathPart': 'pets', 'path': '/pets'}
```
------
#### [ AWS CLI ]
```
aws apigateway create-resource --rest-api-id abcd1234 \
--region us-west-2 \
--parent-id efg567 \
--path-part pets
```
A continuación se muestra la salida de este comando:
```
{
"id": "aaa111",
"parentId": "efg567",
"pathPart": "pets",
"path": "/pets"
}
```
------
El recurso `/pets` que ha creado tiene un ID de recurso de `aaa111`. Se utiliza este valor en la configuración de la API.
1. A continuación, agregue un recurso secundario en el recurso de `/pets`. Este recurso, `/{petId}` tiene un parámetro de ruta para `{petId}`. Para hacer una parte de la ruta, un parámetro de la ruta, sitúelo entre llaves, `{ }`. Use el siguiente ejemplo para crear un recurso de `/pets/{petId}` para la API:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateResourceCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateResourceCommand({
restApiId: 'abcd1234',
parentId: 'aaa111',
pathPart: '{petId}'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The '/pets/{petId}' resource setup failed:\n", err)
}
})();
```
Una llamada correcta devuelve información sobre el recurso en un resultado como el siguiente:
```
{
"path": "/pets/{petId}",
"pathPart": "{petId}",
"id": "bbb222",
"parentId": "aaa111'"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_resource(
restApiId='abcd1234',
parentId='aaa111',
pathPart='{petId}'
)
except botocore.exceptions.ClientError as error:
logger.exception("The '/pets/{petId}' resource setup failed: %s.", error)
raise
attribute=["id","parentId", "pathPart", "path",]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve información sobre el recurso en un resultado como el siguiente:
```
{'id': 'bbb222', 'parentId': 'aaa111', 'pathPart': '{petId}', 'path': '/pets/{petId}'}
```
------
#### [ AWS CLI ]
```
aws apigateway create-resource --rest-api-id abcd1234 \
--region us-west-2 \
--parent-id aaa111 \
--path-part '{petId}'
```
A continuación se muestra la salida de este comando:
```
{
"id": "bbb222",
"parentId": "aaa111",
"path": "/pets/{petId}",
"pathPart": "{petId}"
}
```
------
El recurso `/pets/{petId}` que ha creado tiene un ID de recurso de `bbb222`. Se utiliza este valor en la configuración de la API.
1. En los dos pasos siguientes, se agregan métodos HTTP a los recursos. En este tutorial, se establecen los métodos para que tengan acceso abierto configurando el `authorization-type` para establecer 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 [Control y administración del acceso a las API de REST en API Gateway](apigateway-control-access-to-api.md).
Use el siguiente ejemplo para agregar el método HTTP `GET` al recurso `/pets`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
authorizationType: 'NONE'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets' method setup failed:\n", err)
}
})();
```
Una llamada correcta devuelve el resultado siguiente:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
authorizationType='NONE'
)
except botocore.exceptions.ClientError as error:
logger.exception("The 'GET /pets' method setup failed: %s", error)
raise
attribute=["httpMethod","authorizationType","apiKeyRequired"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve el resultado siguiente:
```
{'httpMethod': 'GET', 'authorizationType': 'NONE', 'apiKeyRequired': False}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method --rest-api-id abcd1234 \
--resource-id aaa111 \
--http-method GET \
--authorization-type "NONE" \
--region us-west-2
```
A continuación se muestra la salida de este comando:
```
{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": false
}
```
------
1. Use el siguiente ejemplo para agregar el método HTTP `GET` al recurso `/pets/{petId}` y establecer la propiedad `requestParameters` para pasar el valor `petId` proporcionado por el cliente al backend:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
authorizationType: 'NONE'
requestParameters: {
"method.request.path.petId" : true
}
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets/{petId}' method setup failed:\n", err)
}
})();
```
Una llamada correcta devuelve el resultado siguiente:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"authorizationType": "NONE",
"requestParameters": {
"method.request.path.petId": true
}
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
authorizationType='NONE',
requestParameters={
"method.request.path.petId": True
}
)
except botocore.exceptions.ClientError as error:
logger.exception("The 'GET /pets/{petId}' method setup failed: %s", error)
raise
attribute=["httpMethod","authorizationType","apiKeyRequired", "requestParameters" ]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve el resultado siguiente:
```
{'httpMethod': 'GET', 'authorizationType': 'NONE', 'apiKeyRequired': False, 'requestParameters': {'method.request.path.petId': True}}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET \
--authorization-type "NONE" \
--region us-west-2 \
--request-parameters method.request.path.petId=true
```
A continuación se muestra la salida de este comando:
```
{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": false,
"requestParameters": {
"method.request.path.petId": true
}
}
```
------
1. Use el siguiente ejemplo para agregar la respuesta del método 200 OK para el método `GET /pets`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodResponseCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
statusCode: '200'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the 200 OK response for the 'GET /pets' method failed:\n", err)
}
})();
```
Una llamada correcta devuelve el resultado siguiente:
```
{
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method_response(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
statusCode='200'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the 200 OK response for the 'GET /pets' method failed %s.", error)
raise
attribute=["statusCode"]
filtered_result ={key:result[key] for key in attribute}
logger.info(filtered_result)
```
Una llamada correcta devuelve el resultado siguiente:
```
{'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method-response --rest-api-id abcd1234 \
--resource-id aaa111 --http-method GET \
--status-code 200 --region us-west-2
```
A continuación se muestra la salida de este comando:
```
{
"statusCode": "200"
}
```
------
1. Use el siguiente ejemplo para agregar la respuesta del método 200 OK para el método `GET /pets/{petId}`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutMethodResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutMethodResponseCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
statusCode: '200'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the 200 OK response for the 'GET /pets/{petId}' method failed:\n", err)
}
})();
```
Una llamada correcta devuelve el resultado siguiente:
```
{
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_method_response(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
statusCode='200'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the 200 OK response for the 'GET /pets/{petId}' method failed %s.", error)
raise
attribute=["statusCode"]
filtered_result ={key:result[key] for key in attribute}
logger.info(filtered_result)
```
Una llamada correcta devuelve el resultado siguiente:
```
{'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-method-response --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET \
--status-code 200 --region us-west-2
```
A continuación se muestra la salida de este comando:
```
{
"statusCode": "200"
}
```
------
1. Use el siguiente ejemplo para configurar una integración para el método `GET /pets` con un punto de conexión HTTP. El punto de conexión HTTPS es `http://petstore-demo-endpoint.execute-api.com/petstore/pets`.
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
type: 'HTTP',
integrationHttpMethod: 'GET',
uri: 'http://petstore-demo-endpoint.execute-api.com/petstore/pets'
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the integration of the 'GET /pets' method of the API failed:\n", err)
}
})();
```
Una llamada correcta devuelve el resultado siguiente:
```
{
"httpMethod": "GET",
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"type": "HTTP",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"cacheNamespace": "ccc333"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
type='HTTP',
integrationHttpMethod='GET',
uri='http://petstore-demo-endpoint.execute-api.com/petstore/pets'
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration of the 'GET /' method of the API failed %s.", error)
raise
attribute=["httpMethod","passthroughBehavior","cacheKeyParameters", "type", "uri", "cacheNamespace"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve el resultado siguiente:
```
{'httpMethod': 'GET', 'passthroughBehavior': 'WHEN_NO_MATCH', 'cacheKeyParameters': [], 'type': 'HTTP', 'uri': 'http://petstore-demo-endpoint.execute-api.com/petstore/pets', 'cacheNamespace': 'ccc333'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration --rest-api-id abcd1234 \
--resource-id aaa111 --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": []
}
```
------
1. Use el siguiente ejemplo para configurar una integración para el método `GET /pets/{petId}` con un punto de conexión HTTP. El punto de conexión HTTPS es `http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}`. En este paso, se mapea el parámetro de ruta `petId` al parámetro de ruta del punto de conexión `id`.
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
type: 'HTTP',
integrationHttpMethod: 'GET',
uri: 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}'
requestParameters: {
"integration.request.path.id": "method.request.path.petId"
}
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("Set up the integration of the 'GET /pets/{petId}' method of the API failed:\n", err)
}
})();
```
Una llamada correcta devuelve el resultado siguiente:
```
{
"httpMethod": "GET",
"passthroughBehavior": "WHEN_NO_MATCH",
"cacheKeyParameters": [],
"type": "HTTP",
"uri": "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"cacheNamespace": "ddd444",
"requestParameters": {
"integration.request.path.id": "method.request.path.petId"
}
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration(
restApiId='ieps9b05sf',
resourceId='t8zeb4',
httpMethod='GET',
type='HTTP',
integrationHttpMethod='GET',
uri='http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}',
requestParameters={
"integration.request.path.id": "method.request.path.petId"
}
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration of the 'GET /pets/{petId}' method of the API failed %s.", error)
raise
attribute=["httpMethod","passthroughBehavior","cacheKeyParameters", "type", "uri", "cacheNamespace", "requestParameters"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve el resultado siguiente:
```
{'httpMethod': 'GET', 'passthroughBehavior': 'WHEN_NO_MATCH', 'cacheKeyParameters': [], 'type': 'HTTP', 'uri': 'http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}', 'cacheNamespace': 'ddd444', 'requestParameters': {'integration.request.path.id': 'method.request.path.petId'}}}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration --rest-api-id abcd1234 \
--resource-id bbb222 --http-method GET --type HTTP \
--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
```
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": []
}
```
------
1. Use el siguiente ejemplo para agregar la respuesta de integración para la integración de `GET /pets`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationResponseCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
statusCode: '200',
selectionPattern: ''
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets' method integration response setup failed:\n", err)
}
})();
```
Una llamada correcta devuelve el resultado siguiente:
```
{
"selectionPattern": "",
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration_response(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
statusCode='200',
selectionPattern='',
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration response of the 'GET /pets' method of the API failed: %s", error)
raise
attribute=["selectionPattern","statusCode"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve el resultado siguiente:
```
{'selectionPattern': "", 'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration-response --rest-api-id abcd1234 \
--resource-id aaa111 --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": ""
}
```
------
1. Use el siguiente ejemplo para agregar la respuesta de integración para la integración de `GET /pets/{petId}`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, PutIntegrationResponseCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new PutIntegrationResponseCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
statusCode: '200',
selectionPattern: ''
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The 'GET /pets/{petId}' method integration response setup failed:\n", err)
}
})();
```
Una llamada correcta devuelve el resultado siguiente:
```
{
"selectionPattern": "",
"statusCode": "200"
}
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.put_integration_response(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
statusCode='200',
selectionPattern='',
)
except botocore.exceptions.ClientError as error:
logger.exception("Set up the integration response of the 'GET /pets/{petId}' method of the API failed: %s", error)
raise
attribute=["selectionPattern","statusCode"]
filtered_result ={key:result[key] for key in attribute}
print(filtered_result)
```
Una llamada correcta devuelve el resultado siguiente:
```
{'selectionPattern': "", 'statusCode': '200'}
```
------
#### [ AWS CLI ]
```
aws apigateway put-integration-response --rest-api-id abcd1234 \
--resource-id bbb222 --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": ""
}
```
------
Después de crear la respuesta de integración, la API puede consultar las mascotas disponibles en el sitio web de PetStore y ver una mascota concreta de un identificador especificado. Antes de que los clientes puedan llamar a la API, debe implementarla. Le recomendamos que antes de implementar la API, la pruebe.
1. Use el siguiente ejemplo para probar el método `GET /pets`:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new TestInvokeMethodCommand({
restApiId: 'abcd1234',
resourceId: 'aaa111',
httpMethod: 'GET',
pathWithQueryString: '/',
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The test on 'GET /pets' method failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.test_invoke_method(
restApiId='abcd1234',
resourceId='aaa111',
httpMethod='GET',
pathWithQueryString='/',
)
except botocore.exceptions.ClientError as error:
logger.exception("Test invoke method on 'GET /pets' failed: %s", error)
raise
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway test-invoke-method --rest-api-id abcd1234 /
--resource-id aaa111 /
--http-method GET /
--path-with-query-string '/'
```
------
1. Use el siguiente ejemplo para probar el método `GET /pets/{petId}` con un `petId` de 3:
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, TestInvokeMethodCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new TestInvokeMethodCommand({
restApiId: 'abcd1234',
resourceId: 'bbb222',
httpMethod: 'GET',
pathWithQueryString: '/pets/3',
});
try {
const results = await apig.send(command)
console.log(results)
} catch (err) {
console.log("The test on 'GET /pets/{petId}' method failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.test_invoke_method(
restApiId='abcd1234',
resourceId='bbb222',
httpMethod='GET',
pathWithQueryString='/pets/3',
)
except botocore.exceptions.ClientError as error:
logger.exception("Test invoke method on 'GET /pets/{petId}' failed: %s", error)
raise
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway test-invoke-method --rest-api-id abcd1234 /
--resource-id bbb222 /
--http-method GET /
--path-with-query-string '/pets/3'
```
------
Una vez que haya probado con éxito la API, puede implementarla en una etapa.
1. Use el siguiente ejemplo para implementar la API en una etapa denominada `test`. Cuando se implementa la API en una etapa, los intermediarios de la API pueden invocar la API.
------
#### [ JavaScript v3 ]
```
import {APIGatewayClient, CreateDeploymentCommand } from "@aws-sdk/client-api-gateway";
(async function (){
const apig = new APIGatewayClient({region:"us-east-1"});
const command = new CreateDeploymentCommand({
restApiId: 'abcd1234',
stageName: 'test',
stageDescription: 'test deployment'
});
try {
const results = await apig.send(command)
console.log("Deploying API succeeded\n", results)
} catch (err) {
console.log("Deploying API failed:\n", err)
}
})();
```
------
#### [ Python ]
```
import botocore
import boto3
import logging
logger = logging.getLogger()
apig = boto3.client('apigateway')
try:
result = apig.create_deployment(
restApiId='ieps9b05sf',
stageName='test',
stageDescription='my test stage',
)
except botocore.exceptions.ClientError as error:
logger.exception("Error deploying stage %s.", error)
raise
print('Deploying API succeeded')
print(result)
```
------
#### [ AWS CLI ]
```
aws apigateway create-deployment --rest-api-id abcd1234 \
--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"
}
```
------
Los clientes ahora pueden llamar a la API. Puede probar esta API ingresando la URL `https://abcd1234.execute-api.us-west-2.amazonaws.com/test/pets` en un navegador y sustituyendo `abcd1234` por el identificador de la API.
Para ver más ejemplos de cómo crear o actualizar una API mediante los AWS SDK o AWS CLI, consulte [Acciones para API Gateway con AWS SDK](https://docs.aws.amazon.com/code-library/latest/ug/api-gateway_code_examples_actions.html).
## Automatización de la configuración de la API
En lugar de crear la API paso a paso, puede automatizar la creación y la limpieza de recursos de AWS mediante OpenAPI, CloudFormation o Terraform para crear la API.
### Definición de OpenAPI 3.0
Puede importar una definición de OpenAPI a API Gateway. Para obtener más información, consulte [Desarrollo de API de REST mediante OpenAPI en API Gateway](api-gateway-import-api.md).
```
{
"openapi" : "3.0.1",
"info" : {
"title" : "Simple PetStore (OpenAPI)",
"description" : "Demo API created using OpenAPI",
"version" : "2024-05-24T20:39:34Z"
},
"servers" : [ {
"url" : "{basePath}",
"variables" : {
"basePath" : {
"default" : "Prod"
}
}
} ],
"paths" : {
"/pets" : {
"get" : {
"responses" : {
"200" : {
"description" : "200 response",
"content" : { }
}
},
"x-amazon-apigateway-integration" : {
"type" : "http",
"httpMethod" : "GET",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"passthroughBehavior" : "when_no_match",
"timeoutInMillis" : 29000
}
}
},
"/pets/{petId}" : {
"get" : {
"parameters" : [ {
"name" : "petId",
"in" : "path",
"required" : true,
"schema" : {
"type" : "string"
}
} ],
"responses" : {
"200" : {
"description" : "200 response",
"content" : { }
}
},
"x-amazon-apigateway-integration" : {
"type" : "http",
"httpMethod" : "GET",
"uri" : "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}",
"responses" : {
"default" : {
"statusCode" : "200"
}
},
"requestParameters" : {
"integration.request.path.id" : "method.request.path.petId"
},
"passthroughBehavior" : "when_no_match",
"timeoutInMillis" : 29000
}
}
}
},
"components" : { }
}
```
### Plantilla de AWS CloudFormation
Para implementar la plantilla de CloudFormation, consulte [Creación de una pila en la consola de AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-create-stack.html).
```
AWSTemplateFormatVersion: 2010-09-09
Resources:
Api:
Type: 'AWS::ApiGateway::RestApi'
Properties:
Name: Simple PetStore (AWS CloudFormation)
PetsResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !GetAtt Api.RootResourceId
PathPart: 'pets'
PetIdResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !Ref PetsResource
PathPart: '{petId}'
PetsMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetsResource
HttpMethod: GET
AuthorizationType: NONE
Integration:
Type: HTTP
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/
IntegrationResponses:
- StatusCode: '200'
MethodResponses:
- StatusCode: '200'
PetIdMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetIdResource
HttpMethod: GET
AuthorizationType: NONE
RequestParameters:
method.request.path.petId: true
Integration:
Type: HTTP
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}
RequestParameters:
integration.request.path.id: method.request.path.petId
IntegrationResponses:
- StatusCode: '200'
MethodResponses:
- StatusCode: '200'
ApiDeployment:
Type: 'AWS::ApiGateway::Deployment'
DependsOn:
- PetsMethodGet
Properties:
RestApiId: !Ref Api
StageName: Prod
Outputs:
ApiRootUrl:
Description: Root Url of the API
Value: !Sub 'https://${Api}.execute-api.${AWS::Region}.amazonaws.com/Prod'
```
### Configuración de Terraform
Para obtener más información sobre Terraform, consulte [Terraform](https://developer.hashicorp.com/terraform/intro).
```
provider "aws" {
region = "us-east-1" # Update with your desired region
}
resource "aws_api_gateway_rest_api" "Api" {
name = "Simple PetStore (Terraform)"
description = "Demo API created using Terraform"
}
resource "aws_api_gateway_resource" "petsResource"{
rest_api_id = aws_api_gateway_rest_api.Api.id
parent_id = aws_api_gateway_rest_api.Api.root_resource_id
path_part = "pets"
}
resource "aws_api_gateway_resource" "petIdResource"{
rest_api_id = aws_api_gateway_rest_api.Api.id
parent_id = aws_api_gateway_resource.petsResource.id
path_part = "{petId}"
}
resource "aws_api_gateway_method" "petsMethodGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = "GET"
authorization = "NONE"
}
resource "aws_api_gateway_method_response" "petsMethodResponseGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
status_code ="200"
}
resource "aws_api_gateway_integration" "petsIntegration" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
type = "HTTP"
uri = "http://petstore-demo-endpoint.execute-api.com/petstore/pets"
integration_http_method = "GET"
depends_on = [aws_api_gateway_method.petsMethodGet]
}
resource "aws_api_gateway_integration_response" "petsIntegrationResponse" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petsResource.id
http_method = aws_api_gateway_method.petsMethodGet.http_method
status_code = aws_api_gateway_method_response.petsMethodResponseGet.status_code
}
resource "aws_api_gateway_method" "petIdMethodGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = "GET"
authorization = "NONE"
request_parameters = {"method.request.path.petId" = true}
}
resource "aws_api_gateway_method_response" "petIdMethodResponseGet" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
status_code ="200"
}
resource "aws_api_gateway_integration" "petIdIntegration" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
type = "HTTP"
uri = "http://petstore-demo-endpoint.execute-api.com/petstore/pets/{id}"
integration_http_method = "GET"
request_parameters = {"integration.request.path.id" = "method.request.path.petId"}
depends_on = [aws_api_gateway_method.petIdMethodGet]
}
resource "aws_api_gateway_integration_response" "petIdIntegrationResponse" {
rest_api_id = aws_api_gateway_rest_api.Api.id
resource_id = aws_api_gateway_resource.petIdResource.id
http_method = aws_api_gateway_method.petIdMethodGet.http_method
status_code = aws_api_gateway_method_response.petIdMethodResponseGet.status_code
}
resource "aws_api_gateway_deployment" "Deployment" {
rest_api_id = aws_api_gateway_rest_api.Api.id
depends_on = [aws_api_gateway_integration.petsIntegration,aws_api_gateway_integration.petIdIntegration ]
}
resource "aws_api_gateway_stage" "Stage" {
stage_name = "Prod"
rest_api_id = aws_api_gateway_rest_api.Api.id
deployment_id = aws_api_gateway_deployment.Deployment.id
}
```
# Tutorial: Creación de una API de 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.
Este tutorial tarda aproximadamente 30 minutos en completarse. En primer lugar, utilice una plantilla de 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 Consola de administración de AWS 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.
![\[Información general de la API privada creada en este tutorial.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/private-api-tutorial-diagram.png)
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 [Configuración para usar API Gateway](setting-up.md).
En este tutorial, se utiliza la Consola de administración de AWS. Para obtener una plantilla de CloudFormation que cree esta API y todos los recursos relacionados, consulte [template.yaml](samples/private-api-full-template.zip).
**Topics**
+ [Paso 1: crear dependencias](#private-api-tutorial-create-dependencies)
+ [Paso 2: crear una API privada](#private-api-tutorial-create-api)
+ [Paso 3: crear un método e integración](#private-api-tutorial-create-method)
+ [Paso 4: adjuntar una política de recursos](#private-api-tutorial-attach-resource-policy)
+ [Paso 5: implemente su API](#private-api-tutorial-deploy-api)
+ [Paso 6: compruebe que su API no sea accesible públicamente](#private-api-tutorial-test-private-api)
+ [Paso 7: conéctese a una instancia de su VPC e invoque su API](#private-api-tutorial-connect-to-instance)
+ [Paso 8: Eliminar](#private-api-tutorial-cleanup)
+ [Próximos pasos: automatice con CloudFormation](#private-api-tutorial-next-steps)
## Paso 1: crear dependencias
Descargue y descomprima [esta plantilla de CloudFormation](samples/private-api-starter-template.zip). 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 CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione **Create stack (Crear pila)** y, a continuación, seleccione **With new resources (standard) (Con nuevos recursos [estándar])**.
1. En **Specify template (Especificar plantilla)**, elija **Upload a template file (Cargar un archivo de plantilla)**.
1. Seleccione la plantilla que ha descargado.
1. Elija **Next (Siguiente)**.
1. En **Stack name (Nombre de pila)**, escriba **private-api-tutorial** y, a continuación, elija **Next (Siguiente)**.
1. En **Configure stack options (Configurar opciones de pila)**, elija **Next (Siguiente)**.
1. Para **Capabilities** (Capacidades), sepa que CloudFormation puede crear recursos de IAM en su cuenta.
1. Elija **Siguiente** y, a continuación, elija **Enviar**.
CloudFormation aprovisiona las dependencias para su API. Puede tardar unos minutos. Cuando el estado de la pila de CloudFormation sea **CREATE\$1COMPLETE**, 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](https://console.aws.amazon.com/apigateway).
1. Seleccione **Create API (Crear API)**y, a continuación, para **API REST**, seleccione **Build (Construir)**.
1. En **API name (Nombre de la API)**, escriba**private-api-tutorial**.
1. En **Tipo de punto de conexión de la API**, seleccione **Privado**.
1. 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 CloudFormation.
1. Para **Tipo de dirección IP**, elija **Dualstack**.
1. Seleccione **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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Elija **Crear método**.
1. En **Tipo de método**, seleccione `GET`.
1. En **Tipo de integración**, seleccione **Función de Lambda**.
1. 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.
1. En la **Lambda function** (Función de Lambda), elija la función que creó con la plantilla de CloudFormation en el paso 1. El nombre de la función comienza con **private-api-tutorial**.
1. Elija **Crear método**.
## Paso 4: adjuntar una política de recursos
Adjuntar una [política de recursos](apigateway-resource-policies.md) 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](apigateway-vpc-endpoint-policies.md) 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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Elija **Política de recursos** y, a continuación, elija **Crear política**.
1. 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 CloudFormation.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": "execute-api:/*",
"Condition": {
"StringNotEquals": {
"aws:sourceVpce": "vpce-abcd1234"
}
}
},
{
"Effect": "Allow",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": "execute-api:/*"
}
]
}
```
------
1. Seleccione **Save changes (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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Elija **Implementar API**.
1. En **Etapa**, seleccione **Nueva etapa**.
1. En **Stage name (Nombre de etapa)**, escriba **test**.
1. (Opcional) En **Description (Descripción)**, introduzca una descripción.
1. 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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. En el panel de navegación principal, elija **Etapas** y, a continuación, elija la etapa **test**.
1. 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.
1. 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.
**Para probar la API**
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Elija **Instances**.
1. Elija la instancia denominada **private-api-tutorial** que creó con la plantilla de CloudFormation en el paso 1.
1. Elija **Connect (Conectar)** y, a continuación, elija **Session Manager (Administrador de sesiones)**.
1. Elija **Connect (Conectar)** para iniciar una sesión basada en explorador en la instancia.
1. 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!`.
![\[Utilice el Session Manager para invocar la API desde su VPC de Amazon VPC.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/private-api-tutorial-invoke.png)
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 CloudFormation.
**Para eliminar una API REST**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. 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 CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione su pila de CloudFormation.
1. Elija **Delete (Eliminar)** y, a continuación, confirme su elección.
## Próximos pasos: automatice con CloudFormation
Puede automatizar la creación y la limpieza de todos los recursos de AWS involucrados en este tutorial. Para obtener una plantilla de CloudFormation de ejemplo completa, consulte [template.yaml](samples/private-api-full-template.zip).
# 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.
**Topics**
+ [Tutorial: Creación de una API de HTTP CRUD con Lambda y DynamoDB](http-api-dynamo-db.md)
+ [Tutorial: Creación de una API de HTTP con una integración privada en un servicio de Amazon ECS](http-api-private-integration.md)
# Tutorial: Creación de una API de HTTP 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](https://aws.amazon.com/free/).
En primer lugar, se crea una tabla [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) utilizando la consola de DynamoDB. Luego, se crea una función de [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) 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.
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.
![\[Información general de la API HTTP creada en este tutorial.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ddb-crud.png)
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 [Configuración para usar API Gateway](setting-up.md).
En este tutorial, se utiliza la Consola de administración de AWS. Para obtener una plantilla de AWS SAM que cree esta API y todos los recursos relacionados, consulte [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).
**Topics**
+ [Paso 1: crear una tabla de DynamoDB](#http-api-dynamo-db-create-table)
+ [Paso 2: crear una función Lambda](#http-api-dynamo-db-create-function)
+ [Paso 3: crear una API HTTP](#http-api-dynamo-db-create-api)
+ [Paso 4: crear rutas](#http-api-dynamo-db-create-routes)
+ [Paso 5: crear una integración](#http-api-dynamo-db-create-integration)
+ [Paso 6: conectar la integración a las rutas](#http-api-dynamo-db-attach-integrations)
+ [Paso 7: probar la API](#http-api-dynamo-db-invoke-api)
+ [Paso 8: Eliminar](#http-api-dynamo-db-cleanup)
+ [Pasos siguientes: automatización con AWS SAM o CloudFormation](#http-api-dynamo-db-next-steps)
## Paso 1: crear una tabla de DynamoDB
Se utiliza una tabla [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html) para almacenar datos para la API.
Cada elemento tiene un ID único, que usamos como [clave de partición](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) para la tabla.
**Cree una tabla de DynamoDB**
1. Abra la consola de DynamoDB en [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/).
1. Seleccione **Create table**.
1. En **Nombre de la tabla**, introduzca **http-crud-tutorial-items**.
1. En **Partition key** (Clave de partición), ingrese **id**.
1. Seleccione **Create table (Creación de tabla)**.
## Paso 2: crear una función Lambda
Se crea una función [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) 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](http-api-develop-integrations-lambda.md#http-api-develop-integrations-lambda.proxy-format) 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 obtener más información sobre Lambda, consulte [The Lambda monolith](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith) (El monolito de Lambda).
**Cómo crear una función de Lambda**
1. Inicie sesión en la consola de Lambda en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda).
1. Elija **Create function (Crear función)**.
1. En **Function name (Nombre de función)**, introduzca **http-crud-tutorial-function**.
1. En **Tiempo de ejecución**, elija el último tiempo de ejecución de **Node.js** o **Python** compatible.
1. En **Permisos**, seleccione **Cambiar el rol de ejecución predeterminado**.
1. Seleccione **Create a new role from AWS policy templates** (Crear un nuevo rol en plantillas de políticas de AWS).
1. En **Nombre del rol**, introduzca **http-crud-tutorial-role**.
1. En **Plantillas de políticas**, seleccione **Simple microservice permissions**. Esta política concede a la función Lambda permiso para interactuar con DynamoDB.
**nota**
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.
1. Elija **Create function (Crear función)**.
1. Abra la función de Lambda en el editor de código de la consola y sustituya su contenido con el siguiente código. Seleccione **Implementar** para actualizar la función.
------
#### [ Node.js ]
```
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
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;
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,
};
};
```
------
#### [ Python ]
```
import json
import boto3
from decimal import Decimal
client = boto3.client('dynamodb')
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table('http-crud-tutorial-items')
tableName = 'http-crud-tutorial-items'
def lambda_handler(event, context):
print(event)
body = {}
statusCode = 200
headers = {
"Content-Type": "application/json"
}
try:
if event['routeKey'] == "DELETE /items/{id}":
table.delete_item(
Key={'id': event['pathParameters']['id']})
body = 'Deleted item ' + event['pathParameters']['id']
elif event['routeKey'] == "GET /items/{id}":
body = table.get_item(
Key={'id': event['pathParameters']['id']})
body = body["Item"]
responseBody = [
{'price': float(body['price']), 'id': body['id'], 'name': body['name']}]
body = responseBody
elif event['routeKey'] == "GET /items":
body = table.scan()
body = body["Items"]
print("ITEMS----")
print(body)
responseBody = []
for items in body:
responseItems = [
{'price': float(items['price']), 'id': items['id'], 'name': items['name']}]
responseBody.append(responseItems)
body = responseBody
elif event['routeKey'] == "PUT /items":
requestJSON = json.loads(event['body'])
table.put_item(
Item={
'id': requestJSON['id'],
'price': Decimal(str(requestJSON['price'])),
'name': requestJSON['name']
})
body = 'Put item ' + requestJSON['id']
except KeyError:
statusCode = 400
body = 'Unsupported route: ' + event['routeKey']
body = json.dumps(body)
res = {
"statusCode": statusCode,
"headers": {
"Content-Type": "application/json"
},
"body": body
}
return res
```
------
## 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.
**Para crear una API HTTP**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Seleccione **Crear API**y, a continuación, para **API HTTP**, seleccione **Crear**.
1. En **API name (Nombre de la API)**, escriba**http-crud-tutorial-api**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Elija **Next (Siguiente)**.
1. En **Configurar rutas**, seleccione **Siguiente** para omitir la creación de rutas. Se crearán rutas más adelante.
1. Revise la etapa que API Gateway crea y, a continuación, seleccione **Siguiente**.
1. 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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Elija **Routes (Rutas)**.
1. Seleccione **Create (Crear)**.
1. En **Method (Método)**, seleccione **GET**.
1. En la ruta de acceso, introduzca **/items/\$1id\$1**. 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.
1. Seleccione **Create (Crear)**.
1. Repita los pasos 4 a 7 para `GET /items`, `DELETE /items/{id}`, y `PUT /items`.
![\[La API tiene rutas para GET /items, GET /items/{id}, DELETE /items/{id} y PUT /items.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ddb-create-routes.png)
## 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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Seleccione **Integraciones**.
1. Seleccione **Administrar integraciones** y, a continuación, seleccione **Crear**.
1. Omitir **Conectar esta integración a una ruta**. Esta etapa se completará más adelante.
1. En **Tipo de integración**, seleccione **Función Lambda**.
1. En **Función Lambda**, introduzca **http-crud-tutorial-function**.
1. Seleccione **Create (Crear)**.
## 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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Seleccione **Integraciones**.
1. Seleccione una ruta.
1. En **Elegir una integración existente**, seleccione **http-crud-tutorial-function**.
1. Seleccione **Conectar integración**.
1. Repita los pasos 4 a 6 para todas las rutas.
Todas las rutas muestran que se adjuntó una integración de AWS Lambda.
![\[La consola muestra a AWS Lambda en todas las rutas para indicar que la integración se adjuntó.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ddb-attach-integrations.png)
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](https://curl.se).
**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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Tenga en cuenta la URL de invocación de la API. Aparece en **Invocar URL** en la página **Detalles**.
![\[Después de crear la API, la consola muestra la URL de invocación de la API.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ddb-invoke-url.png)
1. 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.
```
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
```
1. 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/](https://console.aws.amazon.com/dynamodb/).
1. Seleccionar la tabla.
1. Elija **Delete table (Eliminar tabla)**.
1. 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](https://console.aws.amazon.com/apigateway).
1. En la página **API**, seleccione una API. Seleccione **Actions** y, luego, **Delete**.
1. 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/](https://console.aws.amazon.com/lambda).
1. En la página **Functions** (Funciones), seleccione una función. Seleccione **Actions** y, luego, **Delete**.
1. 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](https://console.aws.amazon.com/cloudwatch/home#logs:).
1. 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)**.
1. 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](https://console.aws.amazon.com/iam/home?#/roles) (Roles).
1. Seleccione el rol de la función, por ejempl, `http-crud-tutorial-role`.
1. Elija **Delete role (Eliminar rol)**.
1. Elija **Sí, eliminar**.
## Pasos siguientes: automatización con AWS SAM o CloudFormation
Puede automatizar la creación y la limpieza de los recursos de AWS mediante el uso de CloudFormation o AWS SAM. Para obtener un ejemplo de plantilla de AWS SAM para este tutorial, consulte [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).
Para obtener plantillas de CloudFormation de ejemplo, consulte las [plantillas de CloudFormation de ejemplo](https://github.com/awsdocs/amazon-api-gateway-developer-guide/tree/main/cloudformation-templates).
# Tutorial: Creación de una API de HTTP con una integración privada en un servicio de 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 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.
![\[Información general de la API HTTP creada en este tutorial.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/private-integration.png)
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 [Configuración para usar API Gateway](setting-up.md).
En este tutorial, se utiliza la Consola de administración de AWS. Para obtener una plantilla de CloudFormation que cree esta API y todos los recursos relacionados, consulte [template.yaml](samples/private-integration-full-template.zip).
**Topics**
+ [Paso 1: crear un Servicio Amazon ECS](#http-api-private-integration-create-ecs-service)
+ [Paso 2: crear un enlace de VPC](#http-api-private-integration-vpc-link)
+ [Paso 3: crear una API HTTP](#http-api-private-integration-create-api)
+ [Paso 4: creación de una ruta](#http-api-private-integration-create-routes)
+ [Paso 5: crear una integración](#http-api-private-integration-create-integration)
+ [Paso 6: probar la API](#http-api-private-integration-invoke-api)
+ [Paso 7: Limpieza](#http-api-private-integration-cleanup)
+ [Próximos pasos: automatice con CloudFormation](#http-api-private-integration-next-steps)
## 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 CloudFormation](samples/private-integration-cfn.zip) 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 CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione **Create stack (Crear pila)** y, a continuación, seleccione **With new resources (standard) (Con nuevos recursos [estándar])**.
1. En **Specify template (Especificar plantilla)**, elija **Upload a template file (Cargar un archivo de plantilla)**.
1. Seleccione la plantilla que ha descargado.
1. Elija **Next (Siguiente)**.
1. En **Stack name (Nombre de pila)**, escriba **http-api-private-integrations-tutorial** y, a continuación, elija **Next (Siguiente)**.
1. En **Configure stack options (Configurar opciones de pila)**, elija **Next (Siguiente)**.
1. Para **Capabilities** (Capacidades), sepa que CloudFormation puede crear recursos de IAM en su cuenta.
1. Elija **Siguiente** y, a continuación, elija **Enviar**.
CloudFormation aprovisiona al Servicio ECS. Puede tardar unos minutos. Cuando el estado de la pila de CloudFormation sea **CREATE\$1COMPLETE**, 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](https://console.aws.amazon.com/apigateway).
1. En el panel de navegación principal, elija **Enlaces de VPC** y, a continuación, elija **Crear**.
Es posible que necesite elegir el icono del menú para abrir el panel de navegación principal.
1. 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)**.
1. En **Name (Nombre)** escriba **private-integrations-tutorial**.
1. En **VPC**, elija la VPC que ha creado en el paso 1. El nombre debe comenzar con **PrivateIntegrationsStack**.
1. En **Subnets (Subredes)**, seleccione las dos subredes privadas de la VPC. Los nombres terminan en `PrivateSubnet`.
1. Para **Grupos de seguridad**, seleccione el ID de grupo que comience por `private-integrations-tutorial` y tenga la descripción `PrivateIntegrationsStack/PrivateIntegrationsTutorialService/Service/SecurityGroup`.
1. 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.
**Para crear una API HTTP**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Seleccione **Crear API**y, a continuación, para **API HTTP**, seleccione **Crear**.
1. En **API name (Nombre de la API)**, escriba**http-private-integrations-tutorial**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. Elija **Next (Siguiente)**.
1. En **Configurar rutas**, seleccione **Siguiente** para omitir la creación de rutas. Se crearán rutas más adelante.
1. 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)**.
1. 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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Elija **Routes (Rutas)**.
1. Seleccione **Create (Crear)**.
1. En **Method (Método)**, seleccione **ANY**.
1. En la ruta de acceso, introduzca **/\$1proxy\$1\$1**. 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.
1. Seleccione **Create (Crear)**.
## Paso 5: crear una integración
Se crea una integración para conectar una ruta a los recursos de backend.
**Para crear una integración**
1. Inicie sesión en la consola de API Gateway en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Seleccione **Integraciones**.
1. Seleccione **Administrar integraciones** y, a continuación, seleccione **Crear**.
1. En **Atach this intergration to a route (Adjuntar esta integración a una ruta)**, seleccione la ruta **ANY/\$1proxy\$1\$1** que creó anteriormente.
1. En **Integration type (Tipo de integración)**, elija **Private resource (Recurso privado)**.
1. En **Integration details (Detalles de integración)**, elija **Select manually (Seleccionar manualmente)**.
1. En **Target service (Servicio de destino)**, seleccione **ALB/NLB**.
1. En **Load balancer** (Equilibrador de carga), elija el equilibrador de carga que creó con la plantilla de CloudFormation en el paso 1. El nombre debería comenzar con **http-Priva**.
1. En **Listener (Agente de escucha)**, elija **HTTP 80**.
1. 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`.
1. 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.
![\[La consola muestra que tiene una ruta /{proxy+} con una integración a un balanceador de carga en una VPC.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/private-integration-tutorial-route.png)
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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Tenga en cuenta la URL de invocación de la API.
![\[Después de crear la API, la consola muestra la URL de invocación de la API.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/getting-started-invoke-url.png)
1. 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.
1. 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 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](https://console.aws.amazon.com/apigateway).
1. 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](https://console.aws.amazon.com/apigateway).
1. Elija **VPC link (Enlace de VPC)**.
1. Seleccione el enlace de VPC, elija **Delete (Eliminar)**y, a continuación, confirme su elección.
**Para eliminar una pila de CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione su pila de CloudFormation.
1. Elija **Delete (Eliminar)** y, a continuación, confirme su elección.
## Próximos pasos: automatice con CloudFormation
Puede automatizar la creación y la limpieza de todos los recursos de AWS involucrados en este tutorial. Para obtener una plantilla de CloudFormation de ejemplo completa, consulte [template.yaml](samples/private-integration-full-template.zip).
# Tutoriales de la API REST de Amazon API Gateway
Los siguientes tutoriales proporcionan un ejercicio práctico que le ayudará a obtener información sobre las API de WebSocket de API Gateway.
**Topics**
+ [Tutorial: Creación de una aplicación de chat de WebSocket con una API de WebSocket, Lambda y DynamoDB](websocket-api-chat-app.md)
+ [Tutorial: Creación de una API de WebSocket con una integración de AWS](websocket-api-step-functions-tutorial.md)
# Tutorial: Creación de una aplicación de chat de WebSocket 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 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.
![\[Descripción general de la arquitectura de la API creada en este tutorial.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ws-chat-app.png)
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 [Configuración para usar API Gateway](setting-up.md).
También es necesario `wscat` para conectarse a la API. Para obtener más información, consulte [Utilice `wscat` para conectarse y enviar mensajes a una API de WebSocket](apigateway-how-to-call-websocket-api-wscat.md).
**Topics**
+ [Paso 1: Crear funciones Lambda y una tabla de DynamoDB](#websocket-api-chat-app-create-dependencies)
+ [Paso 2: Crear una API de WebSocket](#websocket-api-chat-app-create-api)
+ [Paso 3: probar la API](#websocket-api-chat-app-invoke-api)
+ [Paso 4: Limpiar](#websocket-api-chat-app-cleanup)
+ [Próximos pasos: automatice con CloudFormation](#websocket-api-chat-app-next-steps)
## Paso 1: Crear funciones Lambda y una tabla de DynamoDB
Descargue y descomprima [la plantilla de creación de aplicaciones para CloudFormation](samples/ws-chat-app-starter.zip). 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 CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione **Create stack (Crear pila)** y, a continuación, seleccione **With new resources (standard) (Con nuevos recursos [estándar])**.
1. En **Specify template (Especificar plantilla)**, elija **Upload a template file (Cargar un archivo de plantilla)**.
1. Seleccione la plantilla que ha descargado.
1. Elija **Next (Siguiente)**.
1. En **Stack name (Nombre de pila)**, escriba **websocket-api-chat-app-tutorial** y, a continuación, elija **Next (Siguiente)**.
1. En **Configure stack options (Configurar opciones de pila)**, elija **Next (Siguiente)**.
1. Para **Capabilities** (Capacidades), sepa que CloudFormation puede crear recursos de IAM en su cuenta.
1. Elija **Siguiente** y, a continuación, elija **Enviar**.
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 CloudFormation sea **CREATE\$1COMPLETE**, estará listo para continuar con el paso siguiente.
## 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](https://console.aws.amazon.com/apigateway).
1. Seleccione **Crear API**. En **WebSocket API** (API de WebSocket), elija **Build** (Crear).
1. En **API name (Nombre de la API)**, escriba**websocket-chat-app-tutorial**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. 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.
1. Elija **Siguiente**.
1. Para **Predefined routes** (Rutas predefinidas), elija **Add \$1connect** (Agregar \$1connect), **Add \$1disconnect** (Agregar \$1disconnect) y **Add \$1default** (Agregar \$1default). Las rutas **\$1connect** y **\$1disconnect** 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.
1. 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.
1. Elija **Siguiente**.
1. 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 CloudFormation en el paso 1. El nombre de cada función coincide con una ruta. Por ejemplo, para la ruta **\$1connect**, elija la función denominada **websocket-chat-app-tutorial-ConnectHandler**.
1. 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).
1. Elija **Create and deploy** (Crear e implementar).
## 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](https://console.aws.amazon.com/apigateway).
1. Elija la API.
1. Elija **Stages** (Etapas) y, a continuación, elija **production** (producción).
1. 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)
```
1. 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.
**Cómo 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:
```
{"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 \$1default 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","connectionID":"Mg_ugfpqPHcCIVA="}
```
**Para desconectarse de la API**
+ Pulse **CTRL\$1C** 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 CloudFormation.
**Para eliminar una API de WebSocket**
1. Inicie sesión en la consola de API Gateway, en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. 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 CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione su pila de CloudFormation.
1. Elija **Delete (Eliminar)** y, a continuación, confirme su elección.
## Próximos pasos: automatice con CloudFormation
Puede automatizar la creación y la limpieza de todos los recursos de AWS involucrados en este tutorial. Para obtener una plantilla de CloudFormation que cree esta API y todos los recursos relacionados, consulte [ws-chat-app.yaml](samples/ws-chat-app.zip).
# Tutorial: Creación de una API de WebSocket con una integración de AWS
En este tutorial, se crea una aplicación de transmisión sin servidor con una API de WebSocket. Los clientes pueden recibir mensajes sin tener que sondear para comprobar si hay actualizaciones.
Este tutorial muestra cómo transmitir mensajes a los clientes conectados e incluye un ejemplo de un autorizador de Lambda, una integración simulada y una integración que no sea de proxy en Step Functions.
![\[Descripción general de la arquitectura de la API creada en este tutorial.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ws-sfn-app.png)
Una vez haya creado los recursos con una plantilla de CloudFormation, utilizará la consola de API Gateway para crear una API de WebSocket que se integre con los recursos de AWS. Adjuntará un autorizador de Lambda a la API y creará una integración de servicios de AWS con Step Functions para iniciar la ejecución de una máquina de estado. La máquina de estado de Step Functions invocará una función de Lambda que envía un mensaje a todos los clientes conectados.
Después de crear la API, probará la conexión a la API y verificará que se envían y reciben mensajes. Para completar este tutorial se necesita aproximadamente 45 minutos.
**Topics**
+ [Requisitos previos](#websocket-api-step-functions-prerequisites)
+ [Paso 1: Crear recursos](#websocket-api-step-functions-create-dependencies)
+ [Paso 2: Crear una API de WebSocket](#websocket-api-step-functions-create-api)
+ [Paso 3: Creación de un autorizador de Lambda](#websocket-api-step-functions-create-authorizer)
+ [Paso 4: Creación de una integración bidireccional simulada](#websocket-api-step-functions-create-mock-integration)
+ [Paso 5: Creación de una integración que no sea de proxy con Step Functions](#websocket-api-step-functions-create-step-function-integration)
+ [Paso 6: probar la API](#websocket-api-step-functions-test-api)
+ [Paso 7: limpiar](#websocket-api-step-functions-cleanup)
+ [Pasos a seguir a continuación](#websocket-api-step-functions-next-steps)
## Requisitos previos
Necesita los siguientes requisitos previos:
+ 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 [Configuración para usar API Gateway](setting-up.md).
+ `wscat` para conectarse a la API. Para obtener más información, consulte [Utilice `wscat` para conectarse y enviar mensajes a una API de WebSocket](apigateway-how-to-call-websocket-api-wscat.md).
Le recomendamos que complete el tutorial de la aplicación de chat de WebSocket antes de iniciar este tutorial. Para completar el tutorial de la aplicación de chat de WebSocket, consulte [Tutorial: Creación de una aplicación de chat de WebSocket con una API de WebSocket, Lambda y DynamoDB](websocket-api-chat-app.md).
## Paso 1: Crear recursos
Descargue y descomprima [la plantilla de creación de aplicaciones para CloudFormation](samples/ws-sfn-starter.zip). Usará esta plantilla para crear lo siguiente:
+ Funciones de Lambda que gestionan las solicitudes de la API y autorizan el acceso a la API.
+ Una tabla de DynamoDB para almacenar los ID de cliente y la identificación de usuario de entidad principal devuelta por el autorizador de Lambda.
+ Una máquina de estado de Step Functions para enviar mensajes a los clientes conectados.
**Para crear una pila de CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione **Create stack (Crear pila)** y, a continuación, seleccione **With new resources (standard) (Con nuevos recursos [estándar])**.
1. En **Specify template (Especificar plantilla)**, elija **Upload a template file (Cargar un archivo de plantilla)**.
1. Seleccione la plantilla que ha descargado.
1. Elija **Next (Siguiente)**.
1. En **Stack name (Nombre de pila)**, escriba **websocket-step-functions-tutorial** y, a continuación, elija **Next (Siguiente)**.
1. En **Configure stack options (Configurar opciones de pila)**, elija **Next (Siguiente)**.
1. Para **Capabilities** (Capacidades), sepa que CloudFormation puede crear recursos de IAM en su cuenta.
1. Elija **Siguiente** y, a continuación, elija **Enviar**.
CloudFormation aprovisiona los recursos especificados en la plantilla. Puede tardar varios minutos en finalizar el aprovisionamiento de los recursos. Elija la pestaña **Salidas** para ver los recursos creados y los ARN. Cuando el estado de la pila de CloudFormation sea **CREATE\$1COMPLETE**, estará listo para continuar con el paso siguiente.
## Paso 2: Crear una API de WebSocket
Creará una API de WebSocket para gestionar las conexiones de clientes y enrutar solicitudes a los recursos 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](https://console.aws.amazon.com/apigateway).
1. Seleccione **Crear API**. En **WebSocket API** (API de WebSocket), elija **Build** (Crear).
1. En **API name (Nombre de la API)**, escriba**websocket-step-functions-tutorial**.
1. En **Tipo de dirección IP**, seleccione **IPv4**.
1. 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.
1. Elija **Siguiente**.
1. Para **Rutas predefinidas**, elija **Agregar \$1connect**, **Agregar \$1disconnect** y **Agregar \$1default**.
Las rutas **\$1connect** y **\$1disconnect** 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 **\$1default** cuando ninguna otra ruta coincide con una solicitud. Creará una ruta personalizada para conectarse a Step Functions después de crear la API.
1. Elija **Siguiente**.
1. Para **Integración para \$1connect**, haga lo siguiente:
1. Para **Tipo de integración**, elija **Lambda**.
1. Para **Función de Lambda**, elija la función de Lambda **\$1connect** correspondiente que creó con CloudFormation en el paso 1. El nombre de la función de Lambda debe comenzar con **websocket-step**.
1. Para **Integración para \$1disconnect**, haga lo siguiente:
1. Para **Tipo de integración**, elija **Lambda**.
1. Para **Función de Lambda**, elija la función de Lambda **\$1disconnect** correspondiente que creó con CloudFormation en el paso 1. El nombre de la función de Lambda debe comenzar con **websocket-step**.
1. Para **Integración para \$1default**, elija **simulación**.
En una integración simulada, API Gateway administra la respuesta de la ruta sin un backend de integración.
1. Elija **Siguiente**.
1. Revise la etapa que API Gateway le crea. De forma predeterminada, API Gateway crea una etapa denominada **producción** e implementa automáticamente la API en esa etapa. Elija **Siguiente**.
1. Elija **Create and deploy** (Crear e implementar).
## Paso 3: Creación de un autorizador de Lambda
Para controlar el acceso a la API de WebSocket, debe crear un autorizador de Lambda. La plantilla de CloudFormation creó la función del autorizador de Lambda para usted. Puede ver la función de Lambda en la consola de Lambda. El nombre no debe comenzar por **websocket-step-functions-tutorial-AuthorizerHandler**. Esta función de Lambda deniega todas las llamadas a la API de WebSocket a menos que el encabezado de `Authorization` sea `Allow`. La función de Lambda también transfiere la variable `$context.authorizer.principalId` a la API, que luego se utiliza en la tabla de DynamoDB para identificar a los intermediarios de la API.
En este paso, debe configurar la ruta **\$1connect** para usar el autorizador de Lambda.
**Creación de un autorizador de Lambda**
1. Inicie sesión en la consola de API Gateway, en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. En el panel de navegación principal, elija **Autorizadores**.
1. Elija **Creación de un autorizador**.
1. Para **Nombre del autorizador**, ingrese **LambdaAuthorizer**.
1. Para **ARN de autorizador**, ingrese el nombre del autorizador creado por la plantilla de CloudFormation. El nombre no debe comenzar por **websocket-step-functions-tutorial-AuthorizerHandler**.
**nota**
Le recomendamos que no utilice este autorizador de ejemplo para las API de producción.
1. Para **Tipo de origen de identidad**, elija **Encabezado**. En **Clave**, escriba **Authorization**.
1. Elija **Crear autorizador**.
Después de crear el autorizador, debe adjuntarlo a la ruta **\$1connect** de la API.
**Asociación de un autorizador a la ruta de \$1connect**
1. En el panel de navegación principal, elija **Rutas**.
1. Elija la ruta **\$1connect**.
1. En la sección **Configuración de la solicitud de ruta**, elija **Editar**.
1. Para **Autorización**, elija el menú desplegable y, a continuación, seleccione el autorizador de solicitudes.
1. Seleccione **Save changes (Guardar cambios)**.
## Paso 4: Creación de una integración bidireccional simulada
A continuación, debe crear la integración simulada bidireccional para la ruta **\$1default**. Una integración simulada le permite enviar una respuesta al cliente sin usar un backend. Cuando crea una integración para la ruta **\$1default**, puede mostrar a los clientes cómo interactuar con la API.
Debe configurar la ruta **\$1default** para indicar a los clientes que usen la ruta **sendmessage**.
**Creación de una integración simulada**
1. Inicie sesión en la consola de API Gateway, en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Elija la ruta **\$1default** y, a continuación, elija la pestaña **Solicitud de integración**.
1. Para las **Plantillas de solicitud**, elija **Editar**.
1. Para **Expresión de selección de plantilla**, ingrese **200** y, a continuación, elija **Editar**.
1. En la pestaña **Solicitud de integración**, para **Plantillas de solicitud**, elija **Crear plantilla**.
1. Para **Clave de plantilla**, ingrese **200**.
1. Para **Generar plantilla**, ingrese la siguiente plantilla de asignación:
```
{"statusCode": 200}
```
Seleccione **Crear plantilla**.
El resultado debe ser similar a lo siguiente:
![\[Configuración de la solicitud de integración para una integración simulada para la ruta $default.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ws-sfn-mock-integration-request.png)
1. Para el panel de la **ruta \$1default**, elija **Habilitar la comunicación bidireccional**.
1. Elija la pestaña **Respuesta de integración** y, a continuación, elija **Creación de respuesta de integración**.
1. Para **Clave de respuesta**, escriba **\$1default**.
1. Para **Expresión de selección de plantillas**, ingrese **200**.
1. Elija **Crear respuesta**.
1. En **Plantillas de respuesta**, elija **Crear plantilla**.
1. Para **Clave de plantilla**, ingrese **200**.
1. Para **Plantilla de respuesta**, ingrese la siguiente plantilla de asignación:
```
{"Use the sendmessage route to send a message. Connection ID: $context.connectionId"}
```
1. Seleccione **Crear plantilla**.
El resultado debe ser similar a lo siguiente:
![\[Configuración de respuesta de integración para una integración simulada para la ruta $default.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ws-sfn-mock-integration-response.png)
## Paso 5: Creación de una integración que no sea de proxy con Step Functions
A continuación, debe crear una ruta **sendmessage**. Los clientes pueden invocar la ruta **sendmessage** para transmitir un mensaje a todos los clientes conectados. La ruta **sendmessage** tiene una integración de servicio de AWS que no es de proxy con AWS Step Functions. La integración invoca el comando [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html) para la máquina de estado de Step Functions que la plantilla de CloudFormation creó para usted.
**Creación de una integración que no sea de proxy**
1. Inicie sesión en la consola de API Gateway, en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. Elija **Create route (Crear ruta)**.
1. Para **Route key** (Clave de ruta), ingrese **sendmessage**.
1. En **Tipo de integración**, seleccione **Servicio de AWS**.
1. Para **Región de AWS**, ingrese la región en la que implementó la plantilla de CloudFormation.
1. Para **Servicio de AWS**, elija **Step Functions**.
1. En **Método HTTP**, elija **POST**.
1. En **Nombre de la función**, introduzca **StartExecution**.
1. Para **Rol de ejecución**, ingrese el rol de ejecución creado por la plantilla de CloudFormation. El nombre debe ser **WebsocketTutorialApiRole**.
1. Elija **Create route (Crear ruta)**.
A continuación, debe crear una plantilla de asignación para enviar los parámetros de la solicitud a la máquina de estado de Step Functions.
**Para crear una plantilla de mapeo**
1. Elija la ruta **sendmessage** y, a continuación, elija la pestaña **Solicitud de integración**.
1. En la sección **Plantillas de solicitud**, elija **Editar**.
1. Para **Expresión de selección de plantillas**, ingrese **\$1\$1default**.
1. Seleccione **Editar**.
1. En la sección **Plantillas de solicitud**, elija **Crear plantilla**.
1. Para **Clave de plantilla**, ingrese **\$1\$1default**.
1. Para **Generar plantilla**, ingrese la siguiente plantilla de asignación:
```
#set($domain = "$context.domainName")
#set($stage = "$context.stage")
#set($body = $input.json('$'))
#set($getMessage = $util.parseJson($body))
#set($mymessage = $getMessage.message)
{
"input": "{\"domain\": \"$domain\", \"stage\": \"$stage\", \"message\": \"$mymessage\"}",
"stateMachineArn": "arn:aws:states:us-east-2:123456789012:stateMachine:WebSocket-Tutorial-StateMachine"
}
```
Sustituya *stateMachineArn* por el ARN de la máquina de estado creada por CloudFormation.
La plantilla de asignación hace lo siguiente:
+ Crea la variable `$domain` mediante la variable de contexto `domainName`.
+ Crea la variable `$stage` mediante la variable de contexto `stage`.
Las variables `$domain` y `$stage` son necesarias para crear una URL de devolución de llamada.
+ Toma el mensaje JSON `sendmessage` entrante y extrae la propiedad de `message`.
+ Crea la entrada de la máquina de estado. La entrada es el dominio y la etapa de la API de WebSocket y el mensaje de la ruta `sendmessage`.
1. Seleccione **Crear plantilla**.
![\[configuración de ruta sendmessage.\]](http://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/images/ws-sfn-integration-request.png)
Puede crear una integración que no sea de proxy en las rutas **\$1connect** o **\$1disconnect**, para agregar o eliminar directamente un ID de conexión de la tabla de DynamoDB, sin invocar una función de Lambda.
## Paso 6: probar la API
A continuación, implementará y probará la API para asegurarse de que funciona correctamente. Utilizará el comando `wscat` para conectarse a la API y, a continuación, utilizará un comando de barra inclinada para enviar un marco de ping para comprobar la conexión a la API de WebSocket.
**Para implementar su API**
1. Inicie sesión en la consola de API Gateway, en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. En el panel de navegación principal, elija **Rutas**.
1. Elija **Implementar API**.
1. Para **Etapa**, elija **producción**.
1. (Opcional) Para **Descripción de implementación**, ingrese una descripción.
1. Elija **Implementar**.
Después de implementar la API, puede invocarla. Use la URL de invocación para llamar a la API.
**Obtención de la URL de invocación para la API**
1. Elija la API.
1. Elija **Stages** (Etapas) y, a continuación, elija **production** (producción).
1. 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`.
Ahora que tiene la URL de invocación, puede probar la conexión a la API de WebSocket.
**Prueba de la conexión a la API**
1. Para conectarse a la API, utilice el siguiente comando. En primer lugar, se prueba la conexión invocando la ruta de `/ping`.
```
wscat -c wss://abcdef123.execute-api.us-east-2.amazonaws.com/production -H "Authorization: Allow" --slash -P
```
```
Connected (press CTRL+C to quit)
```
1. Ingrese el siguiente comando para hacer ping al marco de control. Puede utilizar un marco de control para keepalive los fines del cliente.
```
/ping
```
El resultado debe ser similar a lo siguiente:
```
< Received pong (data: "")
```
Ahora que ha probado la conexión, se puede probar que la API funciona correctamente. En este paso, se abre una nueva ventana de terminal para que la API de WebSocket pueda enviar un mensaje a todos los clientes conectados.
**Para probar la API**
1. Abra un nuevo terminal y ejecute el comando `wscat` de nuevo con los siguientes parámetros.
```
wscat -c wss://abcdef123.execute-api.us-east-2.amazonaws.com/production -H "Authorization: Allow"
```
```
Connected (press CTRL+C to quit)
```
1. API Gateway determina qué ruta invocar en función de la expresión de selección de solicitud 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:
```
{"action": "sendmessage", "message": "hello, from Step Functions!"}
```
La máquina de estados de Step Functions asociada a la ruta invoca una función de Lambda con el mensaje y la URL de devolución de llamada. La función de Lambda llama a la API de administración de API Gateway y envía el mensaje a todos los clientes conectados. Todos los clientes reciben el siguiente mensaje:
```
< hello, from Step Functions!
```
Ahora que ha probado la API de WebSocket, puede desconectarse de la API.
**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 **\$1disconnect** de la API. La integración de Lambda para la ruta **\$1disconnect** de la API elimina el ID de conexión de DynamoDB.
## Paso 7: 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 CloudFormation.
**Para eliminar una API de WebSocket**
1. Inicie sesión en la consola de API Gateway, en [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).
1. En la página de las **API**, seleccione la **websocket-api**.
1. Elija **Action (Acciones)**, elija **Delete (Eliminar)**y, a continuación, confirme su elección.
**Para eliminar una pila de CloudFormation**
1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Seleccione su pila de CloudFormation.
1. Elija **Delete (Eliminar)** y, a continuación, confirme su elección.
## Pasos a seguir a continuación
Puede automatizar la creación y la limpieza de todos los recursos de AWS involucrados en este tutorial. Para ver un ejemplo de una plantilla de CloudFormation que automatiza estas acciones para este tutorial, consulte [ws-sfn.zip](samples/ws-sfn-complete.zip).