# Elección de un tutorial de integración de AWS Lambda
<a name="getting-started-with-lambda-integration"></a>

 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
<a name="api-gateway-create-api-as-simple-proxy-for-lambda"></a>

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
<a name="api-gateway-proxy-integration-create-lambda-backend"></a>

**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
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-build"></a>

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
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test"></a>

**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
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test-curl"></a>

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
<a name="getting-started-lambda-non-proxy-integration"></a>

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
<a name="getting-started-new-lambda"></a>

**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
<a name="getting-started-new-api"></a>

 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
<a name="getting-started-new-get"></a>

 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
<a name="getting-started-deploy-api"></a>

 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
<a name="getting-started-test"></a>

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
<a name="getting-started-clean-up"></a>

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
<a name="apigateway-cross-account-lambda-integrations"></a>

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
<a name="apigateway-cross-account-lambda-integrations-create-api"></a>

**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
<a name="apigateway-cross-account-lambda-integrations-create-lambda-function"></a>

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
<a name="apigateway-cross-account-lambda-integrations-create-integration2"></a>

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.