# Creación y administración de URL de funciones de Lambda Una URL de función es un punto de conexión HTTP(S) dedicado para la función de Lambda. Puede crear y configurar una URL de función a través de la consola de Lambda o la API de Lambda. **sugerencia** Lambda ofrece dos formas de invocar la función a través de un punto de conexión HTTP: URL de función y Amazon API Gateway. 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](furls-http-invoke-decision.md). Al crear una URL de función, Lambda genera automáticamente un punto de conexión de URL único para usted. Una vez que crea una URL de función, el punto de conexión de la URL nunca cambia. Los puntos de conexión de la URL de función tienen el siguiente formato: ``` https://.lambda-url..on.aws ``` **nota** Las URL de función no se admiten en las siguientes Regiones de AWS: Asia-Pacífico (Hyderabad) (`ap-south-2`), Asia-Pacífico (Melbourne) (`ap-southeast-4`), Asia-Pacífico (Malasia) (`ap-southeast-5`), Asia Pacífico (Nueva Zelanda) (`ap-southeast-6`), Asia Pacífico (Tailandia) (`ap-southeast-7`) Asia-Pacífico (Taipéi) (`ap-east-2`), Oeste de Canadá (Calgary) (`ca-west-1`), Europa (España) (`eu-south-2`), Europa (Zúrich) (`eu-central-2`), Israel (Tel Aviv) (`il-central-1`) y Medio Oriente (EAU) (`me-central-1`). Las URL de funciones están habilitadas para doble pila y son compatibles con IPv4 e IPv6. Después de configurar una URL de función para su función, puede invocar la función a través de su punto de conexión HTTP(S) mediante un navegador web, curl, Postman o cualquier cliente HTTP. **nota** Puede acceder a la URL de la función solo a través de la Internet pública. Si bien las funciones de Lambda son compatibles con AWS PrivateLink, las URL de las funciones no lo son. Las URL de funciones de Lambda utilizan [políticas basadas en recursos](access-control-resource-based.md) para la seguridad y el control de acceso. Las URL de funciones también admiten opciones de configuración de uso compartido de recursos entre orígenes (CORS). Puede aplicar las URL de las funciones a cualquier alias de la función o a la versión `$LATEST` de la función no publicada. No se puede agregar una URL de función a ninguna otra versión de la función. La siguiente sección muestra cómo crear y administrar una URL de función mediante la consola de Lambda, la AWS CLI y la plantilla de CloudFormation. **Topics** + [Creación de una URL de función (consola)](#create-url-console) + [Creación de una URL de función (AWS CLI)](#create-url-cli) + [Adición de una URL de función a una plantilla de CloudFormation](#urls-cfn) + [Compartir recursos entre orígenes (CORS)](#urls-cors) + [URL de funciones de limitación](#urls-throttling) + [Desactivación de URL de funciones](#urls-deactivating) + [Eliminación de URL de función](#w2aac39c81c53) + [Control de acceso a las URL de las funciones de Lambda](urls-auth.md) + [Invocación de URL de funciones de Lambda](urls-invocation.md) + [Supervisión de las URL de funciones de Lambda](urls-monitoring.md) + [Selección de un método para invocar una función de Lambda mediante una solicitud HTTP](furls-http-invoke-decision.md) + [Tutorial: Creación de un punto de conexión de webhook mediante la URL de una función de Lambda](urls-webhook-tutorial.md) ## Creación de una URL de función (consola) Siga estos pasos para crear una URL de función mediante la consola. ### Para crear una URL de función para una función existente 1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Elija el nombre de la función para la que desea crear la URL de función. 1. Elija la pestaña **Configuration** (Configuración) y, a continuación, elija **Function URL** (URL de función). 1. Elija **Create function URL** (Crear URL de función). 1. Para el **Auth type** (Tipo de autenticación), elija **AWS\$1IAM** o **NONE** (NINGUNO). Para obtener más información sobre la autenticación de URL de función, consulte [Control de acceso](urls-auth.md). 1. (Opcional) Seleccione **Configure cross-origin resource sharing (CORS)** (Configuración de uso compartido de recursos entre orígenes [CORS]) y, a continuación, configure los ajustes de CORS para la URL de función. Para obtener más información acerca de CORS, consulte [Compartir recursos entre orígenes (CORS)](#urls-cors). 1. Seleccione **Save**. Esto crea una URL de función para la versión `$LATEST` no publicada de la función. La URL de función aparece en la sección **Function overview** (Información general de la función) de la consola. ### Para crear una URL de función para un alias existente 1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Elija el nombre de la función con el alias para el que desea crear la URL de función. 1. Elija la pestaña **Aliases** (Alias) y, a continuación, elija el nombre del alias para el que desea crear la URL de función. 1. Elija la pestaña **Configuration** (Configuración) y, a continuación, elija **URL de función** (URL de función). 1. Elija **Create function URL** (Crear URL de función). 1. Para el **Auth type** (Tipo de autenticación), elija **AWS\$1IAM** o **NONE** (NINGUNO). Para obtener más información sobre la autenticación de URL de función, consulte [Control de acceso](urls-auth.md). 1. (Opcional) Seleccione **Configure cross-origin resource sharing (CORS)** (Configuración de uso compartido de recursos entre orígenes [CORS]) y, a continuación, configure los ajustes de CORS para la URL de función. Para obtener más información acerca de CORS, consulte [Compartir recursos entre orígenes (CORS)](#urls-cors). 1. Seleccione **Save**. Esto crea una URL de función para el alias de la función. La URL de función aparece en la sección **Información general de la función** para su alias. ### Para crear una nueva función con una URL de función **Para crear una nueva función con una URL de función (consola)** 1. Abra la página de [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funciones) en la consola de Lambda. 1. Elija **Create function (Crear función)**. 1. Bajo **Basic information (Información básica)**, haga lo siguiente: 1. En **Function name** (Nombre de la función), ingrese un nombre para la función, como **my-function**. 1. En **Tiempo de ejecución**, elija el tiempo de ejecución del lenguaje que prefiera, como **Node.js 24**. 1. En **Architecture** (Arquitectura), elija **x86\$164** o **arm64**. 1. Expanda **Permissions** (Permisos) y, a continuación, elija si desea crear un nuevo rol de ejecución o utilizar uno existente. 1. Expanda **Advanced settings** (Configuración avanzada) y, a continuación, seleccione **Function URL** (URL de función). 1. Para el **Auth type** (Tipo de autenticación), elija **AWS\$1IAM** o **NONE** (NINGUNO). Para obtener más información sobre la autenticación de URL de función, consulte [Control de acceso](urls-auth.md). 1. (Opcional) Seleccione **Configure cross-origin resource sharing (CORS)** (Configuración de uso compartido de recursos entre orígenes [CORS]). Al seleccionar esta opción durante la creación de la función, la URL de función permite solicitudes de todos los orígenes de forma predeterminada. Puede editar la configuración de CORS de la URL de función después de crear la función. Para obtener más información acerca de CORS, consulte [Compartir recursos entre orígenes (CORS)](#urls-cors). 1. Seleccione **Creación de función**. Esto crea una nueva función con una URL de función para la versión `$LATEST` no publicada de la función. La URL de función aparece en la sección **Function overview** (Información general de la función) de la consola. ## Creación de una URL de función (AWS CLI) Para crear una URL de función para una función de Lambda existente mediante la AWS Command Line Interface (AWS CLI), ejecute el siguiente comando: ``` aws lambda create-function-url-config \ --function-name my-function \ --qualifier prod \ // optional --auth-type AWS_IAM --cors-config {AllowOrigins="https://example.com"} // optional ``` Esto añade una URL de función al calificador **prod** para la función **my-function**. Para obtener más información acerca de estos parámetros de configuración, consulte [CreateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunctionUrlConfig.html) en la referencia de la API. **nota** Para crear una URL de función mediante la AWS CLI, la función ya debe existir. ## Adición de una URL de función a una plantilla de CloudFormation Para agregar un recurso de `AWS::Lambda::Url` a su plantilla de CloudFormation, utilice la siguiente sintaxis: ### JSON ``` { "Type" : "AWS::Lambda::Url", "Properties" : { "AuthType" : String, "Cors" : Cors, "Qualifier" : String, "TargetFunctionArn" : String } } ``` ### YAML ``` Type: AWS::Lambda::Url Properties: AuthType: String Cors: Cors Qualifier: String TargetFunctionArn: String ``` ### Parameters + (Obligatorio) `AuthType`: define el tipo de autenticación de la URL de función. Los valores posibles son `AWS_IAM` o `NONE`. Para restringir el acceso solo a los usuarios autenticados, establézcalo en `AWS_IAM`. Para omitir la autenticación de IAM y permitir que cualquier usuario realice solicitudes a su función, establézcalo en `NONE`. + (Opcional) `Cors`: define la [configuración de CORS](#urls-cors) para la URL de función. Para agregar `Cors` al recurso de `AWS::Lambda::Url` en CloudFormation, utilice la siguiente sintaxis. **Example AWS::Lambda::Url.Cors (JSON)** ``` { "AllowCredentials" : Boolean, "AllowHeaders" : [ String, ... ], "AllowMethods" : [ String, ... ], "AllowOrigins" : [ String, ... ], "ExposeHeaders" : [ String, ... ], "MaxAge" : Integer } ``` **Example AWS::Lambda::Url.Cors (YAML)** ``` AllowCredentials: Boolean AllowHeaders: - String AllowMethods: - String AllowOrigins: - String ExposeHeaders: - String MaxAge: Integer ``` + (Opcional) `Qualifier`: el nombre del alias. + (Obligatorio) `TargetFunctionArn`: el nombre o nombre de recurso de Amazon (ARN) de la función de Lambda. Los formatos de nombre válidos incluyen los siguientes: + **Nombre de la función** – `my-function` + **ARN de la función** – `arn:aws:lambda:us-west-2:123456789012:function:my-function` + **ARN parcial** – `123456789012:function:my-function` ## Compartir recursos entre orígenes (CORS) Para definir cómo los distintos orígenes pueden acceder a la URL de función, utilice el [uso compartido de recursos entre orígenes (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). Recomendamos configurar CORS si tiene la intención de llamar a la URL de función desde otro dominio. Lambda es compatible con los siguientes encabezados CORS para las URL de funciones. | Encabezado CORS | Propiedad de configuración de CORS | Valores de ejemplo | | --- | --- | --- | | [ Access-Control-Allow-Origin](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin) | `AllowOrigins` | `*` (permitir todos los orígenes) `https://www.example.com` `http://localhost:60905` | | [ Access-Control-Allow-Methods](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods) | `AllowMethods` | `GET`, `POST`, `DELETE`, `*` | | [ Access-Control-Allow-Headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) | `AllowHeaders` | `Date`, `Keep-Alive`, `X-Custom-Header` | | [ Access-Control-Expose-Headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Expose-Headers) | `ExposeHeaders` | `Date`, `Keep-Alive`, `X-Custom-Header` | | [ Access-Control-Allow-Credentials](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Credentials) | `AllowCredentials` | `TRUE` | | [ Access-Control-Max-Age](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age) | `MaxAge` | `5` (predeterminado), `300` | Al configurar CORS para una URL de función mediante la consola de Lambda o la AWS CLI, Lambda agrega automáticamente los encabezados CORS a todas las respuestas a través de la URL de función. También puede agregar manualmente encabezados CORS a la respuesta de la función. Si hay encabezados contradictorios, el comportamiento esperado depende del tipo de solicitud: + Para las solicitudes de verificación previa, como las solicitudes OPTIONS, prevalecen los encabezados CORS configurados en la URL de función. Lambda devuelve solo estos encabezados CORS en la respuesta. + Para las solicitudes que no son de verificación previa, como las solicitudes GET o POST, Lambda devuelve tanto los encabezados CORS configurados en la URL de función como los encabezados CORS devueltos por la función. Esto puede provocar encabezados CORS duplicados en la respuesta. Es posible que vea un error como el siguiente: `The 'Access-Control-Allow-Origin' header contains multiple values '*, *', but only one is allowed`. En general, se recomienda configurar todos los ajustes de CORS en la URL de función, en lugar de enviar los encabezados CORS manualmente en la respuesta de la función. ## URL de funciones de limitación La limitación limita la velocidad a la que la función procesa las solicitudes. Esto resulta útil en muchas situaciones, como evitar que la función sobrecargue los recursos descendentes o gestionar un aumento repentino de las solicitudes. Puede limitar la tasa de solicitudes que procesa la función de Lambda a través de una URL de función configurando la simultaneidad reservada. La simultaneidad reservada limita el número de invocaciones simultáneas máximas para la función. La tasa máxima de solicitudes por segundo (RPS) de la función equivale a 10 veces la simultaneidad reservada configurada. Por ejemplo, si configura la función con una simultaneidad reservada de 100, el RPS máximo es de 1000. Cada vez que la simultaneidad de la función supera la simultaneidad reservada, la URL de función devuelve un código de estado HTTP `429`. Si la función recibe una solicitud que supera 10 veces el máximo de RPS en función de la simultaneidad reservada configurada, también recibirá un error HTTP `429`. Para obtener más información acerca de la simultaneidad reservada, consulte [Configurar la simultaneidad reservada para una función](configuration-concurrency.md). ## Desactivación de URL de funciones En caso de emergencia, es posible que quiera rechazar todo el tráfico a la URL de función. Para desactivar la URL de función, establezca la simultaneidad reservada en cero. Esto limita todas las solicitudes a la URL de función, lo que da como resultado respuestas de estado HTTP `429`. Para reactivar la URL de función, elimine la configuración de simultaneidad reservada o establezca la configuración en un importe superior a cero. ## Eliminación de URL de función Al eliminar una URL de función, no se la puede recuperar. La creación de una nueva URL de función dará como resultado una dirección URL diferente. **nota** Si elimina una URL de función con el tipo de autenticación `NONE`, Lambda no elimina de forma automática la política basada en recursos asociada. Si desea eliminar esta política, debe hacerlo de forma manual. 1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Elija el nombre de la función. 1. Elija la pestaña **Configuration** (Configuración) y, a continuación, elija **Function URL** (URL de función). 1. Elija **Eliminar**. 1. Escriba la palabra *delete* (eliminar) en el campo para confirmar la eliminación. 1. Elija **Eliminar**. **nota** Al eliminar una función que tiene una URL de función, Lambda la elimina de forma asíncrona. Si crea inmediatamente una función nueva con el mismo nombre en la misma cuenta, es posible que la URL de la función original se asigne a la nueva función en lugar de eliminarse. # Control de acceso a las URL de las funciones de Lambda **nota** A partir de octubre de 2025, las nuevas URL de función requerirán ambos permisos, `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction`. Puede controlar el acceso a las URL de funciones de Lambda mediante el parámetro [AuthType](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunctionUrlConfig.html#lambda-CreateFunctionUrlConfig-request-AuthType) combinado con [políticas basadas en recursos](access-control-resource-based.md) adjuntas a la función específica. La configuración de estos dos componentes determina quién puede invocar o realizar otras acciones administrativas en la URL de función. El parámetro `AuthType` determina cómo Lambda autentica o autoriza las solicitudes a la URL de función. Al configurar la URL de función, debe especificar una de las siguientes opciones de `AuthType`: + `AWS_IAM`: Lambda utiliza AWS Identity and Access Management (IAM) para autenticar y autorizar solicitudes basadas en la política de identidad de la entidad principal de IAM y la política basada en recursos de la función. Elija esta opción si desea que solo los usuarios y roles autenticados invoquen su función a través de la URL de función. + `NONE`: Lambda no realiza ninguna autenticación antes de invocar la función. Sin embargo, la política basada en recursos de la función siempre está vigente y debe conceder acceso público para que la URL de función pueda recibir solicitudes. Elija esta opción para permitir el acceso público y no autenticado a la URL de función. Para obtener más información sobre la seguridad, puede utilizar AWS Identity and Access Management Access Analyzer para obtener un análisis exhaustivo del acceso externo a la URL de función. IAM Access Analyzer también supervisa los permisos nuevos o actualizados en las funciones de Lambda para ayudarle a identificar los permisos que otorgan acceso público y entre cuentas. Puede utilizar IAM Access Analyzer sin cargo. Para comenzar a utilizar IAM Access Analyzer, consulte [Uso de AWS IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html). Esta página contiene ejemplos de políticas basadas en recursos para ambos tipos de autenticación y cómo crear estas políticas mediante la operación de la API [AddPermission](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html) o la consola de Lambda. Para obtener información acerca de cómo invocar la URL de función después de configurar los permisos, consulte [Invocación de URL de funciones de Lambda](urls-invocation.md). **Topics** + [Uso del tipo de autenticación `AWS_IAM`](#urls-auth-iam) + [Uso del tipo de autenticación `NONE`](#urls-auth-none) + [Gobierno y control de acceso](#urls-governance) ## Uso del tipo de autenticación `AWS_IAM` Si elige el tipo de autenticación `AWS_IAM`, los usuarios que necesiten invocar la URL de función de Lambda deben tener el permiso `lambda:InvokeFunctionUrl` y también el permiso `lambda:InvokeFunction`. Según quién realice la solicitud de invocación, es posible que deba conceder este permiso mediante una [política basada en recursos](access-control-resource-based.md). Si la entidad principal que realiza la solicitud está en la misma Cuenta de AWS que la URL de función, entonces la entidad principal debe tener **o bien** los permisos `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction` en su [política basada en identidad](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html), **o** permisos concedidos en la política basada en recursos de la función. En otras palabras, una política basada en recursos es opcional si el usuario ya tiene permisos `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction` en su política basada en identidad. La evaluación de políticas sigue las reglas descritas en la [lógica de evaluación de políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html). Si la entidad principal que realiza la solicitud se encuentra en una cuenta diferente, la entidad principal debe tener **tanto** una política basada en identidad que le otorgue permisos `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction` **como** permisos concedidos en una política basada en recursos sobre la función que intenta invocar. La evaluación de políticas sigue las reglas descritas en [Cómo determinar si una solicitud se permite o se deniega entre cuentas](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html#policy-eval-cross-account). La siguiente política basada en recursos permite al rol `example` en la Cuenta de AWS `444455556666` invocar la URL de función asociada a la función `my-function`. La clave de contexto [lambda:InvokedViaFunctionUrl](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html#lambda-AddPermission-request-InvokedViaFunctionUrl) restringe la acción `lambda:InvokeFunction` a las llamadas de la URL de función. Esto significa que la entidad principal debe usar la URL de función para invocar la función. Si no incluye `lambda:InvokedViaFunctionUrl`, la entidad principal puede invocar su función mediante otros métodos de invocación, además de la URL de función. **Example : política entre cuentas basada en recursos** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::444455556666:role/example" }, "Action": "lambda:InvokeFunctionUrl", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-function", "Condition": { "StringEquals": { "lambda:FunctionUrlAuthType": "AWS_IAM" } } }, { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::444455556666:role/example" }, "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-function", "Condition": { "Bool": { "lambda:InvokedViaFunctionUrl": "true" } } } ] } ``` Puede crear esta política basada en recursos a través de la consola siguiendo estos pasos: **Para conceder permisos de invocación de URL a otra cuenta (consola)** 1. Abra la página de [Funciones](https://console.aws.amazon.com/lambda/home#/functions) en la consola de Lambda. 1. Elija el nombre de la función para la que desea conceder permisos de invocación de la URL. 1. Elija la pestaña **Configuration** (Configuración) y, a continuación, elija **Permissions** (Permisos). 1. En **Resource-based policy** (Política basada en recursos), elija **Add permissions** (Agregar permisos). 1. Elija **Function URL** (URL de función). 1. En **Auth type** (Tipo de autenticación), elija **AWS\$1IAM**. 1. Introduzca un **identificador de estado de cuenta** para su declaración de póliza. 1. En **Entidad principal**, ingrese el ID de cuenta o el nombre de recurso de Amazon (ARN) del usuario o rol al que desea conceder permisos. Por ejemplo: **444455556666**. 1. Seleccione **Save**. Como alternativa, puede crear esta instrucción de política mediante los comandos [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) AWS Command Line Interface (AWS CLI). Al usar la AWS CLI, debe agregar los estados de cuenta `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction` los estados por separado. Por ejemplo: ``` aws lambda add-permission --function-name my-function \ --statement-id UrlPolicyInvokeURL \ --action lambda:InvokeFunctionUrl \ --principal 444455556666 \ --function-url-auth-type AWS_IAM ``` ``` aws lambda add-permission --function-name my-function \ --statement-id UrlPolicyInvokeFunction \ --action lambda:InvokeFunction \ --principal 444455556666 \ --invoked-via-function-url ``` ## Uso del tipo de autenticación `NONE` **importante** Cuando el tipo de autenticación de la URL de función es `NONE` y tiene una [política basada en recursos](access-control-resource-based.md) que concede acceso público, cualquier usuario no autenticado con la URL de función puede invocar la función. En algunos casos, es posible que desee que la URL de función sea pública. Por ejemplo, es posible que desee atender solicitudes realizadas directamente desde un navegador web. Para permitir el acceso público a la URL de función, elija el tipo de autenticación `NONE`. Si elige el tipo de autenticación `NONE`, Lambda no utilizará IAM para autenticar las solicitudes a la URL de función. Sin embargo, su función debe tener una política basada en recursos que permita `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction`. Al crear una URL de función con tipo de autenticación `NONE` a través de la consola o AWS Serverless Application Model (AWS SAM), Lambda crea automáticamente la política basada en recursos por usted. Si utiliza la AWS CLI, AWS CloudFormation o la API de Lambda directamente, debe [agregar la política usted](#policy-cli). Le recomendamos que incluya la clave de contexto [lambda:InvokedViaFunctionUrlL](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html#lambda-AddPermission-request-InvokedViaFunctionUrl) en sus políticas basadas en recursos cuando utilice el tipo de autenticación `NONE`. Esta clave de contexto garantiza que la función solo se pueda invocar a través de la URL de función y no a través de otros métodos de invocación. Tenga en cuenta lo siguientes sobre esta política: + Todas las entidades pueden llamar `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction`. Esto significa que cualquier persona que tenga la URL de función puede invocarla. + El valor de la clave de condición `lambda:FunctionUrlAuthType` es `NONE`. Esto significa que la instrucción de política solo permite el acceso cuando el tipo de autenticación de la URL de función también es `NONE`. + La condición `lambda:InvokedViaFunctionUrl` garantiza que la función solo se pueda invocar a través de la URL de función y no a través de otros métodos de invocación. **Example : política predeterminada basada en recursos para el tipo de autenticación NONE** **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "FunctionURLAllowPublicAccess", "Effect": "Allow", "Principal": "*", "Action": "lambda:InvokeFunctionUrl", "Resource": "arn:aws:lambda:us-east-2:123456789012:function:my-function", "Condition": { "StringEquals": { "lambda:FunctionUrlAuthType": "NONE" } } }, { "Sid": "FunctionURLInvokeAllowPublicAccess", "Effect": "Allow", "Principal": "*", "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:us-east-2:123456789012:function:my-function", "Condition": { "Bool": { "lambda:InvokedViaFunctionUrl": "true" } } } ] } ``` **Crear la política basada en recursos con AWS CLI** A menos que utilice la consola o AWS SAM para crear una URL de función con un tipo de autenticación `NONE`, debe agregar usted mismo la política basada en recursos. Utilice los siguientes comandos para crear declaraciones para los permisos `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction`. Cada declaración debe añadirse en un comando independiente. ``` aws lambda add-permission \ --function-name UrlTestFunction \ --statement-id UrlPolicyInvokeURL \ --action lambda:InvokeFunctionUrl \ --principal * \ --function-url-auth-type NONE ``` ``` aws lambda add-permission \ --function-name UrlTestFunction \ --statement-id UrlPolicyInvokeFunction \ --action lambda:InvokeFunction \ --principal * \ --invoked-via-function-url ``` **nota** Si elimina una URL de función con el tipo de autenticación `NONE`, Lambda no elimina de forma automática la política basada en recursos asociada. Si desea eliminar esta política, debe hacerlo de forma manual. Si la política basada en recursos de una función no concede permisos `lambda:invokeFunctionUrl` y `lambda:InvokeFunction`, los usuarios obtendrán un código de error 403 Forbidden (Prohibido) cuando intenten invocar la URL de función, incluso si la URL de función utiliza el tipo de autenticación . Esto ocurrirá incluso si la URL de función utiliza el tipo de autenticación `NONE`. ## Gobierno y control de acceso Además de los permisos de invocación de la URL de función, también puede controlar el acceso a las acciones utilizadas para configurar las URL de funciones. Lambda es compatible con las siguientes acciones de política de IAM para las URL de funciones: + `lambda:InvokeFunctionUrl`: invocar una función de Lambda mediante la URL de función. + `lambda:CreateFunctionUrlConfig` – crear una URL de función y configurar su `AuthType`. + `lambda:UpdateFunctionUrlConfig` – actualizar una configuración de URL de función y su `AuthType`. + `lambda:GetFunctionUrlConfig`: ver los detalles de una URL de función. + `lambda:ListFunctionUrlConfigs`: enumerar las configuraciones de la URL de función. + `lambda:DeleteFunctionUrlConfig`: eliminar una URL de función. Para permitir o denegar el acceso de otras entidades de AWS a la URL de función, incluya estas acciones en las políticas de IAM. Por ejemplo, la siguiente política concede permisos al rol `example` en la Cuenta de AWS `444455556666` para actualizar la URL de función para la función **my-function** en la cuenta `123456789012`. **Example política de URL de función entre cuentas** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::444455556666:role/example" }, "Action": "lambda:UpdateFunctionUrlConfig", "Resource": "arn:aws:lambda:us-east-2:123456789012:function:my-function" } ] } ``` ### Claves de condición Para obtener un control de acceso detallado sobre las URL de funciones, utilice claves de contexto de condición. Lambda es compatible con las siguientes claves de contexto para las URL de funciones. + `lambda:FunctionUrlAuthType`: define un valor de enumeración que describe el tipo de autenticación que utiliza la URL de función. El valor puede ser `AWS_IAM` o `NONE`. + `lambda:InvokedViaFunctionUrl`: restringe la acción `lambda:InvokeFunction` a las llamadas realizadas a través de la URL de función. Esto garantiza que la función solo se pueda invocar a través de la URL de función y no a través de otros métodos de invocación. Para ver ejemplos de políticas basadas en recursos que utilizan la clave de contexto `lambda:InvokedViaFunctionUrl`, consulte los ejemplos de [Uso del tipo de autenticación `AWS_IAM`](#urls-auth-iam) y [Uso del tipo de autenticación `NONE`](#urls-auth-none). Puede utilizar estas claves de contexto en las políticas asociadas a la función. Por ejemplo, es posible que desee restringir quién puede realizar cambios de configuración en las URL de funciones. Para denegar todas las solicitudes `UpdateFunctionUrlConfig` a cualquier función con tipo de autenticación de URL `NONE`, puede definir la siguiente política: **Example política de URL de función con denegación explícita** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Deny", "Principal": "*", "Action":[ "lambda:UpdateFunctionUrlConfig" ], "Resource": "arn:aws:lambda:us-east-1:123456789012:function:*", "Condition": { "StringEquals": { "lambda:FunctionUrlAuthType": "NONE" } } } ] } ``` Para conceder permisos al rol `example` en la Cuenta de AWS `444455556666` para hacer solicitudes `CreateFunctionUrlConfig` y `UpdateFunctionUrlConfig` en funciones con tipo de autenticación de URL `AWS_IAM`, puede definir la siguiente política: **Example política de URL de función con permiso explícito** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::444455556666:role/example" }, "Action":[ "lambda:CreateFunctionUrlConfig", "lambda:UpdateFunctionUrlConfig" ], "Resource": "arn:aws:lambda:us-east-1:123456789012:function:*", "Condition": { "StringEquals": { "lambda:FunctionUrlAuthType": "AWS_IAM" } } } ] } ``` También puede utilizar esta clave de condición en una [política de control de servicios](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) (SCP). Utilice las SCP para administrar los permisos en toda una organización en AWS Organizations. Por ejemplo, para denegar a los usuarios la creación o actualización de URL de funciones que utilicen un tipo de autenticación distinto a `AWS_IAM`, utilice la siguiente política de control de servicios: **Example SCP de URL de función con denegación explícita** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Deny", "Action":[ "lambda:CreateFunctionUrlConfig", "lambda:UpdateFunctionUrlConfig" ], "Resource": "arn:aws:lambda:*:123456789012:function:*", "Condition": { "StringNotEquals": { "lambda:FunctionUrlAuthType": "AWS_IAM" } } } ] } ``` # Invocación de URL de funciones de Lambda Una URL de función es un punto de conexión HTTP(S) dedicado para la función de Lambda. Puede crear y configurar una URL de función a través de la consola de Lambda o la API de Lambda. **sugerencia** Lambda ofrece dos formas de invocar la función a través de un punto de conexión HTTP: URL de función y Amazon API Gateway. 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](furls-http-invoke-decision.md). Al crear una URL de función, Lambda genera automáticamente un punto de conexión de URL único para usted. Una vez que crea una URL de función, el punto de conexión de la URL nunca cambia. Los puntos de conexión de la URL de función tienen el siguiente formato: ``` https://.lambda-url..on.aws ``` **nota** Las URL de función no se admiten en las siguientes Regiones de AWS: Asia-Pacífico (Hyderabad) (`ap-south-2`), Asia-Pacífico (Melbourne) (`ap-southeast-4`), Asia-Pacífico (Malasia) (`ap-southeast-5`), Asia Pacífico (Nueva Zelanda) (`ap-southeast-6`), Asia Pacífico (Tailandia) (`ap-southeast-7`) Asia-Pacífico (Taipéi) (`ap-east-2`), Oeste de Canadá (Calgary) (`ca-west-1`), Europa (España) (`eu-south-2`), Europa (Zúrich) (`eu-central-2`), Israel (Tel Aviv) (`il-central-1`) y Medio Oriente (EAU) (`me-central-1`). Las URL de funciones están habilitadas para doble pila y son compatibles con IPv4 e IPv6. Después de configurar la URL de función, puede invocar la función a través de su punto de conexión HTTP(S) mediante un navegador web, curl, Postman o cualquier cliente HTTP. Para invocar una URL de función, debe tener permisos `lambda:InvokeFunctionUrl` y `lambda:InvokeFunction`. Para obtener más información, consulte [Control de acceso](urls-auth.md). **Topics** + [Conceptos básicos de invocación de URL de funciones](#urls-invocation-basics) + [Cargas de solicitud y respuesta](#urls-payloads) ## Conceptos básicos de invocación de URL de funciones Si la URL de función utiliza el tipo de autenticación `AWS_IAM`, debe firmar cada solicitud HTTP utilizando [AWS Signature Version 4 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html). Herramientas tales como [Postman](https://quickstarts.postman.com/guide/aws/index.html?index=..%2F..index#2) ofrecen formas integradas de firmar sus solicitudes con SigV4. Si no utiliza una herramienta para firmar solicitudes HTTP en la URL de función, debe firmar manualmente cada solicitud mediante SigV4. Cuando la URL de función recibe una solicitud, Lambda también calcula la firma SigV4. Lambda procesa la solicitud solo si las firmas coinciden. Para obtener instrucciones sobre cómo firmar de manera manual las solicitudes con SigV4, consulte [Firmar solicitudes de AWS con Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html) en la *Guía de Referencia general de Amazon Web Services*. Si la URL de función utiliza el tipo de autenticación `NONE`, no es necesario que firme las solicitudes con SigV4. Puede invocar la función mediante un navegador web, curl, Postman o cualquier cliente HTTP. Para probar solicitudes `GET` simples a su función, utilice un navegador web. Por ejemplo, si la URL de función es `https://abcdefg.lambda-url.us-east-1.on.aws`, y toma un parámetro de cadena `message`, la URL de la solicitud podría tener un aspecto similar al siguiente: ``` https://abcdefg.lambda-url.us-east-1.on.aws/?message=HelloWorld ``` Para probar otras solicitudes HTTP, como una solicitud `POST`, puede utilizar una herramienta como curl. Por ejemplo, si desea incluir algunos datos JSON en una solicitud `POST` a la URL de función, puede utilizar el siguiente comando curl: ``` curl -v 'https://abcdefg.lambda-url.us-east-1.on.aws/?message=HelloWorld' \ -H 'content-type: application/json' \ -d '{ "example": "test" }' ``` ## Cargas de solicitud y respuesta Cuando un cliente llama a la URL de función, Lambda asigna la solicitud a un objeto de evento antes de pasarla a la función. A continuación, la respuesta de la función se asigna a una respuesta HTTP que Lambda envía de vuelta al cliente a través de la URL de función. Los formatos de eventos de solicitud y respuesta siguen el mismo esquema que la [versión de formato de carga 2.0 de Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format). ### Formato de carga de solicitud La carga de una solicitud tiene la siguiente estructura: ``` { "version": "2.0", "routeKey": "$default", "rawPath": "/my/path", "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", "cookies": [ "cookie1", "cookie2" ], "headers": { "header1": "value1", "header2": "value1,value2" }, "queryStringParameters": { "parameter1": "value1,value2", "parameter2": "value" }, "requestContext": { "accountId": "123456789012", "apiId": "", "authentication": null, "authorizer": { "iam": { "accessKey": "AKIA...", "accountId": "111122223333", "callerId": "AIDA...", "cognitoIdentity": null, "principalOrgId": null, "userArn": "arn:aws:iam::111122223333:user/example-user", "userId": "AIDA..." } }, "domainName": ".lambda-url.us-west-2.on.aws", "domainPrefix": "", "http": { "method": "POST", "path": "/my/path", "protocol": "HTTP/1.1", "sourceIp": "123.123.123.123", "userAgent": "agent" }, "requestId": "id", "routeKey": "$default", "stage": "$default", "time": "12/Mar/2020:19:03:58 +0000", "timeEpoch": 1583348638390 }, "body": "Hello from client!", "pathParameters": null, "isBase64Encoded": false, "stageVariables": null } ``` | Parámetro | Descripción | Ejemplo | | --- | --- | --- | | `version` | La versión de formato de carga de este evento. Actualmente, las URL de funciones de Lambda son compatibles con la [versión de formato de carga 2.0](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format). | `2.0` | | `routeKey` | Las URL de funciones no utilizan este parámetro. Lambda establece `$default` como marcador de posición. | `$default` | | `rawPath` | Ruta de acceso de la solicitud. Por ejemplo, si la URL de solicitud es `https://{url-id}.lambda-url.{region}.on.aws/example/test/demo`, el valor de la ruta sin procesar es `/example/test/demo`. | `/example/test/demo` | | `rawQueryString` | La cadena sin procesar que contiene los parámetros de cadena de consulta de la solicitud. Los caracteres admitidos incluyen `a-z`, `A-Z`, `0-9`, `.`, `_`, `-`, `%`, `&`, `=` y `+`. | `"?parameter1=value1¶meter2=value2"` | | `cookies` | Una matriz que contiene todas las cookies enviadas como parte de la solicitud. | `["Cookie_1=Value_1", "Cookie_2=Value_2"]` | | `headers` | La lista de encabezados de solicitud, presentada como pares clave-valor. | `{"header1": "value1", "header2": "value2"}` | | `queryStringParameters` | Los parámetros de consulta de la solicitud. Por ejemplo, si la URL de solicitud es `https://{url-id}.lambda-url.{region}.on.aws/example?name=Jane`, el valor `queryStringParameters` es un objeto JSON con una clave de `name` y un valor de `Jane`. | `{"name": "Jane"}` | | `requestContext` | Un objeto que contiene información adicional sobre la solicitud, como el `requestId`, el momento de la solicitud y la identidad del intermediario si se autoriza a través de AWS Identity and Access Management (IAM). | | | `requestContext.accountId` | El ID de Cuenta de AWS del propietario de la función. | `"123456789012"` | | `requestContext.apiId` | El ID de la URL de función. | `"33anwqw8fj"` | | `requestContext.authentication` | Las URL de funciones no utilizan este parámetro. Lambda establece esto como `null`. | `null` | | `requestContext.authorizer` | Un objeto que contiene información sobre la identidad del intermediario, si la URL de función utiliza el tipo de autenticación `AWS_IAM`. De lo contrario, Lambda establece esto como `null`. | | | `requestContext.authorizer.iam.accessKey` | La clave de acceso de la identidad del intermediario. | `"AKIAIOSFODNN7EXAMPLE"` | | `requestContext.authorizer.iam.accountId` | El ID de identidad de Cuenta de AWS del intermediario. | `"111122223333"` | | `requestContext.authorizer.iam.callerId` | El ID (ID de usuario) del intermediario. | `"AIDACKCEVSQ6C2EXAMPLE"` | | `requestContext.authorizer.iam.cognitoIdentity` | Las URL de funciones no utilizan este parámetro. Lambda establece esto como `null` o lo excluye de JSON. | `null` | | `requestContext.authorizer.iam.principalOrgId` | El ID de la entidad principal de la organización asociado a la identidad del intermediario. | `"AIDACKCEVSQORGEXAMPLE"` | | `requestContext.authorizer.iam.userArn` | El nombre de recurso de Amazon (ARN) del usuario de la identidad del intermediario. | `"arn:aws:iam::111122223333:user/example-user"` | | `requestContext.authorizer.iam.userId` | El ID de usuario de la identidad del intermediario. | `"AIDACOSFODNN7EXAMPLE2"` | | `requestContext.domainName` | El nombre de dominio de la URL de función. | `".lambda-url.us-west-2.on.aws"` | | `requestContext.domainPrefix` | El prefijo de dominio de la URL de función. | `""` | | `requestContext.http` | Un objeto que contiene detalles sobre la solicitud HTTP. | | | `requestContext.http.method` | El método HTTP utilizado en esta solicitud. Los valores válidos son `GET`, `POST`, `PUT`, `HEAD`, `OPTIONS`, `PATCH` y `DELETE`. | `GET` | | `requestContext.http.path` | Ruta de acceso de la solicitud. Por ejemplo, si la URL de solicitud es `https://{url-id}.lambda-url.{region}.on.aws/example/test/demo`, el valor de la ruta es `/example/test/demo`. | `/example/test/demo` | | `requestContext.http.protocol` | El protocolo de la solicitud. | `HTTP/1.1` | | `requestContext.http.sourceIp` | La dirección IP de origen de la conexión TCP inmediata que realiza la solicitud. | `123.123.123.123` | | `requestContext.http.userAgent` | El valor del encabezado de solicitud usuario-agente. | `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/42.0` | | `requestContext.requestId` | El ID de la solicitud de invocación. Puede utilizar este ID para realizar un seguimiento de los registros de invocación relacionados con la función. | `e1506fd5-9e7b-434f-bd42-4f8fa224b599` | | `requestContext.routeKey` | Las URL de funciones no utilizan este parámetro. Lambda establece `$default` como marcador de posición. | `$default` | | `requestContext.stage` | Las URL de funciones no utilizan este parámetro. Lambda establece `$default` como marcador de posición. | `$default` | | `requestContext.time` | La marca de tiempo de la solicitud. | `"07/Sep/2021:22:50:22 +0000"` | | `requestContext.timeEpoch` | La marca de tiempo de la solicitud, en fecha de inicio Unix. | `"1631055022677"` | | `body` | El cuerpo de la solicitud. Si el tipo de contenido de la solicitud es binario, el cuerpo está codificado en base64. | `{"key1": "value1", "key2": "value2"}` | | `pathParameters` | Las URL de funciones no utilizan este parámetro. Lambda establece esto como `null` o lo excluye de JSON. | `null` | | `isBase64Encoded` | `TRUE` si el cuerpo es una carga binaria y está codificado en base64. `FALSE` en caso contrario. | `FALSE` | | `stageVariables` | Las URL de funciones no utilizan este parámetro. Lambda establece esto como `null` o lo excluye de JSON. | `null` | ### Formato de carga de respuesta Cuando la función devuelve una respuesta, Lambda analiza la respuesta y la convierte en una respuesta HTTP. Las cargas de respuesta de la función tienen el siguiente formato: ``` { "statusCode": 201, "headers": { "Content-Type": "application/json", "My-Custom-Header": "Custom Value" }, "body": "{ \"message\": \"Hello, world!\" }", "cookies": [ "Cookie_1=Value1; Expires=21 Oct 2021 07:48 GMT", "Cookie_2=Value2; Max-Age=78000" ], "isBase64Encoded": false } ``` Lambda le infiere el formato de respuesta. Si la función devuelve JSON válido y no devuelve un `statusCode`, Lambda asume lo siguiente: + `statusCode` is `200`. **nota** Los `statusCode` válidos están dentro del rango de 100 a 599. + `content-type` is `application/json`. + `body` es la respuesta de la función. + `isBase64Encoded` is `false`. En los ejemplos siguientes se muestra cómo se asigna la salida de la función de Lambda a la carga de respuesta y cómo se asigna la carga de respuesta a la respuesta HTTP final. Cuando el cliente invoca la URL de función, ve la respuesta HTTP. **Ejemplo de salida para una respuesta de cadena** | Salida de función de Lambda | Salida de respuesta interpretada | Respuesta HTTP (lo que ve el cliente) | | --- | --- | --- | | 
"Hello, world!"
| 
{
  "statusCode": 200,
  "body": "Hello, world!",
  "headers": {
    "content-type": "application/json"
  },
  "isBase64Encoded": false
}
| 
HTTP/2 200
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 15

