# Invocación de una función de Lambda mediante un punto de conexión de Amazon API Gateway
Puede crear una API web con un punto de enlace HTTP para la función Lambda utilizando Amazon API Gateway. API Gateway dispone de herramientas para crear y documentar API web que enrutan solicitudes HTTP a funciones de Lambda. Puede proteger el acceso a la API con controles de autenticación y autorización. Las API pueden atender el tráfico a través de Internet o estar accesibles exclusivamente en la VPC.
**sugerencia**
Lambda ofrece dos formas de invocar la función a través de un punto de conexión HTTP: API Gateway y URL de función de Lambda. Si no está seguro de cuál es el mejor método para el caso, consulte [Selección de un método para invocar una función de Lambda mediante una solicitud HTTP](apig-http-invoke-decision.md).
Los recursos de la API definen uno o varios métodos, como GET o POST. Los métodos tienen una integración que enruta las solicitudes a una función Lambda o a otro tipo de integración. Puede definir cada recurso y cada método de manera individual, o utilizar tipos de recursos y métodos especiales para que coincidan con todas las solicitudes que se ajustan a un patrón. Un [recurso proxy](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html) captura todas las rutas que hay debajo de un recurso. El método `ANY` captura todos los métodos HTTP.
**Topics**
+ [Elegir un tipo de API](#services-apigateway-apitypes)
+ [Adición de un punto de conexión a la función de Lambda](#apigateway-add)
+ [Integración de proxy](#apigateway-proxy)
+ [Formato de eventos](#apigateway-example-event)
+ [Formato de respuesta](#apigateway-types-transforms)
+ [Permisos](#apigateway-permissions)
+ [Aplicación de muestra](#services-apigateway-samples)
+ [Controlador de eventos de Powertools para AWS Lambda](#services-apigateway-powertools)
+ [Tutorial: Uso de Lambda con API Gateway](services-apigateway-tutorial.md)
+ [Manejo de los errores en Lambda con una API de API Gateway](services-apigateway-errors.md)
+ [Selección de un método para invocar una función de Lambda mediante una solicitud HTTP](apig-http-invoke-decision.md)
## Elegir un tipo de API
API Gateway admite tres tipos de API que invocan funciones de Lambda:
+ [API HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html): una API de RESTful ligera de baja latencia.
+ [API de REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html): una API de RESTful personalizable con gran variedad de características.
+ [API de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html): una API web que mantiene conexiones persistentes con clientes para una comunicación dúplex completa.
Las API HTTP y REST son API RESTful que procesan solicitudes HTTP y devuelven respuestas. Las API HTTP son más recientes y se construyen con la API de la versión 2 de API Gateway. Las siguientes características son nuevas en las API HTTP:
**Características de las API HTTP**
+ **Implementaciones automáticas**: cuando se modifican rutas o integraciones, los cambios se implementan automáticamente en etapas que tienen habilitada la implementación automática.
+ **Etapa predeterminada**: puede crear una etapa predeterminada (`$default`) para atender las solicitudes en la ruta raíz de la URL de la API. En las etapas con nombre asignado, debe incluir el nombre de la etapa al principio de la ruta.
+ **Configuración CORS**: puede configurar la API para agregar encabezados CORS a las respuestas salientes, en lugar de agregarlos en forma manual en el código de función.
Las API REST son las API RESTful clásicas que API Gateway admite desde su lanzamiento. En la actualidad, las API REST tienen más características de personalización, integración y administración.
**Características de las API REST**
+ **Tipos de integración**: las API REST son compatibles con las integraciones de Lambda personalizadas. Con una integración personalizada, puede enviar solo el cuerpo de la solicitud a la función o aplicar una plantilla de transformación al cuerpo de la solicitud antes de enviarla a la función.
+ **Control de acceso**: las API REST admiten más opciones de autenticación y autorización.
+ **Monitoreo y seguimiento**: la API REST admiten el seguimiento de AWS X-Ray y otras opciones de registro.
Para ver una comparativa detallada, consulte [Elección entre las API de REST y las API de HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vs-rest.html) en la *Guía para desarrolladores de API Gateway*.
Las API de WebSocket también usan la API de la versión 2 de API Gateway y admiten un conjunto de características similares. Utilice una API de WebSocket para las aplicaciones que se benefician de una conexión persistente entre el cliente y la API. Las API de WebSocket proporcionan comunicación dúplex completa, lo que significa que tanto el cliente como la API pueden enviar mensajes continuamente sin esperar una respuesta.
Las API HTTP admiten un formato de evento simplificado (versión 2.0). Para ver un ejemplo de un evento de una API de HTTP, consulte [Creación de integraciones proxy de AWS Lambda para la API de HTTP en API Gateway](https://docs.aws.amazon.com//apigateway/latest/developerguide/http-api-develop-integrations-lambda.html).
Para obtener más información, consulte [Creación de integraciones de proxy de AWS Lambda Lambda para las API de HTTP en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html).
## Adición de un punto de conexión a la función de Lambda
**Para agregar un punto de enlace público a la función de Lambda**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Elija una función.
1. En **Descripción general de la función**, elija **Agregar desencadenador**.
1. Seleccione **API Gateway**.
1. Seleccione **Create an API** (Crear una API) o **Use an existing API** (Usar una API existente).
1. **Nueva API:** Para **API type** (Tipo de API), elija **HTTP API** (API HTTP). Para obtener más información, consulte [Elegir un tipo de API](#services-apigateway-apitypes).
1. **API existente:** seleccione la API en la lista desplegable o ingrese el ID de API (p. ej., r3pmxmplak).
1. En **Security (Seguridad)**, elija **Open (Abrir)**.
1. Elija **Añadir**.
## Integración de proxy
Las API de API Gateway se componen de etapas, recursos, métodos e integraciones. La etapa y el recurso determinan la ruta del punto de enlace:
**Formato de la ruta de las API**
+ `/prod/`: etapa `prod` y recurso raíz.
+ `/prod/user`: etapa `prod` y recurso `user`.
+ `/dev/{proxy+}`: cualquier ruta de la etapa `dev`.
+ `/`: (API HTTP) etapa predeterminada y recurso raíz.
La integración de Lambda asigna una combinación de ruta y método HTTP a una función de Lambda. Puede configurar API Gateway para pasar el cuerpo de la solicitud HTTP tal cual (integración personalizada) o para encapsular el cuerpo de la solicitud en un documento que incluya toda la información de la solicitud, incluidos los encabezados, los recursos, la ruta y el método.
Para obtener más información, consulte [Integraciones de proxy de Lambda en API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html).
## Formato de eventos
Amazon API Gateway invoca la función [sincrónicamente](invocation-sync.md) con un evento que contiene una representación JSON de la solicitud HTTP. En las integraciones personalizadas, el evento es el cuerpo de la solicitud. En las integraciones de proxy, el evento tiene una estructura definida. Para ver un ejemplo de un evento de proxy de una API de REST de API Gateway, consulte [Formato de entrada de una función de Lambda para la integración de proxy](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format) en la *Guía para desarrolladores de API Gateway*.
## Formato de respuesta
API Gateway espera una respuesta de la función y transmite el resultado a la persona que llama. En las integraciones personalizadas, debe definir una respuesta de integración y una respuesta de método para convertir la salida de la función en una respuesta HTTP. En las integraciones de proxy, la función debe responder con una representación de la respuesta en un formato específico.
En el ejemplo siguiente, se muestra un objeto response de una función Node.js. El objeto response representa una respuesta HTTP correcta que contiene un documento JSON.
**Example index.mjs: objeto de respuesta de integración de proxy (Node.js).**
```
var response = {
"statusCode": 200,
"headers": {
"Content-Type": "application/json"
},
"isBase64Encoded": false,
"multiValueHeaders": {
"X-Custom-Header": ["My value", "My other value"],
},
"body": "{\n \"TotalCodeSize\": 104330022,\n \"FunctionCount\": 26\n}"
}
```
El tiempo de ejecución de Lambda serializa el objeto response en un archivo JSON y lo envía a la API. La API analiza la respuesta y la utiliza para crear una respuesta HTTP, que luego envía al cliente que realizó la solicitud original.
**Example Respuesta HTTP**
```
< HTTP/1.1 200 OK
< Content-Type: application/json
< Content-Length: 55
< Connection: keep-alive
< x-amzn-RequestId: 32998fea-xmpl-4268-8c72-16138d629356
< X-Custom-Header: My value
< X-Custom-Header: My other value
< X-Amzn-Trace-Id: Root=1-5e6aa925-ccecxmplbae116148e52f036
<
{
"TotalCodeSize": 104330022,
"FunctionCount": 26
}
```
## Permisos
Amazon API Gateway necesita permiso para invocar la función desde la [política basada en recursos](access-control-resource-based.md) de la función. Puede conceder permiso de invocación a toda una API o conceder acceso limitado a una etapa, un recurso o un método.
Cuando agrega una API a la función utilizando la consola de Lambda, la consola de API Gateway o una plantilla de AWS SAM, la política basada en recursos de la función se actualiza automáticamente. A continuación se muestra una política de función de ejemplo.
**Example política de funciones**
****
```
{
"Version":"2012-10-17",
"Id": "default",
"Statement": [
{
"Sid": "nodejs-apig-functiongetEndpointPermissionProd-BWDBXMPLXE2F",
"Effect": "Allow",
"Principal": {
"Service": "apigateway.amazonaws.com"
},
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-2:111122223333:function:nodejs-apig-function-1G3MXMPLXVXYI",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "111122223333"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:execute-api:us-east-2:111122223333:ktyvxmpls1/*/GET/"
}
}
}
]
}
```
Puede administrar manualmente los permisos de las políticas de funciones con las siguientes operaciones de API:
+ [AddPermission](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html)
+ [RemovePermission](https://docs.aws.amazon.com/lambda/latest/api/API_RemovePermission.html)
+ [GetPolicy](https://docs.aws.amazon.com/lambda/latest/api/API_GetPolicy.html)
Para conceder permiso de invocación a una API existente, utilice el comando `add-permission`. Ejemplo:
```
aws lambda add-permission \
--function-name my-function \
--statement-id apigateway-get --action lambda:InvokeFunction \
--principal apigateway.amazonaws.com \
--source-arn "arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET/"
```
Debería ver los siguientes datos de salida:
```
{
"Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"apigateway.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:us-east-2:123456789012:function:my-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET\"}}}"
}
```
**nota**
Si la función y la API se encuentran en Regiones de AWS diferentes, el identificador de región en el ARN del origen debe coincidir con la región de la función, no la región de la API. Cuando API Gateway invoca una función, utiliza el ARN de un recurso que se basa en el ARN de la API, pero que se ha modificado para que coincida con la región de la función.
El ARN de origen de este ejemplo concede permiso a una integración del método GET del recurso raíz en la etapa predeterminada de una API, con el ID `mnh1xmpli7`. Puede utilizar un asterisco en el ARN de origen para conceder permisos a varias etapas, métodos o recursos.
**Patrones de recursos**
+ `mnh1xmpli7/*/GET/*`: método GET de todos los recursos en todas las etapas.
+ `mnh1xmpli7/prod/ANY/user`: método ANY del recurso `user` en la etapa `prod`.
+ `mnh1xmpli7/*/*/*`: cualquier método de todos los recursos en todas las etapas.
Para obtener información detallada acerca de cómo ver la política y quitar instrucciones, consulte [Ver políticas de IAM basadas en recursos en Lambda](access-control-resource-based.md).
## Aplicación de muestra
La aplicación de muestra [API Gateway con Node.js](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig) incluye una función con una plantilla de SAM AWS SAM que crea una API de REST que tiene el seguimiento de AWS X-Ray habilitado. También incluye scripts para implementar, invocar la función, probar la API y limpiar.
## Controlador de eventos de Powertools para AWS Lambda
El controlador de eventos del kit de herramientas de Powertools para AWS Lambda proporciona enrutamiento, middleware, configuración CORS, generación de especificaciones de OpenAPI, validación de solicitudes, manejo de errores y otras características útiles durante la escritura de funciones de Lambda invocadas por un punto de conexión de una API Gateway (HTTP o REST). La utilidad de controlador de eventos está disponible para Python y TypeScript/JavaScript. Para obtener más información, consulte la [API de REST del controlador de eventos](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/) en la documentación de *Powertools para AWS Lambda (Python)* y la [API de HTTP del controlador de eventos](https://docs.aws.amazon.com/powertools/typescript/latest/features/event-handler/http/) en la documentación de *Powertools para AWS Lambda* (TypeScript).
### Python
```
from aws_lambda_powertools import Logger
from aws_lambda_powertools.event_handler import APIGatewayRestResolver
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing.lambda_context import LambdaContext
app = APIGatewayRestResolver()
logger = Logger()
@app.get("/healthz")
def ping():
return {"message": "health status ok"}
@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST)
def lambda_handler(event: dict, context: LambdaContext) -> dict:
return app.resolve(event, context)
```
### Typescript
```
import { Router } from '@aws-lambda-powertools/event-handler/experimental-rest';
import { Logger } from '@aws-lambda-powertools/logger';
import {
correlationPaths,
search,
} from '@aws-lambda-powertools/logger/correlationId';
import type { Context } from 'aws-lambda/handler';
const logger = new Logger({
correlationIdSearchFn: search,
});
const app = new Router({ logger });
app.get("/healthz", async () => {
return { message: "health status ok" };
});
export const handler = async (event: unknown, context: Context) => {
// You can continue using other utilities just as before
logger.addContext(context);
logger.setCorrelationId(event, correlationPaths.API_GATEWAY_REST);
return app.resolve(event, context);
};
```
# Tutorial: Uso de Lambda con API Gateway
En este tutorial, se crea una API de REST a través la cual invoca una función de Lambda mediante una solicitud HTTP. Su función de Lambda realizará operaciones de creación, lectura, actualización y eliminación (CRUD) en una tabla de DynamoDB. Se proporciona esta función a modo de demostración, pero aprenderá a configurar una API de REST de API Gateway que pueda invocar cualquier función de Lambda.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/APIG_tut_resources.png)
El uso de API Gateway proporciona a los usuarios un punto de conexión seguro en HTTP para invocar la función de Lambda y puede ayudar a gestionar grandes volúmenes de llamadas a su función al limitar el tráfico, validar y autorizar automáticamente las llamadas a la API. API Gateway también proporciona controles de seguridad flexibles mediante AWS Identity and Access Management (IAM) y Amazon Cognito. Esto resulta útil para los casos de uso en los que se requiere una autorización previa para las llamadas a la aplicación.
**sugerencia**
Lambda ofrece dos formas de invocar la función a través de un punto de conexión HTTP: API Gateway y URL de función de Lambda. Si no está seguro de cuál es el mejor método para el caso, consulte [Selección de un método para invocar una función de Lambda mediante una solicitud HTTP](apig-http-invoke-decision.md).
Para completar este tutorial, pasará por las siguientes etapas:
1. Cree y configure una función de Lambda en Python o Node.js para realizar operaciones en una tabla de DynamoDB.
1. Cree una API de REST en API Gateway para conectarse a la función de Lambda.
1. Cree una tabla de DynamoDB y pruébela con la función de Lambda en la consola.
1. Despliegue su API y pruebe la configuración completa con curl en una terminal.
Al completar estas etapas, aprenderá a utilizar API Gateway para crear un punto de conexión en HTTP que pueda invocar de forma segura una función de Lambda a cualquier escala. También aprenderá a implementar su API, a probarla en la consola y a enviar una solicitud HTTP mediante una terminal.
## Creación de una política de permisos
Para poder crear un [rol de ejecución](lambda-intro-execution-role.md) para la función de Lambda, primero debe crear una política de permisos que permita a la función acceder a los recursos de AWS necesarios. Para este tutorial, la política le permite a Lambda realizar operaciones de CRUD en una tabla de DynamoDB y escribir en Registros de Amazon CloudWatch.
**Para crear la política de**
1. Abra la página de [Policies (Políticas)](https://console.aws.amazon.com/iam/home#/policies) de la consola de IAM.
1. Seleccione **Crear política**.
1. Elija la pestaña **JSON** y pegue la siguiente política personalizada en el editor JSON.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Stmt1428341300017",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:UpdateItem"
],
"Effect": "Allow",
"Resource": "*"
},
{
"Sid": "",
"Resource": "*",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Effect": "Allow"
}
]
}
```
------
1. Elija **Siguiente: Etiquetas**.
1. Elija **Siguiente: Revisar**.
1. En **Review policy (Revisar política)**, para el **Name (Nombre)** de la política, ingrese **lambda-apigateway-policy**.
1. Elija **Crear política**.
## Creación de un rol de ejecución
Un [rol de ejecución](lambda-intro-execution-role.md) es un rol de AWS Identity and Access Management (IAM) que concede a la función de Lambda permiso para acceder a recursos y Servicios de AWS. Para permitir que la función realice operaciones en una tabla de DynamoDB, adjuntará la política de permisos que creó en el paso anterior.
**Para crear una función de ejecución y adjuntar su política de permisos personalizada**
1. Abra la [página Roles](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM.
1. Elija **Creación de rol**.
1. Para el tipo de entidad de confianza, seleccione **Servicio de AWS** y, para el caso de uso, elija **Lambda**.
1. Elija **Siguiente**.
1. En el cuadro de búsqueda de políticas, escriba **lambda-apigateway-policy**.
1. En los resultados de búsqueda, seleccione la política que ha creado (`lambda-apigateway-policy`), y luego **Next** (Siguiente).
1. En **Role details** (Detalles del rol), introduzca **lambda-apigateway-role** en **Role name** (Nombre del rol) y, luego, elija **Create role** (Crear rol).
## Crear la función de Lambda
1. Abra la [página Funciones](https://console.aws.amazon.com/lambda/home#/functions) de la consola de Lambda y elija **Crear función**.
1. Elija **Crear desde cero**.
1. En **Nombre de la función**, introduzca `LambdaFunctionOverHttps`.
1. En **tiempo de ejecución**, elija el tiempo de ejecución de Node.js o Python más reciente.
1. En **Permissions** (Permisos), expanda **Change default execution role**(Cambiar rol de ejecución predeterminado).
1. Elija **Usar un rol existente** y, a continuación, seleccione el rol **lambda-apigateway-role** que creó antes.
1. Seleccione **Creación de función**.
1. En el panel **Código de fuente**, sustituya el código predeterminado por el siguiente código de Node.js o Python.
------
#### [ Node.js ]
La configuración de la `region` debe coincidir con la Región de AWS en la que se implementa la función y se [crea la tabla de DynamoDB](#services-apigateway-tutorial-table).
**Example index.mjs**
```
import { DynamoDBDocumentClient, PutCommand, GetCommand,
UpdateCommand, DeleteCommand} from "@aws-sdk/lib-dynamodb";
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
const ddbClient = new DynamoDBClient({ region: "us-east-2" });
const ddbDocClient = DynamoDBDocumentClient.from(ddbClient);
// Define the name of the DDB table to perform the CRUD operations on
const tablename = "lambda-apigateway";
/**
* Provide an event that contains the following keys:
*
* - operation: one of 'create,' 'read,' 'update,' 'delete,' or 'echo'
* - payload: a JSON object containing the parameters for the table item
* to perform the operation on
*/
export const handler = async (event, context) => {
const operation = event.operation;
if (operation == 'echo'){
return(event.payload);
}
else {
event.payload.TableName = tablename;
let response;
switch (operation) {
case 'create':
response = await ddbDocClient.send(new PutCommand(event.payload));
break;
case 'read':
response = await ddbDocClient.send(new GetCommand(event.payload));
break;
case 'update':
response = ddbDocClient.send(new UpdateCommand(event.payload));
break;
case 'delete':
response = ddbDocClient.send(new DeleteCommand(event.payload));
break;
default:
response = 'Unknown operation: ${operation}';
}
console.log(response);
return response;
}
};
```
------
#### [ Python ]
**Example lambda\$1function.py**
```
import boto3
# Define the DynamoDB table that Lambda will connect to
table_name = "lambda-apigateway"
# Create the DynamoDB resource
dynamo = boto3.resource('dynamodb').Table(table_name)
# Define some functions to perform the CRUD operations
def create(payload):
return dynamo.put_item(Item=payload['Item'])
def read(payload):
return dynamo.get_item(Key=payload['Key'])
def update(payload):
return dynamo.update_item(**{k: payload[k] for k in ['Key', 'UpdateExpression',
'ExpressionAttributeNames', 'ExpressionAttributeValues'] if k in payload})
def delete(payload):
return dynamo.delete_item(Key=payload['Key'])
def echo(payload):
return payload
operations = {
'create': create,
'read': read,
'update': update,
'delete': delete,
'echo': echo,
}
def lambda_handler(event, context):
'''Provide an event that contains the following keys:
- operation: one of the operations in the operations dict below
- payload: a JSON object containing parameters to pass to the
operation being performed
'''
operation = event['operation']
payload = event['payload']
if operation in operations:
return operations[operation](payload)
else:
raise ValueError(f'Unrecognized operation "{operation}"')
```
------
**nota**
En este ejemplo, el nombre de la tabla de DynamoDB se define como una variable en el código de la función. En la aplicación real, la mejor práctica es pasar este parámetro como variable de entorno y evitar codificar el nombre de la tabla. Para obtener más información, consulte [Uso de variables de entorno de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html).
1. En la sección **IMPLEMENTAR** elija **Implementar** para actualizar el código de la función:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
## Prueba de la función
Antes de integrar la función con API Gateway, confirme que la ha implementado de forma correcta. Utilice la consola de Lambda para enviar un evento de prueba a su función.
1. En la página de la consola de Lambda para su función, seleccione la pestaña **Prueba**.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/test-tab.png)
1. Desplácese a la sección **Evento JSON** y sustituya el evento predeterminado con el siguiente. Este evento coincide con la estructura esperada por la función de Lambda.
```
{
"operation": "echo",
"payload": {
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
}
```
1. Seleccione **Probar**
1. En **Ejecutar la función: se realizó correctamente**, expanda **Detalles**. Debería ver la siguiente respuesta:
```
{
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
```
## Creación de una API REST mediante API Gateway
En este paso, crea la API de REST de API Gateway que utilizará para invocar la función de Lambda.
**Para crear la API**
1. Abra la [consola de API Gateway](https://console.aws.amazon.com/apigateway).
1. Seleccione **Create API (Crear API)**.
1. En el cuadro **REST API (API de REST)**, elija **Build (Crear)**.
1. En **Detalles de la API**, deje seleccionada la opción **Nueva API** y, en **Nombre de la API**, ingrese **DynamoDBOperations**.
1. Seleccione **Create API** (Crear API).
## Creación de un recurso en su API de REST.
Para agregar un método HTTP a su API, primero debe crear un recurso para que funcione ese método. Aquí, se crea el recurso para administrar la tabla de DynamoDB.
**Para crear el recurso**
1. En la [consola de puerta de enlace de la API](https://console.aws.amazon.com/apigateway), en la página **Recursos** de su API, seleccione **Crear recurso**.
1. En **Detalles del recurso**, ingrese el **nombre del recurso****DynamoDBManager**.
1. Elija **Create Resource (Crear recurso)**.
## Creación de un método HTTP POST.
En este paso, creará un método (`POST`) para su recurso `DynamoDBManager`. Debe vincular este método `POST` a la función de Lambda para que cuando el método reciba una solicitud HTTP, API Gateway invoca la función de Lambda.
**nota**
A los efectos de este tutorial, se utiliza un método HTTP (`POST`) para invocar una única función de Lambda que lleva a cabo todas las operaciones de la tabla de DynamoDB. En una aplicación real, la práctica recomendada es utilizar una función de Lambda y un método HTTP diferente para cada operación. Para obtener más información, consulte [The Lambda monolith](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith) en Serverless Land.
**Para crear el método POST**
1. En la página **Recursos** de su API, asegúrese de que el recurso `/DynamoDBManager` esté resaltado. A continuación, en el panel **Métodos**, seleccione **Crear método**.
1. En **Tipo de método**, elija **POST**.
1. En **Tipo de integración**, seleccione **función de Lambda**.
1. Para la **función de Lambda**, elija el nombre de recurso de Amazon (ARN) para la función (`LambdaFunctionOverHttps`).
1. Elija **Crear método**.
## Creación de una tabla de DynamoDB
Cree una tabla de DynamoDB vacía en la que la función de Lambda realizará operaciones CRUD.
**Creación de la tabla de DynamoDB**
1. Abra la [página Tables (Tablas) en la consola de DynamoDB](https://console.aws.amazon.com/dynamodbv2#tables).
1. Seleccione **Create table (Creación de tabla)**.
1. En **Table details (Detalles de la tabla)**, haga lo siguiente:
1. En **Nombre de la tabla**, introduzca **lambda-apigateway**.
1. En **Partition key (Clave de partición)**, ingrese **id** y mantenga el tipo de datos establecido como **String (Cadena)**.
1. En **Settings** (Configuración), mantenga los valores predeterminados en **Default settings** (Configuración predeterminada).
1. Seleccione **Create table (Creación de tabla)**.
## Pruebe la integración de API Gateway, Lambda y DynamoDB.
Ya está listo para probar la integración del método de API de API Gateway con la función de Lambda y la tabla de DynamoDB. Con la consola de API Gateway, envíe las solicitudes directamente a su método `POST` mediante la función de prueba de la consola. En este paso, primero use una operación `create` para agregar un nuevo elemento a la tabla de DynamoDB y, a continuación, use una operación `update` para modificar el elemento.
**Prueba 1: Crear un nuevo elemento en la tabla de DynamoDB**
1. En la [consola de API Gateway](https://console.aws.amazon.com/apigateway), elija su API (`DynamoDBOperations`).
1. Elija el método **POST** debajo del recurso `DynamoDBManager`.
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 **Método de prueba**, deje vacías **las cadenas de consulta** y **los encabezados**. En **Cuerpo de la solicitud**, pegue el siguiente JSON:
```
{
"operation": "create",
"payload": {
"Item": {
"id": "1234ABCD",
"number": 5
}
}
}
```
1. Seleccione **Probar**
Los resultados que se muestran al finalizar la prueba deben mostrar el estado `200`. Este código de estado indica que la operación `create` se ha realizado correctamente.
Para confirmarlo, verifique que ahora su tabla de DynamoDB contenga un nuevo elemento.
1. Abra la página [Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tablas) en la consola de DynamoDB y elija la tabla `lambda-apigateway`.
1. Elija **Explore table items** (Explorar elementos de la tabla). En el panel **Items returned** (Devolución de elementos), debería ver un elemento con el **id**`1234ABCD` y el **número** de `5`. Ejemplo:
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/items-returned.png)
**Prueba 2: Actualización del elemento de la tabla de DynamoDB**
1. En la [consola de la puerta de enlace de API](https://console.aws.amazon.com/apigateway), vuelva a la pestaña **Prueba** del método POST.
1. En **Método de prueba**, deje vacías **las cadenas de consulta** y **los encabezados**. En **Cuerpo de la solicitud**, pegue el siguiente JSON:
```
{
"operation": "update",
"payload": {
"Key": {
"id": "1234ABCD"
},
"UpdateExpression": "SET #num = :newNum",
"ExpressionAttributeNames": {
"#num": "number"
},
"ExpressionAttributeValues": {
":newNum": 10
}
}
}
```
1. Seleccione **Probar**
Los resultados que se muestran cuando finaliza la prueba deben mostrar el estado `200`. Este código de estado indica que la operación de `update` se ha realizado correctamente.
Para confirmarlo, compruebe que el elemento de la tabla de DynamoDB se haya modificado.
1. Abra la página [Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tablas) en la consola de DynamoDB y elija la tabla `lambda-apigateway`.
1. Elija **Explore table items** (Explorar elementos de la tabla). En el panel **Items returned** (Devolución de elementos), debería ver un elemento con el **id**`1234ABCD` y el **número** de `10`.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/items-returned-2.png)
## Implemente la API.
Para que un cliente llame a la API, debe crear una implementación y una etapa asociada. La etapa representa una imagen instantánea de su API, incluidos sus métodos e integraciones.
**Para implementar la API**
1. Abra la página **API** de la [consola de API Gateway](https://console.aws.amazon.com/apigateway) y seleccione la API de `DynamoDBOperations`.
1. En la página **Recursos** de su API, seleccione **Implementar la API**.
1. Para la **Etapa de implementación**, seleccione **\$1Nueva etapa\$1** y, en **Nombre de etapa**, introduzca **test**.
1. Elija **Implementar**.
1. En el panel **Editor de etapas de prueba**, copie la **URL de invocación**. Lo utilizará en el siguiente paso para invocar su función mediante una solicitud HTTP.
## Utilice curl para invocar tu función mediante solicitudes HTTP.
Ahora puede invocar la función de Lambda al emitir una solicitud HTTP a la API. En este paso, creará un elemento nuevo en la tabla de DynamoDB y, a continuación, lo someterá a operaciones de lectura, actualización y eliminación.
**Para crear un elemento en la tabla de DynamoDB con curl**
1. Abra una petición de comando o un terminal en su máquina local y ejecute el siguiente comando `curl` por medio de la URL de invocación que copió en el paso anterior. Este comando utiliza las siguientes opciones:
+ `-H`: añada un encabezado personalizado a la solicitud. Aquí, se especifica el tipo de contenido como JSON.
+ `-d`: envía los datos en el cuerpo de la solicitud. Esta opción usa un método HTTP POST de forma predeterminada.
------
#### [ Linux/macOS ]
```
curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
-H "Content-Type: application/json" \
-d '{"operation": "create", "payload": {"Item": {"id": "5678EFGH", "number": 15}}}'
```
------
#### [ PowerShell ]
```
curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"create\", \"payload\": {\"Item\": {\"id\": \"5678EFGH\", \"number\": 15}}}'
```
------
Si la operación se realizó correctamente, debería ver una respuesta con el código de estado HTTP 200.
1. También puede utilizar la consola de DynamoDB para comprobar que el nuevo elemento esté en la tabla con las siguientes acciones:
1. Abra la página [Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tablas) en la consola de DynamoDB y elija la tabla `lambda-apigateway`.
1. Elija **Explore table items** (Explorar elementos de la tabla). En el panel **Items returned** (Devolución de elementos), debería ver un elemento con el **id**`5678EFGH` y el **número**`15`.
**Para leer el elemento en la tabla de DynamoDB con curl**
+ En la petición de comando o en el terminal, ejecute el siguiente comando `curl` para leer el valor del elemento que acaba de crear. Utilice su propia URL de invocación.
------
#### [ Linux/macOS ]
```
curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
-H "Content-Type: application/json" \
-d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}'
```
------
#### [ PowerShell ]
```
curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
```
------
Debería ver uno de los siguientes resultados dependiendo de si eligió el código de función Node.js o Python:
------
#### [ Node.js ]
```
{"$metadata":{"httpStatusCode":200,"requestId":"7BP3G5Q0C0O1E50FBQI9NS099JVV4KQNSO5AEMVJF66Q9ASUAAJG",
"attempts":1,"totalRetryDelay":0},"Item":{"id":"5678EFGH","number":15}}
```
------
#### [ Python ]
```
{"Item":{"id":"5678EFGH","number":15},"ResponseMetadata":{"RequestId":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG",
"HTTPStatusCode":200,"HTTPHeaders":{"server":"Server","date":"Wed, 31 Jul 2024 00:37:01 GMT","content-type":"application/x-amz-json-1.0",
"content-length":"52","connection":"keep-alive","x-amzn-requestid":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG","x-amz-crc32":"2589610852"},
"RetryAttempts":0}}
```
------
**Para actualizar el elemento en la tabla de DynamoDB con curl**
1. En la petición de comando o en el terminal, ejecute el siguiente comando `curl` para actualizar el elemento que acaba de crear cambiando el valor `number`. Utilice su propia URL de invocación.
------
#### [ Linux/macOS ]
```
curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
-H "Content-Type: application/json" \
-d '{"operation": "update", "payload": {"Key": {"id": "5678EFGH"}, "UpdateExpression": "SET #num = :new_value", "ExpressionAttributeNames": {"#num": "number"}, "ExpressionAttributeValues": {":new_value": 42}}}'
```
------
#### [ PowerShell ]
```
curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"update\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}, \"UpdateExpression\": \"SET #num = :new_value\", \"ExpressionAttributeNames\": {\"#num\": \"number\"}, \"ExpressionAttributeValues\": {\":new_value\": 42}}}'
```
------
1. Para confirmar que se ha actualizado el valor de `number` correspondiente al elemento, ejecute otro comando de lectura:
------
#### [ Linux/macOS ]
```
curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
-H "Content-Type: application/json" \
-d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}'
```
------
#### [ PowerShell ]
```
curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
```
------
**Para eliminar el elemento en la tabla de DynamoDB con curl**
1. En la petición de comando o en el terminal, ejecute el siguiente comando `curl` para eliminar el elemento que ha creado. Utilice su propia URL de invocación.
------
#### [ Linux/macOS ]
```
curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \
-H "Content-Type: application/json" \
-d '{"operation": "delete", "payload": {"Key": {"id": "5678EFGH"}}}'
```
------
#### [ PowerShell ]
```
curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"delete\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}'
```
------
1. Confirme que la operación de eliminación se ha realizado correctamente. En el panel **Elementos devueltos** de la página **Explorar elementos** de la consola de DynamoDB, verifique que el elemento con **id** `5678EFGH` ya no se encuentre en la tabla.
## Elimine sus recursos (opcional)
A menos que desee conservar los recursos que creó para este tutorial, puede eliminarlos ahora. Si elimina los recursos de AWS que ya no utiliza, evitará gastos innecesarios en su Cuenta de AWS.
**Cómo eliminar la función de Lambda**
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Seleccione la función que ha creado.
1. Elija **Acciones**, **Eliminar**.
1. Escriba **confirm** en el campo de entrada de texto y elija **Delete**(Eliminar).
**Cómo eliminar el rol de ejecución**
1. Abra la página [Roles](https://console.aws.amazon.com/iam/home#/roles) en la consola de IAM.
1. Seleccione el rol de ejecución que creó.
1. Elija **Eliminar**.
1. Si desea continuar, escriba el nombre del rol en el campo de entrada de texto y elija **Delete** (Eliminar).
**Para eliminar la API**
1. Abra la [página API](https://console.aws.amazon.com/apigateway/main/apis) de la consola de API Gateway.
1. Seleccione la API que ha creado.
1. Elija **Actions** (Acciones), **Delete** (Eliminar).
1. Elija **Eliminar**.
**Para eliminar una tabla de DynamoDB**
1. Abra la página [Tables (Tablas)](https://console.aws.amazon.com//dynamodb/home#tables:) en la consola de DynamoDB.
1. Seleccione la tabla que ha creado.
1. Elija **Eliminar**.
1. Escriba **delete** en el cuadro de texto.
1. Elija **Delete table (Eliminar tabla)**.
# Manejo de los errores en Lambda con una API de API Gateway
API Gateway trata todos los errores de las invocaciones y las funciones como errores internos. Si la API de Lambda rechaza la solicitud de invocación, API Gateway devuelve un código de error 500. Si la función se ejecuta pero devuelve un error o devuelve una respuesta con un formato incorrecto, API Gateway muestra un 502. En ambos casos, el cuerpo de la respuesta de API Gateway es `{"message": "Internal server error"}`.
**nota**
API Gateway no vuelve a intentar ninguna invocación de Lambda. Si Lambda devuelve un error, API Gateway devuelve una respuesta de error al cliente.
En el ejemplo siguiente, se muestra un mapa de seguimiento de X-Ray de una solicitud que generó un error de función y un error 502 de API Gateway. El cliente recibirá el mensaje de error genérico.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/tracemap-apig-502.png)
Para personalizar la respuesta del error, debe detectar errores en el código y elaborar una respuesta en el formato que desee.
**Example [index.mjs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig/function/index.mjs): error de formato.**
```
var formatError = function(error){
var response = {
"statusCode": error.statusCode,
"headers": {
"Content-Type": "text/plain",
"x-amzn-ErrorType": error.code
},
"isBase64Encoded": false,
"body": error.code + ": " + error.message
}
return response
}
```
API Gateway convierte esta respuesta en un error HTTP con un código de estado y un cuerpo personalizados. En el mapa de seguimiento, el nodo de la función es verde porque el error se administró correctamente.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/tracemap-apig-404.png)
# Selección de un método para invocar una función de Lambda mediante una solicitud HTTP
En muchos casos de uso habituales de Lambda, se debe invocar una función mediante una solicitud HTTP. Por ejemplo, tal vez desee que una aplicación web invoque su función mediante una solicitud del navegador. Las funciones de Lambda también se pueden utilizar para crear API de REST completas, gestionar las interacciones de los usuarios de las aplicaciones móviles, procesar datos de servicios externos mediante llamadas HTTP o crear webhooks personalizados.
En las siguientes secciones, se explican cuáles son sus opciones para invocar a Lambda a través de HTTP y se proporciona información que ayudará a que tome la decisión correcta para su caso de uso concreto.
## ¿Cuáles son sus opciones a la hora de seleccionar un método para invocar una HTTP?
Lambda ofrece dos métodos principales para invocar una función mediante una solicitud HTTP: las [URL de función](urls-configuration.md) y [API Gateway](services-apigateway.md). Las diferencias clave entre estas dos opciones son las siguientes:
+ **Las URL de función de Lambda** proporcionan un punto de conexión HTTP simple y directo para una función de Lambda. Están optimizadas para ofrecer simplicidad y rentabilidad y ofrecen la ruta más rápida para exponer una función de Lambda a través de HTTP.
+ **API Gateway** es un servicio más avanzado para crear una API con todas las características. API Gateway está optimizado para crear y administrar una API de producción a escala y ofrece herramientas integrales para la seguridad, el monitoreo y la administración del tráfico.
## Recomendaciones si ya conoce sus requisitos
Si ya tiene claros sus requisitos, estas son nuestras recomendaciones básicas:
Recomendamos las **[URL de función](urls-configuration.md)** para aplicaciones sencillas o para la creación de prototipos cuando solo necesite métodos básicos de autenticación y gestión de solicitudes y respuestas y siempre que desee reducir al mínimo los costos y la complejidad.
**[API Gateway](services-apigateway.md)** es una mejor opción para aplicaciones de producción a gran escala o para los casos en los que se necesitan características más avanzadas, como la compatibilidad con la [descripción de OpenAPI](https://www.openapis.org/), una variedad de opciones de autenticación, nombres de dominio personalizados o una gestión rica de solicitudes y respuestas, que incluye la limitación, el almacenamiento en caché y la transformación de solicitudes y respuestas.
## Aspectos que deben tenerse en cuenta al seleccionar un método para invocar una función de Lambda
Al seleccionar entre las URL de función y API Gateway, deben tener en cuenta los siguientes factores:
+ Sus necesidades de autenticación, por ejemplo, si necesita OAuth o Amazon Cognito para autenticar a los usuarios
+ Sus requisitos de escalado y la complejidad de la API que desea implementar
+ Si necesita características avanzadas, como la validación de solicitudes y el formato de las solicitudes o respuestas
+ Sus requisitos de monitoreo
+ Sus objetivos de costos
Al comprender estos factores, puede seleccionar la opción que mejor equilibre sus requisitos de seguridad, complejidad y costo.
En la siguiente información, se comparan las principales diferencias entre las dos opciones.
### Autenticación
+ **Las URL de función** proporcionan opciones de autenticación básicas mediante AWS Identity and Access Management (IAM). Puede configurar sus puntos de conexión para que sean públicos (sin autenticación) o para que requieran la autenticación de IAM. Con la autenticación de IAM, puede utilizar credenciales de AWS estándar o roles de IAM para controlar el acceso. Si bien es fácil de configurar, este enfoque ofrece opciones limitadas en comparación con otros métodos de autenticación.
+ **API Gateway** proporciona acceso a una gama más completa de opciones de autenticación. Además de la autenticación de IAM, puede utilizar [autorizadores de Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) (lógica de autenticación personalizada), grupos de usuarios de [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) y flujos de OAuth2.0. Esta flexibilidad permite implementar esquemas de autenticación complejos, que incluyen proveedores de autenticación de terceros, autenticación basada en tokens y autenticación multifactorial.
### Gestión de solicitudes y respuestas
+ **Las URL de función** proporcionan una gestión básica de solicitudes y respuestas HTTP. Son compatibles con los métodos HTTP estándar e incluyen soporte integrado de uso compartido de recursos entre orígenes (CORS). Si bien pueden gestionar las cargas útiles de JSON y los parámetros de consulta de forma natural, no ofrecen capacidades de transformación o validación de solicitudes. La gestión de las respuestas es igual de sencillo: el cliente recibe la respuesta de la función de Lambda exactamente como Lambda la devuelve.
+ **API Gateway** ofrece capacidades sofisticadas de gestión de solicitudes y respuestas. Puede definir validadores de solicitudes, transformar las solicitudes y las respuestas mediante la asignación de plantillas, la configuración de encabezados de solicitudes y respuestas y la implementación el almacenamiento en caché de las respuestas. API Gateway también es compatible con las cargas útiles binarias y los nombres de dominio personalizados y puede modificar las respuestas antes de que lleguen al cliente. Puede configurar modelos para la validación y transformación de solicitudes y respuestas mediante el esquema JSON.
### Escalado
+ **Las URL de función** se escalan directamente con los límites de simultaneidad de la función de Lambda y gestionan los picos de tráfico al escalar la función hasta el límite máximo de simultaneidad configurado. Una vez alcanzado ese límite, Lambda responde a las solicitudes adicionales con respuestas HTTP 429. No hay un mecanismo de colas integrado, por lo que la gestión del escalado depende totalmente de la configuración de la función de Lambda. De forma predeterminada, las funciones de Lambda tienen un límite de 1000 ejecuciones simultáneas por Región de AWS.
+ **API Gateway** proporciona capacidades de escalado adicionales además del escalado propio de Lambda. Incluye controles integrados de limitación y cola de solicitudes, lo que permite administrar los picos de tráfico con mayor facilidad. De forma predeterminada, API Gateway puede gestionar hasta 10 000 solicitudes por segundo por región, con una capacidad de ampliación de 5000 solicitudes por segundo. También proporciona herramientas para limitar las solicitudes en diferentes niveles (API, fase o método) a fin de proteger el backend.
### Supervisión
+ **Las URL de función** ofrecen un monitoreo básico a través de las métricas de Amazon CloudWatch, que incluyen el recuento de solicitudes, la latencia y las tasas de error. Obtiene acceso a métricas y registros estándar de Lambda, que muestran las solicitudes sin procesar que llegan a su función. Si bien esto proporciona una visibilidad operativa esencial, las métricas se centran principalmente en la ejecución de las funciones.
+ **API Gateway** proporciona capacidades de monitoreo integrales que incluyen métricas detalladas, registro y opciones de rastreo. Puede supervisar las llamadas a la API, la latencia, las tasas de error y las tasas de aciertos y errores de la caché a través de CloudWatch. API Gateway también se integra con AWS X-Ray para el rastreo distribuido y proporciona formatos de registro personalizables.
### Coste
+ **Las URL de función** siguen el modelo de precios estándar de Lambda: solo paga por las invocaciones de funciones y el tiempo de cálculo. No hay recargos adicionales para el punto de conexión URL en sí. Esto lo convierte en una opción rentable para API simples o aplicaciones de bajo tráfico si no necesita las características adicionales de la API Gateway.
+ **API Gateway** ofrece un [nivel gratuito](https://aws.amazon.com/api-gateway/pricing/#Free_Tier) que incluye un millón de llamadas a la API recibidas para las API de REST y un millón de llamadas a la API recibidas para las API de HTTP. Después de esto, API Gateway cobra por las llamadas a la API, la transferencia de datos y el almacenamiento en caché (si están habilitados). Consulte la [página de precios](https://aws.amazon.com/api-gateway/pricing/) de API Gateway para conocer los costos de su propio caso práctico.
### Otras características
+ **Las URL de función** están diseñadas para ofrecer simplicidad e integración directa con Lambda. Son compatibles con los puntos de conexión HTTP y HTTPS, ofrecen soporte CORS integrado y proporcionan puntos de conexión de doble pila (IPv4 e IPv6). Si bien carecen de características avanzadas, destacan en situaciones en las que se necesita una forma rápida y sencilla de exponer las funciones de Lambda a través de HTTP.
+ **API Gateway** incluye numerosas características adicionales, como el control de versiones de las API, la administración de etapas, las claves de API para los planes de uso, la documentación de las API a través de Swagger/OpenAPI, las API de WebSocket, las API privadas dentro de una VPC y la integración de WAF para mayor seguridad. También es compatible con las implementaciones canarias, las integraciones simuladas para pruebas y la integración con otros Servicios de AWS más allá de Lambda.
## Selección de un método para invocar una función de Lambda
Ahora que ha leído los criterios para seleccionar entre las URL de función de Lambda y API Gateway y las principales diferencias entre ellas, puede seleccionar la opción que mejor se adapte a sus necesidades y utilizar los siguientes recursos para empezar a utilizarla.
------
#### [ Function URLs ]
**Comience a utilizar las URL de función con los siguientes recursos**
+ Siga el tutorial [Crear de una función de Lambda con una URL de función](urls-webhook-tutorial.md)
+ Obtenga más información sobre las URL de función en el capítulo [Creación y administración de URL de funciones de Lambda](urls-configuration.md) de esta guía
+ Pruebe el tutorial guiado integrado en la consola: **Crear una aplicación web sencilla** de la siguiente manera:
1. Abra la [página de Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda.
1. Abra el panel de ayuda al elegir el icono de la esquina superior derecha de la pantalla.
![\[\]](http://docs.aws.amazon.com/es_es/lambda/latest/dg/images/console_help_screenshot.png)
1. Seleccione **Tutoriales**.
1. En **Crear una aplicación web sencilla**, seleccione **Iniciar el tutorial**.
------
#### [ API Gateway ]
**Comience a utilizar Lambda y API Gateway con los siguientes recursos**
+ Siga el tutorial [Uso de Lambda con API Gateway](services-apigateway-tutorial.md) para crear una API de REST integrada con una función de Lambda de backend.
+ Obtenga más información sobre los distintos tipos de API que ofrece API Gateway en las siguientes secciones de la *guía para desarrolladores de Amazon API Gateway*:
+ [API de REST de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html)
+ [API de HTTP de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html)
+ [API de WebSocket de API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html)
+ Pruebe uno o varios de los ejemplos de la sección de [tutoriales y talleres](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-tutorials.html) de la *Guía para desarrolladores de Amazon API Gateway*.
------