# Explicación: cómo crear un mecanismo de retardo mediante un recurso personalizado respaldado por Lambda En este tutorial, se muestra cómo configurar e inicializar un recurso personalizado respaldado por Lambda mediante una plantilla de muestra de CloudFormation. Esta plantilla crea un mecanismo de retraso que pausa las implementaciones de pilas durante un tiempo específico. Esto puede resultar útil cuando se necesita introducir retrasos deliberados durante el aprovisionamiento de recursos; por ejemplo, cuando se espera a que los recursos se estabilicen antes de que se creen los recursos dependientes. **nota** Si bien anteriormente se recomendaban recursos personalizados respaldados por Lambda para recuperar los ID de AMI, ahora recomendamos usar parámetros AWS Systems Manager. Este enfoque hace que sus plantillas sean más reutilizables y fáciles de mantener. Para obtener más información, consulte [Obtención de un valor de texto sin formato del Almacén de parámetros de Systems Manager](dynamic-references-ssm.md). **Topics** + [Descripción general](#walkthrough-lambda-backed-custom-resources-overview) + [Plantilla de muestra](#walkthrough-lambda-backed-custom-resources-sample-template) + [Explicación de la plantilla de ejemplo](#walkthrough-lambda-backed-custom-resources-sample-template-walkthrough) + [Requisitos previos](#walkthrough-lambda-backed-custom-resources-prerequisites) + [Lanzamiento de la pila](#walkthrough-lambda-backed-custom-resources-createfunction-createstack) + [Saneamiento de recursos](#walkthrough-lambda-backed-custom-resources-createfunction-cleanup) + [Información relacionada](#w2aac11c45b9c24b9c23) ## Descripción general La plantilla de pila de ejemplo utilizada en este tutorial crea un recurso personalizado respaldado por Lambda. Este recurso personalizado introduce un retraso configurable (60 segundos por defecto) durante la creación de la pila. El retraso se produce durante las actualizaciones de la pila solo cuando se modifican las propiedades del recurso personalizado. Esta plantilla proporciona los siguientes recursos: + un recurso personalizado, + una función de Lambda y + un rol de IAM que permite a Lambda escribir registros en CloudWatch. También define dos salidas: + El tiempo real que esperó la función. + Un identificador único generado durante cada ejecución de la función de Lambda. **nota** CloudFormation es un servicio gratuito, pero Lambda cobra en función del número de solicitudes de sus funciones y del tiempo de ejecución de su código. Para obtener más información acerca de los precios de Lambda, consulte [Precios de AWS Lambda](https://aws.amazon.com/lambda/pricing/). ## Plantilla de muestra A continuación, puede ver la plantilla de ejemplo de un recurso personalizado respaldado por Lambda con el mecanismo de retardo: ### JSON ``` { "AWSTemplateFormatVersion": "2010-09-09", "Resources": { "LambdaExecutionRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Statement": [{ "Effect": "Allow", "Principal": { "Service": ["lambda.amazonaws.com"] }, "Action": ["sts:AssumeRole"] }] }, "Path": "/", "Policies": [{ "PolicyName": "AllowLogs", "PolicyDocument": { "Statement": [{ "Effect": "Allow", "Action": ["logs:*"], "Resource": "*" }] } }] } }, "CFNWaiter": { "Type": "AWS::Lambda::Function", "Properties": { "Handler": "index.handler", "Runtime": "python3.9", "Timeout": 900, "Role": { "Fn::GetAtt": ["LambdaExecutionRole", "Arn"] }, "Code": { "ZipFile": { "Fn::Join": ["\n", [ "from time import sleep", "import json", "import cfnresponse", "import uuid", "", "def handler(event, context):", " wait_seconds = 0", " id = str(uuid.uuid1())", " if event[\"RequestType\"] in [\"Create\", \"Update\"]:", " wait_seconds = int(event[\"ResourceProperties\"].get(\"ServiceTimeout\", 0))", " sleep(wait_seconds)", " response = {", " \"TimeWaited\": wait_seconds,", " \"Id\": id ", " }", " cfnresponse.send(event, context, cfnresponse.SUCCESS, response, \"Waiter-\"+id)" ]]} } } }, "CFNWaiterCustomResource": { "Type": "AWS::CloudFormation::CustomResource", "Properties": { "ServiceToken": { "Fn::GetAtt": ["CFNWaiter", "Arn"] }, "ServiceTimeout": 60 } } }, "Outputs": { "TimeWaited": { "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "TimeWaited"] }, "Export": { "Name": "TimeWaited" } }, "WaiterId": { "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "Id"] }, "Export": { "Name": "WaiterId" } } } } ``` ### YAML ``` AWSTemplateFormatVersion: "2010-09-09" Resources: LambdaExecutionRole: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Statement: - Effect: "Allow" Principal: Service: - "lambda.amazonaws.com" Action: - "sts:AssumeRole" Path: "/" Policies: - PolicyName: "AllowLogs" PolicyDocument: Statement: - Effect: "Allow" Action: - "logs:*" Resource: "*" CFNWaiter: Type: AWS::Lambda::Function Properties: Handler: index.handler Runtime: python3.9 Timeout: 900 Role: !GetAtt LambdaExecutionRole.Arn Code: ZipFile: !Sub | from time import sleep import json import cfnresponse import uuid ​ def handler(event, context): wait_seconds = 0 id = str(uuid.uuid1()) if event["RequestType"] in ["Create", "Update"]: wait_seconds = int(event["ResourceProperties"].get("ServiceTimeout", 0)) sleep(wait_seconds) response = { "TimeWaited": wait_seconds, "Id": id } cfnresponse.send(event, context, cfnresponse.SUCCESS, response, "Waiter-"+id) CFNWaiterCustomResource: Type: AWS::CloudFormation::CustomResource Properties: ServiceToken: !GetAtt CFNWaiter.Arn ServiceTimeout: 60 Outputs: TimeWaited: Value: !GetAtt CFNWaiterCustomResource.TimeWaited Export: Name: TimeWaited WaiterId: Value: !GetAtt CFNWaiterCustomResource.Id Export: Name: WaiterId ``` ## Explicación de la plantilla de ejemplo Los siguientes fragmentos explican partes relevantes de la plantilla de ejemplo que ayudan a comprender cómo la función de Lambda se asocia a un recurso personalizado y a entender la salida. `CFNWaiter` del recurso [AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html) El recurso `AWS::Lambda::Function` especifica el código fuente de la función, el nombre del controlador, el entorno del tiempo de ejecución y el nombre de recurso de Amazon (ARN). La propiedad `Handler` está establecida en `index.handler`, ya que utiliza un código fuente de Python. Para obtener más información sobre los identificadores de controlador aceptados al usar código fuente de funciones en línea, consulte [AWS::Lambda::Function Code](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-code.html#cfn-lambda-function-code-zipfile). El `Runtime` se especifica como `python3.9`, ya que el archivo de origen está escrito en Python. El `Timeout` se establece en 900 segundos. La propiedad `Role` utiliza la función `Fn::GetAtt` para obtener el ARN del rol de ejecución `LambdaExecutionRole` que se declara en el recurso `AWS::IAM::Role` en la plantilla. La propiedad `Code` define el código de la función en línea mediante una función de Python. La función de Python en la plantilla de ejemplo hace lo siguiente: + Crear un ID único utilizando el UUID + Verifica si se trata de una solicitud de creación o de actualización + Duerme durante el tiempo especificado por `ServiceTimeout` durante solicitudes de `Create` o `Update` + Devuelve el tiempo de espera y el identificador único ### JSON ``` ... "CFNWaiter": { "Type": "AWS::Lambda::Function", "Properties": { "Handler": "index.handler", "Runtime": "python3.9", "Timeout": 900, "Role": { "Fn::GetAtt": ["LambdaExecutionRole", "Arn"] }, "Code": { "ZipFile": { "Fn::Join": ["\n", [ "from time import sleep", "import json", "import cfnresponse", "import uuid", "", "def handler(event, context):", " wait_seconds = 0", " id = str(uuid.uuid1())", " if event[\"RequestType\"] in [\"Create\", \"Update\"]:", " wait_seconds = int(event[\"ResourceProperties\"].get(\"ServiceTimeout\", 0))", " sleep(wait_seconds)", " response = {", " \"TimeWaited\": wait_seconds,", " \"Id\": id ", " }", " cfnresponse.send(event, context, cfnresponse.SUCCESS, response, \"Waiter-\"+id)" ]]} } } }, ... ``` ### YAML ``` ... CFNWaiter: Type: AWS::Lambda::Function Properties: Handler: index.handler Runtime: python3.9 Timeout: 900 Role: !GetAtt LambdaExecutionRole.Arn Code: ZipFile: !Sub | from time import sleep import json import cfnresponse import uuid ​ def handler(event, context): wait_seconds = 0 id = str(uuid.uuid1()) if event["RequestType"] in ["Create", "Update"]: wait_seconds = int(event["ResourceProperties"].get("ServiceTimeout", 0)) sleep(wait_seconds) response = { "TimeWaited": wait_seconds, "Id": id } cfnresponse.send(event, context, cfnresponse.SUCCESS, response, "Waiter-"+id) ... ``` `LambdaExecutionRole` del recurso [AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html) El recurso `AWS::IAM:Role` crea un rol de ejecución para la función de Lambda, con una política de asunción que autoriza a Lambda a utilizar dicho rol. También contiene una política que permite el acceso a Registros de CloudWatch. ### JSON ``` ... "LambdaExecutionRole": { "Type": "AWS::IAM::Role", "Properties": { "AssumeRolePolicyDocument": { "Statement": [{ "Effect": "Allow", "Principal": { "Service": ["lambda.amazonaws.com"] }, "Action": ["sts:AssumeRole"] }] }, "Path": "/", "Policies": [{ "PolicyName": "AllowLogs", "PolicyDocument": { "Statement": [{ "Effect": "Allow", "Action": ["logs:*"], "Resource": "*" }] } }] } }, ... ``` ### YAML ``` ... LambdaExecutionRole: Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Statement: - Effect: "Allow" Principal: Service: - "lambda.amazonaws.com" Action: - "sts:AssumeRole" Path: "/" Policies: - PolicyName: "AllowLogs" PolicyDocument: Statement: - Effect: "Allow" Action: - "logs:*" Resource: "*" ... ``` `CFNWaiterCustomResource` de recurso [AWS::CloudFormation::CustomResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-customresource.html) El recurso personalizado se vincula a la función de Lambda con su ARN mediante `!GetAtt CFNWaiter.Arn`. Establecerá un tiempo de espera de 60 segundos para las operaciones de creación y actualización, conforme a lo dispuesto en `ServiceTimeout`. El recurso solo se invocará para una operación de actualización si se modifican las propiedades. ### JSON ``` ... "CFNWaiterCustomResource": { "Type": "AWS::CloudFormation::CustomResource", "Properties": { "ServiceToken": { "Fn::GetAtt": ["CFNWaiter", "Arn"] }, "ServiceTimeout": 60 } } }, ... ``` ### YAML ``` ... CFNWaiterCustomResource: Type: AWS::CloudFormation::CustomResource Properties: ServiceToken: !GetAtt CFNWaiter.Arn ServiceTimeout: 60 ... ``` `Outputs` Esta plantilla produce como `Outputs` el `TimeWaited` y el `WaiterId`. El valor `TimeWaited` utiliza una función de `Fn::GetAtt` para indicar la cantidad de tiempo que el recurso de espera realmente esperó. El `WaiterId` utiliza una función de `Fn::GetAtt` para proporcionar el identificador único que se generó y se asoció a la ejecución. ### JSON ``` ... "Outputs": { "TimeWaited": { "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "TimeWaited"] }, "Export": { "Name": "TimeWaited" } }, "WaiterId": { "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "Id"] }, "Export": { "Name": "WaiterId" } } } } ... ``` ### YAML ``` ... Outputs: TimeWaited: Value: !GetAtt CFNWaiterCustomResource.TimeWaited Export: Name: TimeWaited WaiterId: Value: !GetAtt CFNWaiterCustomResource.Id Export: Name: WaiterId ... ``` ## Requisitos previos Se necesitan permisos de IAM para utilizar todos los servicios correspondientes, como Lambda y CloudFormation. ## Lanzamiento de la pila **Para crear la pila** 1. Busque la plantilla que prefiera (YAML o JSON) en la sección [Plantilla de muestra](#walkthrough-lambda-backed-custom-resources-sample-template) y guárdela en la máquina con el nombre `samplelambdabackedcustomresource.template`. 1. Abra la consola de CloudFormation en [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/). 1. En la página **Pilas**, seleccione **Crear pila** en la parte superior derecha y, a continuación, seleccione **Con recursos nuevos (estándar)**. 1. En **Requisito previo: preparar la plantilla**, elija **Seleccione una plantilla existente**. 1. En **Especificar plantilla**, seleccione **Cargar un archivo de plantilla** y, a continuación, elija **Elegir archivo**. 1. Seleccione el archivo de plantilla `samplelambdabackedcustomresource.template` que guardó anteriormente. 1. Elija **Siguiente**. 1. En **Nombre de la pila**, escriba **SampleCustomResourceStack** y, a continuación, elija **Siguiente**. 1. Para este tutorial, no tiene que añadir etiquetas ni especificar una configuración avanzada, así que elija **Next (Siguiente)**. 1. Verifique que el nombre de la pila sea correcto y luego seleccione **Crear**. CloudFormation puede tardar varios minutos en crear la pila. Para monitorizar el progreso, vea los eventos de la pila. Para obtener más información, consulte [Visualización de la información de la pila desde la consola de CloudFormation](cfn-console-view-stack-data-resources.md). Si se crea la pila correctamente, se crean todos los recursos de la pila, como la función Lambda y el recurso personalizado. Ha utilizado correctamente una función de Lambda y un recurso personalizado. Si la función de Lambda devuelve un error, vea los registros de la función en la [consola](https://console.aws.amazon.com/cloudwatch/home#logs:) de Registros de CloudWatch. El nombre de la flujo de registros es el ID físico del recurso personalizado, que puede encontrar al visualizar los recursos de la pila. Para obtener más información, consulte la sección de [Visualización de datos de registro](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) en la *Guía del usuario de Amazon CloudWatch*. ## Saneamiento de recursos Elimine la pila para limpiar todos los recursos de la pila que creó para que no se le cobren los recursos innecesarios. **Para eliminar la pila** 1. En la consola de CloudFormation, elija la pila **SampleCustomResourceStack**. 1. Elija **Actions (Acciones)** y, a continuación, **Delete Stack (Eliminar pila)**. 1. En el mensaje de confirmación, elija **Yes, Delete (Sí, eliminar)**. Se eliminan todos los recursos que creó. Ahora que comprende cómo crear y utilizar un recurso personalizado respaldado por Lambda, puede utilizar la plantilla y el código de ejemplo de esta guía para crear y experimentar con otras pilas y funciones. ## Información relacionada + [Referencia de recursos personalizados de CloudFormation](crpg-ref.md) + [AWS::CloudFormation::CustomResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-customresource.html)