"Hello, world!"
| **Ejemplo de salida para una respuesta JSON** | Salida de función de Lambda | Salida de respuesta interpretada | Respuesta HTTP (lo que ve el cliente) | | --- | --- | --- | | 
{
  "message": "Hello, world!"
}
| 
{
  "statusCode": 200,
  "body": {
    "message": "Hello, world!"
  },
  "headers": {
    "content-type": "application/json"
  },
  "isBase64Encoded": false
}
| 
HTTP/2 200
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 34

{
  "message": "Hello, world!"
}
| **Ejemplo de salida para una respuesta personalizada** | Salida de función de Lambda | Salida de respuesta interpretada | Respuesta HTTP (lo que ve el cliente) | | --- | --- | --- | | 
{
   "statusCode": 201,
    "headers": {
        "Content-Type": "application/json",
        "My-Custom-Header": "Custom Value"
    },
    "body": JSON.stringify({
        "message": "Hello, world!"
    }),
    "isBase64Encoded": false
}
| 
{
   "statusCode": 201,
    "headers": {
        "Content-Type": "application/json",
        "My-Custom-Header": "Custom Value"
    },
    "body": JSON.stringify({
        "message": "Hello, world!"
    }),
    "isBase64Encoded": false
}
| 
HTTP/2 201
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 27
my-custom-header: Custom Value

{
  "message": "Hello, world!"
}
| ### Cookies Para devolver las cookies de su función, no agregue encabezados `set-cookie` manualmente. En su lugar, incluya las cookies en su objeto de carga de respuesta. Lambda interpreta esto automáticamente y las agrega como encabezados `set-cookie` de la respuesta HTTP, como en el siguiente ejemplo. | Salida de función de Lambda | Respuesta HTTP (lo que ve el cliente) | | --- | --- | | 
{
   "statusCode": 201,
    "headers": {
        "Content-Type": "application/json",
        "My-Custom-Header": "Custom Value"
    },
    "body": JSON.stringify({
        "message": "Hello, world!"
    }),
    "cookies": [
        "Cookie_1=Value1; Expires=21 Oct 2021 07:48 GMT",
        "Cookie_2=Value2; Max-Age=78000"
    ],
    "isBase64Encoded": false
}
| 
HTTP/2 201
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 27
my-custom-header: Custom Value
set-cookie: Cookie_1=Value2; Expires=21 Oct 2021 07:48 GMT
set-cookie: Cookie_2=Value2; Max-Age=78000

{
  "message": "Hello, world!"
}
| # Supervisión de las URL de funciones de Lambda Puede utilizar AWS CloudTrail y Amazon CloudWatch para supervisar las URL de funciones. **Topics** + [Supervisión de las URL de funciones con CloudTrail](#urls-cloudtrail) + [Métricas de CloudWatch para las URL de funciones](#urls-cloudwatch) ## Supervisión de las URL de funciones con CloudTrail Para las URL de funciones, Lambda admite automáticamente el registro de las siguientes operaciones de API como eventos en archivos de registros de CloudTrail: + [CreateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunctionUrlConfig.html) + [UpdateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionUrlConfig.html) + [DeleteFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunctionUrlConfig.html) + [GetFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionUrlConfig.html) + [ListFunctionUrlConfigs](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctionUrlConfigs.html) Cada entrada de registro contiene información sobre la identidad del intermediario, cuándo se realizó la solicitud y otros detalles. Puede ver todos los eventos de los últimos 90 días consultando el **historial de eventos** de CloudTrail. Para retener registros pasados 90 días, puede crear una traza. De forma predeterminada, CloudTrail no registra solicitudes `InvokeFunctionUrl`, que se consideran eventos de datos. Sin embargo, puede activar el registro de eventos de datos en CloudTrail. Para obtener más información, consulte [Registro de eventos de datos para registros de seguimiento](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) en la *Guía del usuario de AWS CloudTrail*. ## Métricas de CloudWatch para las URL de funciones Lambda envía métricas agregadas sobre las solicitudes de URL de funciones a CloudWatch. Con estas métricas, puede supervisar las URL de funciones, crear paneles y configurar alarmas en la consola de CloudWatch. Las URL de funciones son compatibles con las siguientes métricas de invocación. Recomendamos ver estas métricas con la estadística `Sum` + `UrlRequestCount`: el número de solicitudes realizadas a esta URL de función. + `Url4xxCount`: el número de solicitudes que devolvió un código de estado HTTP 4XX. Los códigos de la serie 4XX indican errores del lado del cliente, como solicitudes erróneas. + `Url5xxCount`: el número de solicitudes que devolvió un código de estado HTTP 5XX. Los códigos de la serie 5XX indican errores del lado del servidor, como errores de función y tiempos de espera. Las URL de funciones también son compatibles con la siguiente métrica de rendimiento. Recomendamos ver esta métrica con las estadísticas `Average` o `Max`. + `UrlRequestLatency`: el tiempo transcurrido entre el que la URL de función recibe una solicitud y el momento en que la URL de función devuelve una respuesta. Cada una de estas métricas de invocación y rendimiento es compatible con las siguientes dimensiones: + `FunctionName`: visualiza métricas agregadas para las URL de las funciones asignadas a la versión `$LATEST` no publicada o a cualquiera de los alias de la función. Por ejemplo, `hello-world-function`. + `Resource`: visualiza métricas para una URL de función específica. Esto se define mediante el nombre de una función, junto con la versión `$LATEST` no publicada o uno de los alias de la función. Por ejemplo, `hello-world-function:$LATEST`. + `ExecutedVersion`: visualiza métricas para una URL de función específica en función de la versión ejecutada. Puede utilizar esta dimensión principalmente para realizar un seguimiento de la URL de función asignada a la versión `$LATEST` no publicada. # 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*. ------ # Tutorial: Creación de un punto de conexión de webhook mediante la URL de una función de Lambda En este tutorial, creará la URL de una función de Lambda para implementar un punto de conexión de webhook. Un webhook es una comunicación ligera y basada en eventos que envía automáticamente datos entre aplicaciones mediante HTTP. Puede usar un webhook para recibir actualizaciones inmediatas sobre los eventos que ocurren en otro sistema, como cuando un nuevo cliente se registra en un sitio web, se procesa un pago o se carga un archivo. Con Lambda, los webhooks se pueden implementar mediante URL de funciones de Lambda o API Gateway. Las URL de funciones son una buena opción para los webhooks sencillos que no requieren características como la autorización avanzada o la validación de solicitudes. **sugerencia** Si no está seguro de cuál es el mejor método para su caso específico, consulte [Selección de un método para invocar una función de Lambda mediante una solicitud HTTP](furls-http-invoke-decision.md). ## Requisitos previos Para completar este tutorial, debe tener Python (versión 3.8 o posterior) o Node.js (versión 18 o posterior) instalados en su máquina local. Para probar el punto de conexión mediante una solicitud HTTP, el tutorial utiliza [curl](https://curl.se/), una herramienta de línea de comandos que puede utilizar para transferir datos mediante varios protocolos de red. Consulte la [Documentación de curl](https://curl.se/docs/install.html) para obtener información sobre cómo instalar la herramienta si aún no la tiene. ## Crear la función de Lambda Primero cree la función de Lambda que se ejecuta cuando se envía una solicitud HTTP a su punto de conexión de webhook. En este ejemplo, la aplicación remitente envía una actualización cada vez que se envía un pago e indica en el cuerpo de la solicitud HTTP si el pago se ha realizado correctamente. La función de Lambda analiza la solicitud y actúa de acuerdo con el estado del pago. En este ejemplo, el código solo imprime el ID del pedido para el pago, pero en una aplicación real, puede añadir el pedido a una base de datos o enviar una notificación. La función también implementa el método de autenticación más común utilizado para los webhooks, la autenticación de mensajes basada en hash (HMAC). Con este método, tanto las aplicaciones de envío como las de recepción comparten una clave secreta. La aplicación de envío utiliza un algoritmo de hash para generar una firma única utilizando esta clave junto con el contenido del mensaje, e incluye la firma en la solicitud de webhook como un encabezado HTTP. Luego, la aplicación receptora repite este paso, genera la firma con la clave secreta y compara el valor resultante con la firma enviada en el encabezado de la solicitud. Si el resultado coincide, la solicitud se considera legítima. Cree la función mediante la consola de Lambda con el tiempo de ejecución de Python o Node.js. ------ #### [ Python ] **Crear 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. Cree una función básica “Hello world” de la siguiente manera: 1. Elija **Crear función**. 1. Seleccione **Crear desde cero**. 1. En **Nombre de la función**, introduzca **myLambdaWebhook**. 1. En **Tiempo de ejecución**, seleccione **python 3.14**. 1. Seleccione **Creación de función**. 1. En el panel **Código fuente**, sustituya el código existente al copiar y pegar lo siguiente: ``` import json import hmac import hashlib import os def lambda_handler(event, context): # Get the webhook secret from environment variables webhook_secret = os.environ['WEBHOOK_SECRET'] # Verify the webhook signature if not verify_signature(event, webhook_secret): return { 'statusCode': 401, 'body': json.dumps({'error': 'Invalid signature'}) } try: # Parse the webhook payload payload = json.loads(event['body']) # Handle different event types event_type = payload.get('type') if event_type == 'payment.success': # Handle successful payment order_id = payload.get('orderId') print(f"Processing successful payment for order {order_id}") # Add your business logic here # For example, update database, send notifications, etc. elif event_type == 'payment.failed': # Handle failed payment order_id = payload.get('orderId') print(f"Processing failed payment for order {order_id}") # Add your business logic here else: print(f"Received unhandled event type: {event_type}") # Return success response return { 'statusCode': 200, 'body': json.dumps({'received': True}) } except json.JSONDecodeError: return { 'statusCode': 400, 'body': json.dumps({'error': 'Invalid JSON payload'}) } except Exception as e: print(f"Error processing webhook: {e}") return { 'statusCode': 500, 'body': json.dumps({'error': 'Internal server error'}) } def verify_signature(event, webhook_secret): """ Verify the webhook signature using HMAC """ try: # Get the signature from headers signature = event['headers'].get('x-webhook-signature') if not signature: print("Error: Missing webhook signature in headers") return False # Get the raw body (return an empty string if the body key doesn't exist) body = event.get('body', '') # Create HMAC using the secret key expected_signature = hmac.new( webhook_secret.encode('utf-8'), body.encode('utf-8'), hashlib.sha256 ).hexdigest() # Compare the expected signature with the received signature to authenticate the message is_valid = hmac.compare_digest(signature, expected_signature) if not is_valid: print(f"Error: Invalid signature. Received: {signature}, Expected: {expected_signature}") return False return True except Exception as e: print(f"Error verifying signature: {e}") return False ``` 1. En la sección **IMPLEMENTAR**, elija **Implementar** para actualizar el código de la función. ------ #### [ Node.js ] **Crear 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. Cree una función básica “Hello world” de la siguiente manera: 1. Seleccione **Creación de función**. 1. Seleccione **Crear desde cero**. 1. En **Nombre de la función**, introduzca **myLambdaWebhook**. 1. En **Tiempo de ejecución**, seleccione **nodejs24.x**. 1. Seleccione **Creación de función**. 1. En el panel **Código fuente**, sustituya el código existente al copiar y pegar lo siguiente: ``` import crypto from 'crypto'; export const handler = async (event, context) => { // Get the webhook secret from environment variables const webhookSecret = process.env.WEBHOOK_SECRET; // Verify the webhook signature if (!verifySignature(event, webhookSecret)) { return { statusCode: 401, body: JSON.stringify({ error: 'Invalid signature' }) }; } try { // Parse the webhook payload const payload = JSON.parse(event.body); // Handle different event types const eventType = payload.type; switch (eventType) { case 'payment.success': { // Handle successful payment const orderId = payload.orderId; console.log(`Processing successful payment for order ${orderId}`); // Add your business logic here // For example, update database, send notifications, etc. break; } case 'payment.failed': { // Handle failed payment const orderId = payload.orderId; console.log(`Processing failed payment for order ${orderId}`); // Add your business logic here break; } default: console.log(`Received unhandled event type: ${eventType}`); } // Return success response return { statusCode: 200, body: JSON.stringify({ received: true }) }; } catch (error) { if (error instanceof SyntaxError) { // Handle JSON parsing errors return { statusCode: 400, body: JSON.stringify({ error: 'Invalid JSON payload' }) }; } // Handle all other errors console.error('Error processing webhook:', error); return { statusCode: 500, body: JSON.stringify({ error: 'Internal server error' }) }; } }; // Verify the webhook signature using HMAC const verifySignature = (event, webhookSecret) => { try { // Get the signature from headers const signature = event.headers['x-webhook-signature']; if (!signature) { console.log('No signature found in headers:', event.headers); return false; } // Get the raw body (return an empty string if the body key doesn't exist) const body = event.body || ''; // Create HMAC using the secret key const hmac = crypto.createHmac('sha256', webhookSecret); const expectedSignature = hmac.update(body).digest('hex'); // Compare expected and received signatures const isValid = signature === expectedSignature; if (!isValid) { console.log(`Invalid signature. Received: ${signature}, Expected: ${expectedSignature}`); return false; } return true; } catch (error) { console.error('Error during signature verification:', error); return false; } }; ``` 1. En la sección **IMPLEMENTAR**, elija **Implementar** para actualizar el código de la función. ------ ## Crear la clave secreta Para que la función de Lambda autentique la solicitud de webhook, utiliza una clave secreta que comparte con la aplicación que realiza la llamada. En este ejemplo, la clave se almacena en una variable del entorno. En aplicaciones de producción, no incluya información confidencial como contraseñas en el código de la función. En su lugar, [cree un secreto de AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) y, a continuación, [utilice la extensión de Lambda AWS Parameters and Secrets](with-secrets-manager.md) para recuperar las credenciales en su función de Lambda. **Crear y almacenar la clave secreta del webhook** 1. Genere una cadena larga y aleatoria utilizando un generador de números aleatorios criptográficamente seguro. Puede usar los siguientes fragmentos de código en Python o Node.js para generar e imprimir un secreto de 32 caracteres, o usar el método que prefiera. ------ #### [ Python ] **Example código para generar un secreto** ``` import secrets webhook_secret = secrets.token_urlsafe(32) print(webhook_secret) ``` ------ #### [ Node.js ] **Example código para generar un secreto (formato de módulo ES)** ``` import crypto from 'crypto'; let webhookSecret = crypto.randomBytes(32).toString('base64'); console.log(webhookSecret) ``` ------ 1. Guarde la cadena generada como una variable de entorno para su función de la siguiente manera: 1. En la sección **Configuración** de su función, seleccione **Variables de entorno**. 1. Seleccione **Editar**. 1. Elija **Add environment variable** (Añadir variable de entorno). 1. En **Clave**, ingrese **WEBHOOK\$1SECRET**, y en **Valor**, ingrese el secreto que generó en el paso anterior. 1. Seleccione **Save**. Tome nota de este secreto ahora, ya que tendrá que usarlo más adelante en el tutorial para probar la función. ## Crear el punto de conexión de la URL de función Cree un punto de conexión de webhook mediante la URL de una función de Lambda. Dado que utiliza el tipo de autenticación `NONE` para crear un punto de conexión con acceso público, cualquier persona que disponga de la URL puede invocar su función. Para obtener más información sobre cómo controlar el acceso a las URL de las funciones, consulte [Control de acceso a las URL de las funciones de Lambda](urls-auth.md). Si necesita opciones de autenticación más avanzadas para su webhook, considere usar API Gateway. **Crear el punto de conexión de la URL de función** 1. En la pestaña **Configuración** de su función, seleccione **URL de función**. 1. Elija **Create function URL** (Crear URL de función). 1. Para el **Tipo de autenticación**, seleccione **NINGUNO**. 1. Seleccione **Save**. El punto de conexión de la URL de función que acaba de crear aparece en el panel **URL de función**. Copie el punto de conexión para usarlo más adelante en el tutorial. ## Probar la función en la consola Antes de utilizar una solicitud HTTP para invocar la función mediante el punto de conexión de la URL, pruébela en la consola para confirmar que el código funciona según lo previsto. Para verificar la función en la consola, primero debe calcular la firma de un webhook utilizando el secreto que generó anteriormente en el tutorial con la siguiente carga útil de JSON de prueba: ``` { "type": "payment.success", "orderId": "1234", "amount": "99.99" } ``` Use uno de los siguientes ejemplos de código de Python o Node.js para calcular la firma del webhook con su propio secreto. ------ #### [ Python ] **Calcular la firma del webhook** 1. Guarde el siguiente código en un archivo denominado `calculate_signature.py`. Reemplace el secreto del webhook en el código por su propio valor. ``` import secrets import hmac import json import hashlib webhook_secret = "arlbSDCP86n_1H90s0fL_Qb2NAHBIBQOyGI0X4Zay4M" body = json.dumps({"type": "payment.success", "orderId": "1234", "amount": "99.99"}) signature = hmac.new( webhook_secret.encode('utf-8'), body.encode('utf-8'), hashlib.sha256 ).hexdigest() print(signature) ``` 1. Calcule la firma mediante la ejecución del siguiente comando desde el directorio donde haya guardado el código. Copie la firma que genera el código. ``` python calculate_signature.py ``` ------ #### [ Node.js ] **Calcular la firma del webhook** 1. Guarde el siguiente código en un archivo denominado `calculate_signature.mjs`. Reemplace el secreto del webhook en el código por su propio valor. ``` import crypto from 'crypto'; const webhookSecret = "arlbSDCP86n_1H90s0fL_Qb2NAHBIBQOyGI0X4Zay4M" const body = "{\"type\": \"payment.success\", \"orderId\": \"1234\", \"amount\": \"99.99\"}"; let hmac = crypto.createHmac('sha256', webhookSecret); let signature = hmac.update(body).digest('hex'); console.log(signature); ``` 1. Calcule la firma mediante la ejecución del siguiente comando desde el directorio donde haya guardado el código. Copie la firma que genera el código. ``` node calculate_signature.mjs ``` ------ Ahora puede probar el código de función mediante una solicitud HTTP de prueba en la consola. **Probar la función en la consola** 1. Seleccione la pestaña **Código** para su función. 1. En la sección **EVENTOS DE PRUEBA**, elija **Crear nuevo evento de prueba**. 1. Para **Event name (Nombre de evento)**, escriba **myEvent**. 1. En el panel **Evento JSON**, sustituya el código JSON existente al copiar y pegar lo siguiente. Reemplace la firma del webhook por el valor que calculó en el paso anterior. ``` { "headers": { "Content-Type": "application/json", "x-webhook-signature": "2d672e7a0423fab740fbc040e801d1241f2df32d2ffd8989617a599486553e2a" }, "body": "{\"type\": \"payment.success\", \"orderId\": \"1234\", \"amount\": \"99.99\"}" } ``` 1. Seleccione **Save**. 1. Elija **Invoke (Invocar)**. Debería ver una salida similar a esta: ------ #### [ Python ] ``` Status: Succeeded Test Event Name: myEvent Response: { "statusCode": 200, "body": "{\"received\": true}" } Function Logs: START RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6 Version: $LATEST Processing successful payment for order 1234 END RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6 REPORT RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6 Duration: 1.55 ms Billed Duration: 2 ms Memory Size: 128 MB Max Memory Used: 36 MB Init Duration: 136.32 ms ``` ------ #### [ Node.js ] ``` Status: Succeeded Test Event Name: myEvent Response: { "statusCode": 200, "body": "{\"received\":true}" } Function Logs: START RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 Version: $LATEST 2025-01-10T18:05:42.062Z e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 INFO Processing successful payment for order 1234 END RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 REPORT RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 Duration: 60.10 ms Billed Duration: 61 ms Memory Size: 128 MB Max Memory Used: 72 MB Init Duration: 174.46 ms Request ID: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 ``` ------ ## Probar la función mediante una solicitud HTTP Use la herramienta de línea de comandos curl para probar su punto de conexión de webhook. **Probar la función mediante solicitudes HTTP** 1. En un programa de terminal o intérprete de comandos, ejecute el siguiente comando curl. Sustituya la URL por el valor del punto de conexión de la URL de función y sustituya la firma del webhook por la firma que calculó con su propia clave secreta. ``` curl -X POST https://ryqgmbx5xjzxahif6frvzikpre0bpvpf.lambda-url.us-west-2.on.aws/ \ -H "Content-Type: application/json" \ -H "x-webhook-signature: d5f52b76ffba65ff60ea73da67bdf1fc5825d4db56b5d3ffa0b64b7cb85ef48b" \ -d '{"type": "payment.success", "orderId": "1234", "amount": "99.99"}' ``` Debería ver los siguientes datos de salida: ``` {"received": true} ``` 1. Inspeccione los registros de CloudWatch de su función para confirmar que analizó la carga útil correctamente de la siguiente manera: 1. En la consola de Amazon CloudWatch, abra la página [Grupos de registro](https://console.aws.amazon.com/cloudwatch/home#logsV2:log-groups). 1. Seleccione el grupo de registro de la función (`/aws/lambda/myLambdaWebhook`). 1. Seleccione el flujo de registros más reciente. Debería ver una salida similar a la siguiente en los registros de su función: ------ #### [ Python ] ``` Processing successful payment for order 1234 ``` ------ #### [ Node.js ] ``` 2025-01-10T18:05:42.062Z e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 INFO Processing successful payment for order 1234 ``` ------ 1. Ejecute el siguiente comando curl para confirmar que el código detecta una firma no válida. Sustituya la URL por el punto de conexión de su propia URL de función. ``` curl -X POST https://ryqgmbx5xjzxahif6frvzikpre0bpvpf.lambda-url.us-west-2.on.aws/ \ -H "Content-Type: application/json" \ -H "x-webhook-signature: abcdefg" \ -d '{"type": "payment.success", "orderId": "1234", "amount": "99.99"}' ``` Debería ver los siguientes datos de salida: ``` {"error": "Invalid signature"} ``` ## Eliminación de sus recursos 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). Cuando creó una función de Lambda en la consola, Lambda también creó un [rol de ejecución](lambda-intro-execution-role.md) para la función. **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ó Lambda. El rol tiene el formato de nombre `myLambdaWebhook-role-`. 1. Elija **Eliminar**. 1. Si desea continuar, escriba el nombre del rol en el campo de entrada de texto y elija **Delete** (Eliminar).